feat: update math/base/assert TypeScript declarations

Planeshifter · Planeshifter · commit 03d8378be4d5 · 2025-09-21T12:33:49.000-05:00
---
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: na
  - 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
---
diff --git a/lib/node_modules/@stdlib/math/base/assert/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/assert/docs/types/index.d.ts
@@ -25,28 +25,34 @@ import isOddInt32 = require( '@stdlib/math/base/assert/int32-is-odd' );
 import isComposite = require( '@stdlib/math/base/assert/is-composite' );
 import isCoprime = require( '@stdlib/math/base/assert/is-coprime' );
 import isEven = require( '@stdlib/math/base/assert/is-even' );
+import isEvenf = require( '@stdlib/math/base/assert/is-evenf' );
 import isFinite = require( '@stdlib/math/base/assert/is-finite' );
 import isFinitef = require( '@stdlib/math/base/assert/is-finitef' );
 import isInfinite = require( '@stdlib/math/base/assert/is-infinite' );
 import isInfinitef = require( '@stdlib/math/base/assert/is-infinitef' );
 import isInteger = require( '@stdlib/math/base/assert/is-integer' );
+import isIntegerf = require( '@stdlib/math/base/assert/is-integerf' );
 import isnan = require( '@stdlib/math/base/assert/is-nan' );
 import isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 import isNegativeFinite = require( '@stdlib/math/base/assert/is-negative-finite' );
 import isNegativeInteger = require( '@stdlib/math/base/assert/is-negative-integer' );
+import isNegativeIntegerf = require( '@stdlib/math/base/assert/is-negative-integerf' );
 import isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
 import isNegativeZerof = require( '@stdlib/math/base/assert/is-negative-zerof' );
 import isNonNegativeFinite = require( '@stdlib/math/base/assert/is-nonnegative-finite' );
 import isNonNegativeInteger = require( '@stdlib/math/base/assert/is-nonnegative-integer' );
+import isNonnegativeIntegerf = require( '@stdlib/math/base/assert/is-nonnegative-integerf' );
 import isNonPositiveFinite = require( '@stdlib/math/base/assert/is-nonpositive-finite' );
 import isNonPositiveInteger = require( '@stdlib/math/base/assert/is-nonpositive-integer' );
 import isOdd = require( '@stdlib/math/base/assert/is-odd' );
+import isOddf = require( '@stdlib/math/base/assert/is-oddf' );
 import isPositiveFinite = require( '@stdlib/math/base/assert/is-positive-finite' );
 import isPositiveInteger = require( '@stdlib/math/base/assert/is-positive-integer' );
 import isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
 import isPositiveZerof = require( '@stdlib/math/base/assert/is-positive-zerof' );
 import isPrime = require( '@stdlib/math/base/assert/is-prime' );
 import isProbability = require( '@stdlib/math/base/assert/is-probability' );
+import isProbabilityf = require( '@stdlib/math/base/assert/is-probabilityf' );
 import isSafeInteger = require( '@stdlib/math/base/assert/is-safe-integer' );
 import isPow2Uint32 = require( '@stdlib/math/base/assert/uint32-is-pow2' );
 
@@ -155,6 +161,34 @@ interface Namespace {
 	*/
 	isEven: typeof isEven;
 
+	/**
+	* Tests if a finite single-precision floating-point number is an even number.
+	*
+	* ## Notes
+	*
+	* -   The function assumes a finite number. If provided positive or negative infinity, the function will return `true`, when, in fact, the result is undefined.
+	*
+	* @param x - value to test
+	* @returns boolean indicating whether the value is an even number
+	*
+	* @example
+	* var bool = ns.isEvenf( 5.0 );
+	* // returns false
+	*
+	* @example
+	* var bool = ns.isEvenf( -2.0 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isEvenf( 0.0 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isEvenf( NaN );
+	* // returns false
+	*/
+	isEvenf: typeof isEvenf;
+
 	/**
 	* Tests if a double-precision floating-point numeric value is finite.
 	*
@@ -271,6 +305,26 @@ interface Namespace {
 	*/
 	isInteger: typeof isInteger;
 
+	/**
+	* Tests if a finite single-precision floating-point number is an integer.
+	*
+	* ## Notes
+	*
+	* -   The function assumes a finite number. If provided positive or negative infinity, the function will return `true`, when, in fact, the result is undefined.
+	*
+	* @param x - value to test
+	* @returns boolean indicating whether the value is an integer
+	*
+	* @example
+	* var bool = ns.isIntegerf( 1.0 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isIntegerf( 3.14 );
+	* // returns false
+	*/
+	isIntegerf: typeof isIntegerf;
+
 	/**
 	* Tests if a double-precision floating-point numeric value is `NaN`.
 	*
@@ -355,6 +409,26 @@ interface Namespace {
 	*/
 	isNegativeInteger: typeof isNegativeInteger;
 
+	/**
+	* Tests if a finite single-precision floating-point number is a negative integer.
+	*
+	* @param x - value to test
+	* @returns boolean indicating whether the value is a negative integer
+	*
+	* @example
+	* var bool = ns.isNegativeIntegerf( -1.0 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isNegativeIntegerf( 0.0 );
+	* // returns false
+	*
+	* @example
+	* var bool = ns.isNegativeIntegerf( 10.0 );
+	* // returns false
+	*/
+	isNegativeIntegerf: typeof isNegativeIntegerf;
+
 	/**
 	* Tests if a double-precision floating-point numeric value is negative zero.
 	*
@@ -444,6 +518,31 @@ interface Namespace {
 	*/
 	isNonNegativeInteger: typeof isNonNegativeInteger;
 
+	/**
+	* Tests if a finite single-precision floating-point number is a nonnegative integer.
+	*
+	* ## Notes
+	*
+	* -   The function assumes a finite number. If provided positive infinity, the function will return `true`, when, in fact, the result is undefined.
+	* -   The function does not distinguish between positive and negative zero.
+	*
+	* @param x - value to test
+	* @returns boolean indicating whether the value is a nonnegative integer
+	*
+	* @example
+	* var bool = ns.isNonnegativeIntegerf( 1.0 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isNonnegativeIntegerf( 0.0 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isNonnegativeIntegerf( -10.0 );
+	* // returns false
+	*/
+	isNonnegativeIntegerf: typeof isNonnegativeIntegerf;
+
 	/**
 	* Tests if a double-precision floating-point numeric value is a nonpositive finite number.
 	*
@@ -525,6 +624,34 @@ interface Namespace {
 	*/
 	isOdd: typeof isOdd;
 
+	/**
+	* Tests if a finite single-precision floating-point number is an odd number.
+	*
+	* ## Notes
+	*
+	* -   The function assumes a finite number. If provided positive or negative infinity, the function will return `true`, when, in fact, the result is undefined.
+	*
+	* @param x - value to test
+	* @returns boolean indicating whether the value is an odd number
+	*
+	* @example
+	* var bool = ns.isOddf( 5.0 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isOddf( -2.0 );
+	* // returns false
+	*
+	* @example
+	* var bool = ns.isOddf( 0.0 );
+	* // returns false
+	*
+	* @example
+	* var bool = ns.isOddf( NaN );
+	* // returns false
+	*/
+	isOddf: typeof isOddf;
+
 	/**
 	* Tests if a double-precision floating-point numeric value is a positive finite number.
 	*
@@ -653,6 +780,30 @@ interface Namespace {
 	*/
 	isProbability: typeof isProbability;
 
+	/**
+	* Tests if a single-precision floating-point number is a probability.
+	*
+	* ## Notes
+	*
+	* -   A probability is defined as a number on the closed interval `[0,1]`.
+	*
+	* @param x - value to test
+	* @returns boolean indicating whether the value is a probability
+	*
+	* @example
+	* var bool = ns.isProbabilityf( 0.5 );
+	* // returns true
+	*
+	* @example
+	* var bool = ns.isProbabilityf( 3.14 );
+	* // returns false
+	*
+	* @example
+	* var bool = ns.isProbabilityf( NaN );
+	* // returns false
+	*/
+	isProbabilityf: typeof isProbabilityf;
+
 	/**
 	* Tests if a finite double-precision floating-point number is a safe integer.
 	*
