Apply suggestions from code review

gunjjoshi · web-flow · commit 4f8b523f80cc · 2025-02-25T10:46:02.000+05:30
Signed-off-by: Gunj Joshi &lt;gunjjoshi8372@gmail.com&gt;
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/README.md b/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/README.md
@@ -105,7 +105,7 @@ for ( i = 0; i < x.length; i++ ) {
 ### Usage
 
 ```c
-#include "stdlib/math/base/special/kernel_log1p.h"
+#include "stdlib/math/base/special/kernel_log1pf.h"
 ```
 
 #### stdlib_base_kernel_log1pf( f )
@@ -153,7 +153,7 @@ int main( void ) {
     float out;
     int i;
     for ( i = 0; i < 10; i++ ) {
-        out = stdlib_base_kernel_log1p( x[ i ] );
+        out = stdlib_base_kernel_log1pf( x[ i ] );
         printf ( "x[ i ]: %f, out: %f\n", x[ i ], out );
     }
 }
@@ -171,13 +171,6 @@ int main( void ) {
 
 <section class="related">
 
-* * *
-
-## See Also
-
--   <span class="package-name">[`@stdlib/math/base/special/kernel-log1p`][@stdlib/math/base/special/kernel-log1p]</span><span class="delimiter">: </span><span class="description">Computes `log(1+f) - f` for `1+f` in `~[sqrt(2)/2, sqrt(2)]`.</span>
--   <span class="package-name">[`@stdlib/math/base/special/log1p`][@stdlib/math/base/special/log1p]</span><span class="delimiter">: </span><span class="description">evaluate the natural logarithm of 1+x.</span>
-
 </section>
 
 <!-- /.related -->
@@ -192,10 +185,6 @@ int main( void ) {
 
 <!-- <related-links> -->
 
-[@stdlib/math/base/special/kernel-log1p]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/kernel-log1p
-
-[@stdlib/math/base/special/log1p]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/log1p
-
 <!-- </related-links> -->
 
 </section>
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/benchmark/benchmark.js
@@ -22,7 +22,7 @@
 
 var bench = require( '@stdlib/bench' );
 var uniform = require( '@stdlib/random/array/uniform' );
-var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pkg = require( './../package.json' ).name;
 var kernelLog1pf = require( './../lib' );
 
@@ -39,12 +39,12 @@ bench( pkg, function benchmark( b ) {
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
 		y = kernelLog1pf( x[ i % x.length ] );
-		if ( isnan( y ) ) {
+		if ( isnanf( y ) ) {
 			b.fail( 'should not return NaN' );
 		}
 	}
 	b.toc();
-	if ( isnan( y ) ) {
+	if ( isnanf( y ) ) {
 		b.fail( 'should not return NaN' );
 	}
 	b.pass( 'benchmark finished' );
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/benchmark/benchmark.native.js
@@ -23,7 +23,7 @@
 var resolve = require( 'path' ).resolve;
 var bench = require( '@stdlib/bench' );
 var uniform = require( '@stdlib/random/array/uniform' );
-var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 var pkg = require( './../package.json' ).name;
 
@@ -48,12 +48,12 @@ bench( pkg+'::native', opts, function benchmark( b ) {
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
 		y = kernelLog1pf( x[ i % x.length ] );
-		if ( isnan( y ) ) {
+		if ( isnanf( y ) ) {
 			b.fail( 'should not return NaN' );
 		}
 	}
 	b.toc();
-	if ( isnan( y ) ) {
+	if ( isnanf( y ) ) {
 		b.fail( 'should not return NaN' );
 	}
 	b.pass( 'benchmark finished' );
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/benchmark/c/native/benchmark.c b/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/benchmark/c/native/benchmark.c
@@ -91,9 +91,9 @@ static double rand_float( void ) {
 */
 static double benchmark( void ) {
 	double elapsed;
-	double x[ 100 ];
-	double z;
+	float x[ 100 ];
 	double t;
+	float z;
 	int i;
 
 	for ( i = 0; i < 100; i++ ) {
@@ -102,7 +102,7 @@ static double benchmark( void ) {
 
 	t = tic();
 	for ( i = 0; i < ITERATIONS; i++ ) {
-		z = stdlib_base_kernel_log1pf( x[ i%100 ] );
+		z = stdlib_base_kernel_log1pf( x[ i % 100 ] );
 		if ( z != z ) {
 			printf( "should not return NaN\n" );
 			break;
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/lib/main.js b/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/lib/main.js
@@ -43,6 +43,79 @@ var polyvalQ = require( './polyval_q.js' );
 /**
 * Computes `logf(1+f) - f` for `1+f` in `~[sqrtf(2)/2, sqrtf(2)]`.
 *
+* ## Method
+*
+* This function is a helper function for computing logarithms in base \\(e\\), and what follows describes the overall strategy for doing so. The argument reduction and adding the final term of the polynomial are done by the caller for increased accuracy when different bases are used.
+*
+* 1.  Argument Reduction. Find \\(k\\) and \\(f\\) such that
+*
+*     ```tex
+*     x = 2^k \cdot (1+f)
+*     ```
+*
+*     where \\(\sqrt(2)/2 < 1+f < \sqrt(2)\\).
+*
+* 2.  Approximation of \\(\operatorname{log}(1+f)\\). Let
+*
+*     ```tex
+*     \begin{align*}
+*     s &= \frac{f}{2+f} \\
+*     &= 2s + \frac{2}{3} s^3 + \frac{2}{5} s^5 + \ldots \\
+*     &= 2s + s R
+*     \end{align*}
+*     ```
+*
+*     based on
+*
+*     ```tex
+*     \operatorname{log}(1+f) &= \operatorname{log}(1+s) - \operatorname{log}(1-s)
+*     ```
+*
+*     We use a special Reme algorithm on \\(\[0,0.1716]\\) to generate a polynomial of degree \\(14\\) to approximate \\(R\\). The maximum error of this polynomial approximation is bounded by \\(2^{-58.45}\\). In other words,
+*
+*     ```tex
+*     R(z) ~ L_{g1} s^2 + L_{g2} s^4 + L_{g3} s^6 + L_{g4} s^8 + L_{g5} s^{10} + L_{g6} s^{12} + L_{g7} s^{14}
+*     ```
+*
+*     where the values of \\(L_{g1}\\) to \\(L_{g7}\\) are the polynomial coefficients used in the program below and
+*
+*     ```tex
+*     L_{g1} s^2 + \ldots + L_{g7} s^{14} - R(z) \leq 2^{-58.45}
+*     ```
+*
+*     Note that
+*
+*     ```tex
+*     2s = f - s \cdot f = f - h_{fsq} + (s \cdot h_{fsq})
+*     ```
+*
+*     where \\(h_{fsq} = f^{2}/2\\).
+*
+*     In order to guarantee an error in \\(\operatorname{log}\\) below 1 ulp, we compute \\(\operatorname{log}\\) by
+*
+*     ```tex
+*     \begin{align*}
+*     \operatorname{log}(1+f) &= f - s (f - R) & \textrm{(if f is not too large)} \\
+*     \operatorname{log}(1+f) &= f - (h_{fsq} - s (h_{fsq}+R)) & \textrm{(better accuracy)}
+*     \end{align*}
+*
+* 3.  Finally,
+*
+*     ```tex
+*     \begin{align*}
+*     \operatorname{log}(x) &= k \cdot \operatorname{ln2} + \operatorname{log}(1+f) \\
+*     &= k \cdot \operatorname{ln2}_{hi} + (f-(h_{fsq}-(s \cdot (h_{fsq}+R) + k \cdot \operatorname{ln2}_{lo})))
+*     \end{align*}
+*     ```
+*
+*     Here, \\(\operatorname{ln2}\\) is split into two floating point numbers:
+*
+*     ```tex
+*     \operatorname{ln2} = \operatorname{ln2}_{hi} + \operatorname{ln2}_{lo}
+*     ```
+*
+*     where \\(n \cdot \operatorname{ln2}_{hi}\\) is always exact for \\(|n| < 2000\\).
+*
 * @param {number} f - input value
 * @returns {number} function value
 *
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/src/main.c b/lib/node_modules/@stdlib/math/base/special/kernel-log1pf/src/main.c
@@ -80,6 +80,79 @@ static float polyval_q( const float x ) {
 /**
 * Computes `logf(1+f) - f` for `1+f` in `~[sqrtf(2)/2, sqrtf(2)]`.
 *
+* ## Method
+*
+* This function is a helper function for computing logarithms in base \\(e\\), and what follows describes the overall strategy for doing so. The argument reduction and adding the final term of the polynomial are done by the caller for increased accuracy when different bases are used.
+*
+* 1.  Argument Reduction. Find \\(k\\) and \\(f\\) such that
+*
+*     ```tex
+*     x = 2^k \cdot (1+f)
+*     ```
+*
+*     where \\(\sqrt(2)/2 < 1+f < \sqrt(2)\\).
+*
+* 2.  Approximation of \\(\operatorname{log}(1+f)\\). Let
+*
+*     ```tex
+*     \begin{align*}
+*     s &= \frac{f}{2+f} \\
+*     &= 2s + \frac{2}{3} s^3 + \frac{2}{5} s^5 + \ldots \\
+*     &= 2s + s R
+*     \end{align*}
+*     ```
+*
+*     based on
+*
+*     ```tex
+*     \operatorname{log}(1+f) &= \operatorname{log}(1+s) - \operatorname{log}(1-s)
+*     ```
+*
+*     We use a special Reme algorithm on \\(\[0,0.1716]\\) to generate a polynomial of degree \\(14\\) to approximate \\(R\\). The maximum error of this polynomial approximation is bounded by \\(2^{-58.45}\\). In other words,
+*
+*     ```tex
+*     R(z) ~ L_{g1} s^2 + L_{g2} s^4 + L_{g3} s^6 + L_{g4} s^8 + L_{g5} s^{10} + L_{g6} s^{12} + L_{g7} s^{14}
+*     ```
+*
+*     where the values of \\(L_{g1}\\) to \\(L_{g7}\\) are the polynomial coefficients used in the program below and
+*
+*     ```tex
+*     L_{g1} s^2 + \ldots + L_{g7} s^{14} - R(z) \leq 2^{-58.45}
+*     ```
+*
+*     Note that
+*
+*     ```tex
+*     2s = f - s \cdot f = f - h_{fsq} + (s \cdot h_{fsq})
+*     ```
+*
+*     where \\(h_{fsq} = f^{2}/2\\).
+*
+*     In order to guarantee an error in \\(\operatorname{log}\\) below 1 ulp, we compute \\(\operatorname{log}\\) by
+*
+*     ```tex
+*     \begin{align*}
+*     \operatorname{log}(1+f) &= f - s (f - R) & \textrm{(if f is not too large)} \\
+*     \operatorname{log}(1+f) &= f - (h_{fsq} - s (h_{fsq}+R)) & \textrm{(better accuracy)}
+*     \end{align*}
+*
+* 3.  Finally,
+*
+*     ```tex
+*     \begin{align*}
+*     \operatorname{log}(x) &= k \cdot \operatorname{ln2} + \operatorname{log}(1+f) \\
+*     &= k \cdot \operatorname{ln2}_{hi} + (f-(h_{fsq}-(s \cdot (h_{fsq}+R) + k \cdot \operatorname{ln2}_{lo})))
+*     \end{align*}
+*     ```
+*
+*     Here, \\(\operatorname{ln2}\\) is split into two floating point numbers:
+*
+*     ```tex
+*     \operatorname{ln2} = \operatorname{ln2}_{hi} + \operatorname{ln2}_{lo}
+*     ```
+*
+*     where \\(n \cdot \operatorname{ln2}_{hi}\\) is always exact for \\(|n| < 2000\\).
+*
 * @param f    input value
 * @return     output value
 *
