Skip to content

Commit e6cb1fe

Browse files
nirmaljbnirmaljb
committed
fix: update the namespace to correct convention
--- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed ---
1 parent 8165e41 commit e6cb1fe

2 files changed

Lines changed: 107 additions & 107 deletions

File tree

‎lib/node_modules/@stdlib/math/base/special/kernel-betainc/test/test.js‎

Lines changed: 54 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
/**
22
* @license Apache-2.0
33
*
4-
* Copyright (c) 2018 The Stdlib Authors.
4+
* Copyright (c) 2026 The Stdlib Authors.
55
*
66
* Licensed under the Apache License, Version 2.0 (the "License");
77
* you may not use this file except in compliance with the License.
@@ -209,22 +209,22 @@ tape( 'the function handles the `a=1` branch', function test( t ) {
209209
var val;
210210

211211
val = kernelBetainc( 0.25, 1.0, 2.0, true, false );
212-
t.strictEqual( val[ 0 ], 0.4375, 'returns expected lower regularized value' );
213-
t.strictEqual( val[ 1 ], 1.5, 'returns expected regularized derivative for lower regularized value' );
212+
t.strictEqual( val[ 0 ], 0.4375, 'returns expected value for lower regularized endpoint' );
213+
t.strictEqual( val[ 1 ], 1.5, 'returns expected regularized derivative for lower regularized endpoint' );
214214

215215
val = kernelBetainc( 0.25, 1.0, 2.0, true, true );
216-
t.strictEqual( val[ 0 ], 0.5625, 'returns expected upper regularized value' );
217-
t.strictEqual( val[ 1 ], 1.5, 'returns expected regularized derivative for upper regularized value' );
216+
t.strictEqual( val[ 0 ], 0.5625, 'returns expected value for upper regularized endpoint' );
217+
t.strictEqual( val[ 1 ], 1.5, 'returns expected regularized derivative for upper regularized endpoint' );
218218

219219
val = kernelBetainc( 0.25, 1.0, 2.0, false, false );
220-
t.strictEqual( val[ 0 ], 0.21875, 'returns expected lower unregularized value' );
220+
t.strictEqual( val[ 0 ], 0.21875, 'returns expected value for lower unregularized endpoint' );
221221

222222
val = kernelBetainc( 0.25, 1.0, 2.0, false, true );
223-
t.strictEqual( val[ 0 ], 0.28125, 'returns expected upper unregularized value' );
223+
t.strictEqual( val[ 0 ], 0.28125, 'returns expected value for upper unregularized endpoint' );
224224

225-
val = kernelBetainc( 32/100, 1, 4634/100000, true, false );
225+
val = kernelBetainc( 32/100, 1.0, 4634/100000, true, false );
226226
expected = 0.017712849440718489999419956301675684844663359595318;
227-
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'within tolerance.' );
227+
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'returns expected value' );
228228

229229
t.end();
230230
});
@@ -236,47 +236,47 @@ tape( 'the function evaluates the lower regularized incomplete beta function for
236236

237237
val = kernelBetainc( 6917/10000, 159/10000, 1184/1000000000, true, false );
238238
expected = 0.000075393541456247525676062058821484095548666733251733;
239-
t.strictEqual( isAlmostSameValue( val[0], expected, 3 ), true, 'within tolerance.' );
239+
t.strictEqual( isAlmostSameValue( val[0], expected, 3 ), true, 'returns expected value' );
240240

241241
val = kernelBetainc( 9157/10000, 4243/100, 3001/10000, true, false );
242242
expected = 0.0028387319012616013434124297160711532419664289474798;
243-
t.strictEqual( isAlmostSameValue( val[0], expected, 16 ), true, 'within tolerance.' );
243+
t.strictEqual( isAlmostSameValue( val[0], expected, 16 ), true, 'returns expected value' );
244244

245245
val = kernelBetainc( 8391/100000, 9713/1000, 9940/100, true, false );
246246
expected = 0.46116895440368248909937863372410093344466819447476;
247-
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'within tolerance.' );
247+
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'returns expected value' );
248248

249249
val = kernelBetainc( 0.75, 72.5, 1.125, true, false );
250250
expected = 1.3423066982487051710597194786268004978931316494920e-9;
251-
t.strictEqual( isAlmostSameValue( val[0], expected, 11 ), true, 'within tolerance.' );
251+
t.strictEqual( isAlmostSameValue( val[0], expected, 11 ), true, 'returns expected value' );
252252

253253
val = kernelBetainc( 7599/10000, 4985/1000, 1066/1000, true, false );
254254
expected = 0.27533431334486812211032939156910472371928659321347;
255-
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'within tolerance.' );
255+
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'returns expected value' );
256256

257257
val = kernelBetainc( 1741/10000, 6813/1000, 1056/1000, true, false );
258258
expected = 7.6736128722762245852815040810349072461658078840945e-6;
259-
t.strictEqual( isAlmostSameValue( val[0], expected, 7 ), true, 'within tolerance.' );
259+
t.strictEqual( isAlmostSameValue( val[0], expected, 7 ), true, 'returns expected value' );
260260

261261
val = kernelBetainc( 2003/10000, 4898/10000, 2251/10000, true, false );
262262
expected = 0.17089223868046209692215231702890838878342349377008;
263-
t.strictEqual( isAlmostSameValue( val[0], expected, 2 ), true, 'within tolerance.' );
263+
t.strictEqual( isAlmostSameValue( val[0], expected, 2 ), true, 'returns expected value' );
264264

265265
val = kernelBetainc( 6537/10000, 4049/1000, 1540/10000, true, false );
266266
expected = 0.017273988301528087878279199511703371301647583919670;
267-
t.strictEqual( isAlmostSameValue( val[0], expected, 10 ), true, 'within tolerance.' );
267+
t.strictEqual( isAlmostSameValue( val[0], expected, 10 ), true, 'returns expected value' );
268268

269269
val = kernelBetainc( 8003/10000, 7269/1000, 1190/10000, true, false );
270270
expected = 0.013334694467796052900138431733772122625376753696347;
271-
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'within tolerance.' );
271+
t.strictEqual( isAlmostSameValue( val[0], expected, 1 ), true, 'returns expected value' );
272272

273273
val = kernelBetainc( 8665/100000, 2726/1000, 1151/100000, true, false );
274274
expected = 5.8218877068298586420691288375690562915515260230173e-6;
275-
t.strictEqual( isAlmostSameValue( val[0], expected, 5 ), true, 'within tolerance.' );
275+
t.strictEqual( isAlmostSameValue( val[0], expected, 5 ), true, 'returns expected value' );
276276

277277
val = kernelBetainc( 7582/10000, 3431/10000, 4634/100000, true, false );
278278
expected = 0.15132819929418661038699397753916091907278005695387;
279-
t.strictEqual( isAlmostSameValue( val[0], expected, 2 ), true, 'within tolerance.' );
279+
t.strictEqual( isAlmostSameValue( val[0], expected, 2 ), true, 'returns expected value' );
280280

281281
t.end();
282282
});
@@ -287,19 +287,19 @@ tape( 'the function evaluates the lower regularized incomplete beta function for
287287

288288
val = kernelBetainc( 0.25, 3, 8, true, false );
289289
expected = 0.474407196044921875;
290-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
290+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
291291

292292
val = kernelBetainc( 0.25, 6, 8, true, false );
293293
expected = 0.080212593078613281250;
294-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
294+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
295295

296296
val = kernelBetainc( 0.25, 12, 1, true, false );
297297
expected = 5.96046447753906250e-8;
298-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
298+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
299299

300300
val = kernelBetainc( 0.25, 1, 8, true, false );
301301
expected = 0.899887084960937500;
302-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
302+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
303303

304304
t.end();
305305
});
@@ -310,38 +310,38 @@ tape( 'the function handles the `a=0.5` and `b=0.5` cases', function test( t ) {
310310

311311
val = kernelBetainc( 0.25, 0.5, 0.5, true, false );
312312
expected = 1.0 / 3.0;
313-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected lower regularized value.' );
313+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
314314

315315
expected = sqrt( 3.0 ) / ( 4.0 * PI );
316-
t.strictEqual( isAlmostSameValue( val[ 1 ], expected, 1 ), true, 'returns expected regularized derivative for lower branch value.' );
316+
t.strictEqual( isAlmostSameValue( val[ 1 ], expected, 1 ), true, 'returns expected value' );
317317

318318
val = kernelBetainc( 0.25, 0.5, 0.5, true, true );
319319
expected = 2.0 / 3.0;
320-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected upper regularized value.' );
320+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
321321

322322
expected = PI / 3.0;
323323
val = kernelBetainc( 0.25, 0.5, 0.5, false, false );
324-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected lower unregularized value.' );
324+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
325325

326326
expected = 2.0 * PI / 3.0;
327327
val = kernelBetainc( 0.25, 0.5, 0.5, false, true );
328-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected upper unregularized value.' );
328+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
329329

330330
val = kernelBetainc( 0.125, 0.5, 0.5, true, false );
331331
expected = 0.230053456162615885213780567705142893009911395270714102055874;
332-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected lower regularized value.' );
332+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
333333

334334
val = kernelBetainc( 0.125, 0.5, 0.5, true, true );
335335
expected = 0.769946543837384114786219432294857106990088604729285897944125;
336-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected upper regularized value.' );
336+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
337337

338338
val = kernelBetainc( 0.825, 0.5, 0.5, true, false );
339339
expected = 0.725231121519469565327291851560156562956885802608457839260161;
340-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected lower regularized value.' );
340+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
341341

342342
val = kernelBetainc( 0.825, 0.5, 0.5, true, true );
343343
expected = 0.274768878480530434672708148439843437043114197391542160739838;
344-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected upper regularized value.' );
344+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
345345

346346
t.end();
347347
});
@@ -366,19 +366,19 @@ tape( 'the function handles the `b=1` special cases', function test( t ) {
366366

367367
val = kernelBetainc( 0.825, 0.5, 1, true, false );
368368
expected = 0.908295106229247499626759842915458109758420750043003849691665;
369-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected lower regularized value.' );
369+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
370370

371371
val = kernelBetainc( 0.825, 0.5, 1, true, true );
372372
expected = 0.091704893770752500373240157084541890241579249956996150308334;
373-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 2 ), true, 'returns expected upper regularized value.' );
373+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 2 ), true, 'returns expected value' );
374374

375375
val = kernelBetainc( 0.825, 30, 1, true, false );
376376
expected = 0.003116150729395132012981654047222541793435357905008020740211;
377-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 16 ), true, 'returns expected lower regularized value.' );
377+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 16 ), true, 'returns expected value' );
378378

379379
val = kernelBetainc( 0.825, 30, 1, true, true );
380380
expected = 0.996883849270604867987018345952777458206564642094991979259788;
381-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected upper regularized value.' );
381+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
382382

383383
t.end();
384384
});
@@ -395,29 +395,29 @@ tape( 'the function handles extreme x values (Rocco Romeo bug cases)', function
395395
x0 = ldexp( 1.0, -52 );
396396
val = kernelBetainc( x0, 2, 24, false, false );
397397
expected=2.46519032881565349871772482100516780410072110983579277754743e-32;
398-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 2 ), true, 'within tolerance.' );
398+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 2 ), true, 'returns expected value' );
399399

400400
val = kernelBetainc( x0, 2, 24, true, false );
401401
expected=1.47911419728939209923063489260310068246043266590147566652846e-29;
402-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
402+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
403403

404404
x0 = ldexp( 1.0, -270 );
405405
val = kernelBetainc( x0, 3, 2, false, false );
406406
expected=4.88182556606650701438035298707052523938789614661168065734809e-245;
407-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
407+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
408408

409409
val = kernelBetainc( x0, 3, 2, true, false );
410410
expected=5.85819067927980841725642358448463028726547537593401678881771e-244;
411-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
411+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
412412

413413
x0 = ldexp( 1.0, -373 );
414414
val = kernelBetainc( x0, 2, 31, false, false );
415415
expected=1.35080680244581673116149460571129957689952846520037541640260e-225;
416-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 12 ), true, 'within tolerance.' );
416+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 12 ), true, 'returns expected value' );
417417

418418
val = kernelBetainc( x0, 2, 31, true, false );
419419
expected=1.34000034802625019731220264886560918028433223747877241307138e-222;
420-
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'within tolerance.' );
420+
t.strictEqual( isAlmostSameValue( val[ 0 ], expected, 1 ), true, 'returns expected value' );
421421

422422
t.end();
423423
});
@@ -428,7 +428,7 @@ tape( 'the function returns the correct derivative for a naive analytical check'
428428

429429
val = kernelBetainc( 0.5, 2, 3, true, false );
430430
expected = 1.5;
431-
t.strictEqual( isAlmostSameValue( val[ 1 ], expected, 1 ), true, 'within tolerance.' );
431+
t.strictEqual( isAlmostSameValue( val[ 1 ], expected, 1 ), true, 'returns expected value' );
432432

433433
t.end();
434434
});
@@ -468,7 +468,7 @@ tape( 'the function evaluates the lower regularized incomplete beta function for
468468
sb = smallRange.b;
469469
for ( i = 0; i < sv.length; i++ ) {
470470
y = kernelBetainc( sv[i], sa[i], sb[i], true, false )[0];
471-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 19 ), true, 'within tolerance' );
471+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 19 ), true, 'returns expected value' );
472472
}
473473
t.end();
474474
});
@@ -487,7 +487,7 @@ tape( 'the function evaluates the upper regularized incomplete beta function for
487487
sb = smallRange.b;
488488
for ( i = 0; i < sv.length; i++ ) {
489489
y = kernelBetainc( sv[i], sa[i], sb[i], true, true )[0];
490-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 29 ), true, 'within tolerance' );
490+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 29 ), true, 'returns expected value' );
491491
}
492492
t.end();
493493
});
@@ -506,7 +506,7 @@ tape( 'the function evaluates the lower regularized incomplete beta function for
506506
mb = mediumRange.b;
507507
for ( i = 0; i < mv.length; i++ ) {
508508
y = kernelBetainc( mv[i], ma[i], mb[i], true, false )[0];
509-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 162 ), true, 'within tolerance' );
509+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 162 ), true, 'returns expected value' );
510510
}
511511
t.end();
512512
});
@@ -525,7 +525,7 @@ tape( 'the function evaluates the upper regularized incomplete beta function for
525525
mb = mediumRange.b;
526526
for ( i = 0; i < mv.length; i++ ) {
527527
y = kernelBetainc( mv[i], ma[i], mb[i], true, true )[0];
528-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 228 ), true, 'within tolerance' );
528+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 228 ), true, 'returns expected value' );
529529
}
530530
t.end();
531531
});
@@ -544,7 +544,7 @@ tape( 'the function evaluates the lower regularized incomplete beta function for
544544
lb = largeRange.b;
545545
for ( i = 0; i < lv.length; i++ ) {
546546
y = kernelBetainc( lv[i], la[i], lb[i], true, false )[0];
547-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 2165 ), true, 'within tolerance' );
547+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 2165 ), true, 'returns expected value' );
548548
}
549549
t.end();
550550
});
@@ -563,7 +563,7 @@ tape( 'the function evaluates the upper regularized incomplete beta function for
563563
lb = largeRange.b;
564564
for ( i = 0; i < lv.length; i++ ) {
565565
y = kernelBetainc( lv[i], la[i], lb[i], true, true )[0];
566-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 24771 ), true, 'within tolerance' );
566+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 24771 ), true, 'returns expected value' );
567567
}
568568
t.end();
569569
});
@@ -582,7 +582,7 @@ tape( 'the function evaluates the lower regularized incomplete beta function for
582582
ib = intValues.b;
583583
for ( i = 0; i < iv.length; i++ ) {
584584
y = kernelBetainc( iv[i], ia[i], ib[i], true, false )[0];
585-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 20 ), true, 'within tolerance' );
585+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 20 ), true, 'returns expected value' );
586586
}
587587
t.end();
588588
});
@@ -601,7 +601,7 @@ tape( 'the function evaluates the upper regularized incomplete beta function for
601601
ib = intValues.b;
602602
for ( i = 0; i < iv.length; i++ ) {
603603
y = kernelBetainc( iv[i], ia[i], ib[i], true, true )[0];
604-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 12 ), true, 'within tolerance' );
604+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 12 ), true, 'returns expected value' );
605605
}
606606
t.end();
607607
});
@@ -620,7 +620,7 @@ tape( 'the function evaluates the lower regularized incomplete beta function for
620620
lb = largeAsym.b;
621621
for ( i = 0; i < lv.length; i++ ) {
622622
y = kernelBetainc( lv[i], la[i], lb[i], true, false )[0];
623-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 87 ), true, 'within tolerance' );
623+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 87 ), true, 'returns expected value' );
624624
}
625625
t.end();
626626
});
@@ -639,7 +639,7 @@ tape( 'the function evaluates the upper regularized incomplete beta function for
639639
lb = largeAsym.b;
640640
for ( i = 0; i < lv.length; i++ ) {
641641
y = kernelBetainc( lv[i], la[i], lb[i], true, true )[0];
642-
t.strictEqual( isAlmostSameValue( y, expected[ i ], 69 ), true, 'within tolerance' );
642+
t.strictEqual( isAlmostSameValue( y, expected[ i ], 69 ), true, 'returns expected value' );
643643
}
644644
t.end();
645645
});

0 commit comments

Comments
 (0)