chore: minor clean-up

---
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: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - 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: passed
  - 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: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: Planeshifter

lib/node_modules/@stdlib/math/base/special/floorf/README.md

@@ -115,7 +115,7 @@ The function accepts the following arguments:
 -   **x**: `[in] float` input value.
 
 ```c
-float stdlib_base_floor( const float x );
+float stdlib_base_floorf( const float x );
 ```
 
 </section>

lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/main.js

@@ -139,7 +139,7 @@ function ibetaInvImp( a, b, p, q ) {
 		invert = true;
 	}
 	// Depending upon which approximation method we use, we may end up calculating either x or y initially (where y = 1-x):
-	x = 0.0; // Set to a safe zero to avoid a
+	x = 0.0;
 
 	// For some of the methods we can put tighter bounds on the result than simply [0,1]:
 	lower = 0.0;
@@ -241,7 +241,7 @@ function ibetaInvImp( a, b, p, q ) {
 					p = tmp;
 					invert = !invert;
 				}
-				// Try and compute the easy way first:
+				// Try to compute the easy way first:
 				bet = 0.0;
 				if ( b < 2.0 ) {
 					bet = beta( a, b );
@@ -295,7 +295,7 @@ function ibetaInvImp( a, b, p, q ) {
 		upper = xs;
 	}
 	else if ( a > 1.0 && b > 1.0 ) {
-		// Small a and b, both greater than 1, there is a point of inflection at xs, and it's complement is xs2, we must always start our iteration from the right side of the point of inflection.
+		// Small a and b, both greater than 1, there is a point of inflection at xs, and its complement is xs2, we must always start our iteration from the right side of the point of inflection.
 		xs = ( a-1.0 ) / ( a+b-2.0 );
 		xs2 = ( b-1.0 ) / ( a+b-2.0 );
 		ps = betainc( xs, a, b ) - p;

lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.js

@@ -84,7 +84,7 @@ tape( 'if evaluated at a pole (`s = 1`), the function returns `NaN`', function t
 	t.end();
 });
 
-tape( 'the function returns `1` for all input values greater or equal than `56`', function test( t ) {
+tape( 'the function returns `1` for all input values greater than or equal to `56`', function test( t ) {
 	var s;
 	var v;
 	var i;

lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.native.js

@@ -93,7 +93,7 @@ tape( 'if evaluated at a pole (`s = 1`), the function returns `NaN`', opts, func
 	t.end();
 });
 
-tape( 'the function returns `1` for all input values greater or equal than `56`', opts, function test( t ) {
+tape( 'the function returns `1` for all input values greater than or equal to `56`', opts, function test( t ) {
 	var s;
 	var v;
 	var i;

lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.loss.epsilon_insensitive.js

@@ -60,7 +60,7 @@ tape( 'the weights are unchanged for errors smaller than epsilon in magnitude (n
 	t.end();
 });
 
-tape( 'the sub-gradient of the linear loss times the learning rate is added to the weights for absolute errors greater or equal than epsilon (no regularization)', function test( t ) {
+tape( 'the sub-gradient of the linear loss times the learning rate is added to the weights for absolute errors greater than or equal to epsilon (no regularization)', function test( t ) {
 	/* eslint-disable no-underscore-dangle */
 	var expected;
 	var weights;

lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.loss.huber.js

@@ -61,7 +61,7 @@ tape( 'the sub-gradient of the squared-error loss times the learning rate is add
 	t.end();
 });
 
-tape( 'the sub-gradient of the linear loss times the learning rate is added to the weights for absolute errors greater or equal than epsilon (no regularization)', function test( t ) {
+tape( 'the sub-gradient of the linear loss times the learning rate is added to the weights for absolute errors greater than or equal to epsilon (no regularization)', function test( t ) {
 	/* eslint-disable no-underscore-dangle */
 	var expected;
 	var weights;

lib/node_modules/@stdlib/ndarray/base/assign/src/internal/sort2ins.c

@@ -26,7 +26,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *

lib/node_modules/@stdlib/ndarray/base/every/src/internal/sort2ins.c

@@ -26,7 +26,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *

lib/node_modules/@stdlib/ndarray/base/nullary-loop-interchange-order/lib/sort2ins.js

@@ -27,7 +27,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *

lib/node_modules/@stdlib/ndarray/base/nullary/src/internal/sort2ins.c

@@ -26,7 +26,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *

lib/node_modules/@stdlib/ndarray/base/unary-accumulate/src/internal/sort2ins.c

@@ -26,7 +26,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *

lib/node_modules/@stdlib/ndarray/base/unary-loop-interchange-order/lib/sort2ins.js

@@ -27,7 +27,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *

lib/node_modules/@stdlib/ndarray/base/unary/src/internal/sort2ins.c

@@ -26,7 +26,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *