refactor: JS implementation

Author: Neerajpathak07

lib/node_modules/@stdlib/math/base/special/pow/lib/y_is_huge.js

@@ -95,16 +95,16 @@ v = powf( NaN, NaN );
 
 ```javascript
 var randu = require( '@stdlib/random/base/randu' );
-var round = require( '@stdlib/math/base/special/round' );
+var roundf = require( '@stdlib/math/base/special/roundf' );
 var powf = require( '@stdlib/math/base/special/powf' );
 
 var b;
 var x;
 var i;
 
 for ( i = 0; i < 100; i++ ) {
-    b = round( randu()*10.0 );
-    x = round( randu()*10.0 ) - 5.0;
+    b = roundf( randu()*10.0 );
+    x = roundf( randu()*10.0 ) - 5.0;
     console.log( '%d^%d = %d', b, x, powf( b, x ) );
 }
 ```

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

@@ -19,15 +19,15 @@
 'use strict';
 
 var randu = require( '@stdlib/random/base/randu' );
-var round = require( '@stdlib/math/base/special/round' );
+var roundf = require( '@stdlib/math/base/special/roundf' );
 var powf = require( './../lib' );
 
 var b;
 var x;
 var i;
 
 for ( i = 0; i < 100; i++ ) {
-	b = round( randu()*10.0 );
-	x = round( randu()*10.0 ) - 5.0;
+	b = roundf( randu()*10.0 );
+	x = roundf( randu()*10.0 ) - 5.0;
 	console.log( '%d^%d = %d', b, x, powf( b, x ) );
 }

lib/node_modules/@stdlib/math/base/special/powf/examples/index.js

@@ -53,7 +53,7 @@
 
 // MODULES //
 
-var main = require( '@stdlib/math/base/special/powf/lib/log2axf' );
+var main = require( '@stdlib/math/base/special/powf/lib/log2ax' );
 
 
 // EXPORTS //

lib/node_modules/@stdlib/math/base/special/powf/lib/index.js

@@ -0,0 +1,226 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*
+* ## Notice
+*
+* The following copyright and license were part of the original implementation available as part of [FreeBSD]{@link https://svnweb.freebsd.org/base/release/9.3.0/lib/msun/src/e_powf.c}. The implementation follows the original, but has been modified for JavaScript.
+*
+* ```text
+* Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+*
+* Developed at SunPro, a Sun Microsystems, Inc. business.
+* Permission to use, copy, modify, and distribute this
+* software is freely granted, provided that this notice
+* is preserved.
+* ```
+*/
+
+'use strict';
+
+// MODULES //
+
+var fromWordf = require( '@stdlib/number/float32/base/from-word' );
+var toWordf = require( '@stdlib/number/float32/base/to-word' );
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
+var BIAS = require( '@stdlib/constants/float32/exponent-bias' );
+var polyvalL = require( './polyval_l.js' );
+
+
+// VARIABLES //
+
+// 0x007fffff = 8388607 => 0 00000000000 11111111111111111111
+var HIGH_EXP_2 = 0x007fffff; // asm type annotation
+
+// 0x00080000 = 524288 => 0 00000000000 10000000000000000000
+var HIGH_MIN_NORMAL_EXP = 0x00800000; // asm type annotation
+
+// 0x3f800000 = 1065353216 => 0 01111111000 00000000000000000000
+var HIGH_BIASED_EXP_0 = 0x3f800000; // asm type annotation
+
+// 0xfffff000 = 4294963200 => 1 11111111111 11111111111100000000
+var HIGH_BIASED_EXP_NEG_64 = 0xfffff000; // asm type annotation
+
+// 0x20000000 = 536870912 => 0 10000000000 00000000000000000000
+var HIGH_SIGNIFICAND_HALF = 0x20000000; // asm type annotation
+
+// 0x00400000 = 4194304 => 0 00000000000 10000000000000000000
+var HIGH_MIN_NORMAL_EXP_HALF = 0x00400000; // asm type annotation
+
+var HIGH_NUM_SIGNIFICAND_BITS = 23; // asm type annotation
+
+var TWO24 = 16777216.0;	// 0x4b800000
+
+// 2/(3*LN2)
+var CP = 9.6179670095e-01; // 0x3f76384f =2/(3ln2)
+
+// (float)CP
+var CP_HI = 9.6191406250e-01; // 0x3f764000 =12b cp
+
+// Low: CP_HI
+var CP_LO = -1.1736857402e-04; // 0xb8f623c6 =tail of CP_HI
+
+var BP = [
+	1.0,
+	1.5
+];
+var DP_HI = [
+	0.0,
+	5.84960938e-01 // 0x3f15c000
+];
+var DP_LO = [
+	0.0,
+	1.56322085e-06 // 0x35d1cfdc
+];
+
+
+// MAIN //
+
+/**
+* Computes \\(\operatorname{log2}(ax)\\).
+*
+* @private
+* @param {Array} out - output array
+* @param {number} ax - absolute value of `x`
+* @param {number} ahx - high word of `ax`
+* @returns {Array} output array containing a tuple comprised of high and low parts
+*
+* @example
+* var t = log2ax( [ 0.0, 0.0 ], 9.0, 1075970048 ); // => [ t1, t2 ]
+* // returns [ 3.169923782348633, 0.0000012190936795504075 ]
+*/
+function log2ax( out, ax, ahx ) {
+	var ahs;
+	var ss; // `hs + ls`
+	var s2; // `ss` squared
+	var hs;
+	var ls;
+	var ht;
+	var lt;
+	var bp; // `BP` constant
+	var dp; // `DP` constant
+	var hp;
+	var lp;
+	var hz;
+	var lz;
+	var t1;
+	var t2;
+	var t;
+	var r;
+	var u;
+	var v;
+	var n;
+	var j;
+	var k;
+
+	n = 0; // asm type annotation
+
+	// Check if `x` is subnormal...
+	if ( ahx < HIGH_MIN_NORMAL_EXP ) {
+		ax *= TWO24;
+		n -= 24; // asm type annotation
+		ahx = fromWordf( ax );
+	}
+	// Extract the unbiased exponent of `x`:
+	n += ((ahx >> HIGH_NUM_SIGNIFICAND_BITS) - BIAS); // asm type annotation
+
+	// Isolate the significand bits of `x`:
+	j = (ahx & HIGH_EXP_2); // asm type annotation
+
+	// Normalize `ahx` by setting the (biased) exponent to `127`:
+	ahx = (j | HIGH_BIASED_EXP_0); // asm type annotation
+
+	// Determine the interval of `|x|` by comparing significand bits...
+
+	// |x| < sqrt(3/2)
+	if ( j <= 0x1cc471 ) { // 0 00000000001 11001100100010001110
+		k = 0;
+	}
+	// |x| < sqrt(3)
+	else if ( j < 0x5db3d7 ) { // 0 00000000010 11101101100111110111
+		k = 1;
+	}
+	// |x| >= sqrtf(3)
+	else {
+		k = 0;
+		n += 1; // asm type annotation
+		ahx -= HIGH_MIN_NORMAL_EXP;
+	}
+	// Load the normalized float word into `|x|`:
+	ahx = float64ToFloat32( ahx );
+	ax = toWordf( ahx );
+
+	// Compute `ss = hs + ls = (x-1)/(x+1)` or `(x-1.5)/(x+1.5)`:
+	bp = float64ToFloat32( BP[ k ] ); // BP[0] = 1.0, BP[1] = 1.5
+	u = float64ToFloat32( ax - bp ); // (x-1) || (x-1.5)
+	v = float64ToFloat32( 1.0 / float64ToFloat32(ax + bp) ); // 1/(x+1) || 1/(x+1.5)
+	ss = float64ToFloat32( u * v );
+	hs = float64ToFloat32( ss );
+	ahs = fromWordf( hs );
+	ahs = float64ToFloat32( ahs & HIGH_BIASED_EXP_NEG_64 )
+	hs = toWordf( ahs );
+
+	// Compute `ht = ax + bp` High
+	ahs = ((ahx>>1) & HIGH_BIASED_EXP_NEG_64) | HIGH_SIGNIFICAND_HALF;
+	ahs += HIGH_MIN_NORMAL_EXP_HALF+(k << 21); // `(k<<21)` can be considered the word equivalent of `1.0` or `1.5`
+	ahs = float64ToFloat32( ahs );
+	ht = toWordf( ahs );
+	lt = float64ToFloat32( ax - float64ToFloat32(ht - bp) );
+	ls = float64ToFloat32( v * ( float64ToFloat32( u - float64ToFloat32(hs*ht) ) - float64ToFloat32( hs*lt ) ) ); // eslint-disable-line max-len
+
+	// Compute `log(ax)`...
+
+	s2 = float64ToFloat32( ss * ss);
+	r = float64ToFloat32( s2 * s2 * float64ToFloat32( polyvalL( s2 )));
+	r += float64ToFloat32( ls * float64ToFloat32(hs + ss));
+	s2 = float64ToFloat32( hs * hs );
+	ht = float64ToFloat32( 3.0 + s2 + r );
+	ahs = fromWordf( ht );
+	ahs = float64ToFloat32( ahs & HIGH_BIASED_EXP_NEG_64 );
+	ht = toWordf( ahs );
+	lt = float64ToFloat32( r - float64ToFloat32((ht-3.0) - s2));
+
+	// u+v = ss*(1+...):
+	u = float64ToFloat32( hs * ht );
+	v = float64ToFloat32( float64ToFloat32( ls*ht ) + float64ToFloat32( lt*ss )); // eslint-disable-line max-len
+
+	// 2/(3LN2) * (ss+...):
+	hp = u + v;
+	ahs = fromWordf( hp );
+	ahs = float64ToFloat32( ahs & HIGH_BIASED_EXP_NEG_64 );
+	hp = toWordf( ahs );
+	lp = float64ToFloat32( v - float64ToFloat32(hp - u));
+	hz = float64ToFloat32( CP_HI * hp ); // CP_HI+CP_LO = 2/(3*LN2)
+	lz = float64ToFloat32( float64ToFloat32( CP_LO*hp ) + float64ToFloat32( lp*CP ) + DP_LO[ k ]); // eslint-disable-line max-len
+
+	// log2(ax) = (ss+...)*2/(3*LN2) = n + dp + hz + lz
+	dp = float64ToFloat32( DP_HI[ k ] );
+	t = float64ToFloat32( n );
+	// log2(ax)
+	t1 = float64ToFloat32(( float64ToFloat32(hz+lz) + float64ToFloat32( dp )) + float64ToFloat32( t )); // eslint-disable-line max-len
+	ahs = fromWordf( t1 );
+	ahs = float64ToFloat32( ahs & HIGH_BIASED_EXP_NEG_64 );
+	t1 = toWordf( ahs );
+	t2 = float64ToFloat32( lz - float64ToFloat32(((t1-t) - dp) - float64ToFloat32( hz ))); // eslint-disable-line max-len
+
+	return out;
+}
+
+
+// EXPORTS //
+
+module.exports = log2ax;