chore: update modules & var

Author: Neerajpathak07

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

@@ -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/examples/index.js

@@ -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/lib/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/logx.js

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2018 The Stdlib Authors.
+* 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.
@@ -18,7 +18,7 @@
 *
 * ## 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/s_pow.c}. The implementation follows the original, but has been modified for JavaScript.
+* 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.
@@ -78,8 +78,8 @@ function logx( out, ax ) {
 	var u;
 	var v;
 
-	t = ( float64ToFloat32( ax - 1.0 ) ); // `t` has `20` trailing zeros
-	w = float64ToFloat32( t * t * polyvalW( t ) );
+	t = float64ToFloat32( ax - 1.0 ); // `t` has `20` trailing zeros
+	w = float64ToFloat32( t * t * float64ToFloat32( polyvalW( t ) ) );
 	u = float64ToFloat32( INV_LN2_HI * t ); // `INV_LN2_HI` has `16` significant bits
 	v = float64ToFloat32( float64ToFloat32( t*INV_LN2_LO ) - float64ToFloat32( w*INV_LN2 ) ); // eslint-disable-line max-len
 	t1 = float64ToFloat32( u + v );

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

@@ -18,7 +18,7 @@
 *
 * ## 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/s_pow.c}. The implementation follows the original, but has been modified for JavaScript.
+* 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.
@@ -39,57 +39,50 @@ var isInfinitef = require( '@stdlib/math/base/assert/is-infinitef' );
 var isIntegerf = require( '@stdlib/math/base/assert/is-integerf' );
 var sqrtf = require( '@stdlib/math/base/special/sqrtf' );
 var absf = require( '@stdlib/math/base/special/absf' );
-var toWords = require( '@stdlib/number/float32/base/to-words' );
-var setLowWord = require( '@stdlib/number/float32/base/set-low-word' );
-var uint32ToInt32 = require( '@stdlib/number/uint32/base/to-int32' );
+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 NINF = require( '@stdlib/constants/float32/ninf' );
 var PINF = require( '@stdlib/constants/float32/pinf' );
-var ABS_MASK = require( '@stdlib/constants/float32/high-word-abs-mask' );
 var FLOAT32_ABS_MASK = require( '@stdlib/constants/float32/abs-mask' );
 var xIsZero = require( './x_is_zero.js' );
-var yIsHuge = require( './y_is_huge.js' );
 var yIsInfinite = require( './y_is_infinite.js' );
-var log2axf = require( './log2axf.js' );
-var logxf = require( './logxf.js' );
-var pow2f = require( './pow2f.js' );
+var log2ax = require( './log2ax.js' );
+var logx = require( './logx.js' );
+var pow2 = require( './pow2.js' );
 
 
 // VARIABLES //
 
-// 0x3fefffff = 1072693247 => 0 01111111110 11111111111111111111 => biased exponent: 1022 = -1+1023 => 2^-1
-var HIGH_MAX_NEAR_UNITY = 0x3fefffff|0; // asm type annotation
+// 0x3f7ffff8 = 1065353216 => 0 01111111011 11111111111111111000 => biased exponent: 126 = -1+127 => 2^-1 * (1.999999)
+var HIGH_MAX_NEAR_UNITY = 0x3f7ffff8; // asm type annotation
 
-// 0x41e00000 = 1105199104 => 0 10000011110 00000000000000000000 => biased exponent: 1054 = 31+1023 => 2^31
-var HIGH_BIASED_EXP_31 = 0x41e00000|0; // asm type annotation
+// 0x4d000000 = 1291845632 => 0 10011010000 00000000000000000000 => biased exponent: 208 = 81+127 => 2^81
+var HIGH_BIASED_EXP_27 = 0x4d000000; // asm type annotation
 
-// 0x43f00000 = 1139802112 => 0 10000111111 00000000000000000000 => biased exponent: 1087 = 64+1023 => 2^64
-var HIGH_BIASED_EXP_64 = 0x43f00000|0; // asm type annotation
+// 0x43000000 = 1124073472 => 0 10000110000 00000000000000000000 => biased exponent: 96 = -31+127 => 2^16
+var SMALL_BIASED_EXP_10 = 0x43000000; // asm type annotation
 
-// 0x40900000 = 1083179008 => 0 10000001001 00000000000000000000 => biased exponent: 1033 = 10+1023 => 2^10 = 1024
-var HIGH_BIASED_EXP_10 = 0x40900000|0; // asm type annotation
+// 0x3f800007 = 1065353223 => 0 01111111100 00000000000000000111 => biased exponent: 127 = 0+127 => 2^0 * (1.0000000007)
+var BIASED_EXP_0 = 0x3f800007; // asm type annotation
 
-// 0x3ff00000 = 1072693248 => 0 01111111111 00000000000000000000 => biased exponent: 1023 = 0+1023 => 2^0 = 1
-var HIGH_BIASED_EXP_0 = 0x3ff00000|0; // asm type annotation
+// 0xfffff000 = 4294963200 => 1 11111111111 11111111111100000000
+var HIGH_BIASED_EXP_NEG_64 = 0xfffff000; // asm type annotation
 
-// 0x4090cc00 = 1083231232 => 0 10000001001 00001100110000000000
-var HIGH_1075 = 0x4090cc00|0; // asm type annotation
+// 0x43160000 = 1128275968 => 0 10000110011 00000000000000000000 => biased exponent: 99 = -28+127 => 2^22
+var SMALL_60 = 0x43160000; // asm type annotation
 
-// 0xc090cc00 = 3230714880 => 1 10000001001 00001100110000000000
-var HIGH_NEG_1075 = 0xc090cc00>>>0; // asm type annotation
-
-var HIGH_NUM_NONSIGN_BITS = 31|0; // asm type annotation
+// 0xc3160000 = 3273056256 => 1 10000110011 00000000000000000000 => biased exponent: 99 = -28+127 => -2^22
+var SMALL_NEG_60 = 0xc3160000>>>0; // asm type annotation
 
 var HUGE = 1.0e30;
 var TINY = 1.0e-30;
 
 // -(1024-log2(ovfl+.5ulp))
 var OVT = 4.2995665694e-08;
 
-// High/low words workspace:
-var WORDS = [ 0|0, 0|0 ];
-
 // Log workspace:
-var LOG_WORKSPACE = [ 0.0, 0.0 ];
+var LOG_WORKSPACE = 0.0;
 
 
 // MAIN //
@@ -194,64 +187,55 @@ var LOG_WORKSPACE = [ 0.0, 0.0 ];
 * // returns NaN
 */
 function powf( x, y ) {
-	var ahx; // absolute value high word `x`
-	var ahy; // absolute value high word `y`
-	var ax;  // absolute value `x`
-	var hx;  // high word `x`
-	var lx;  // low word `x`
-	var hy;  // high word `y`
-	var ly;  // low word `y`
-	var sx;  // sign `x`
-	var sy;  // sign `y`
+	var ahs;
+	var ahx;
+	var ahy;
+	var ax;
+	var hx;
+	var hy;
+	var hp;
+	var lp;
+	var sn;
 	var y1;
+	var t1;
+	var t2;
 	var hp;
 	var lp;
 	var z; // y prime
 	var j;
-	var i;
-	if ( isnanf( x ) || isnanf( y ) ) {
-		return NaN;
-	}
-	// Split `y` into high and low words:
-	toWords.assign( y, WORDS, 1, 0 );
-	hy = WORDS[ 0 ];
-	ly = WORDS[ 1 ];
+
+	hx = fromWordf( x );
+	hy = fromWordf( y );
 
 	// Special cases `y`...
-	if ( ly === 0 ) {
-		if ( y === 0.0 ) {
-			return 1.0;
-		}
-		if ( y === 1.0 ) {
-			return x;
-		}
-		if ( y === -1.0 ) {
-			return 1.0 / x;
-		}
-		if ( y === 0.5 ) {
-			return sqrtf( x );
-		}
-		if ( y === -0.5 ) {
-			return 1.0 / sqrtf( x );
-		}
-		if ( y === 2.0 ) {
-			return x * x;
-		}
-		if ( y === 3.0 ) {
-			return x * x * x;
-		}
-		if ( y === 4.0 ) {
-			x *= x;
-			return x * x;
-		}
-		if ( isInfinitef( y ) ) {
-			return yIsInfinite( x, y );
-		}
+	if ( y === 0.0 ) {
+		return 1.0;
+	}
+	if ( y === 1.0 ) {
+		return x;
+	}
+	if ( y === -1.0 ) {
+		return 1.0 / x;
+	}
+	if ( y === 0.5 ) {
+		return sqrtf( x );
+	}
+	if ( y === -0.5 ) {
+		return 1.0 / sqrtf( x );
+	}
+	if ( y === 2.0 ) {
+		return x * x;
+	}
+	if ( y === 3.0 ) {
+		return x * x * x;
+	}
+	if ( y === 4.0 ) {
+		x *= x;
+		return x * x;
+	}
+	if ( isInfinitef( y ) ) {
+		return yIsInfinite( x, y );
 	}
-	// Split `x` into high and low words:
-	toWords.assign( x, WORDS, 1, 0 );
-	hx = WORDS[ 0 ];
-	lx = WORDS[ 1 ];
 
 	// Special cases `x`...
 	if ( lx === 0 ) {
@@ -291,68 +275,60 @@ function powf( x, y ) {
 	ahx = (hx & FLOAT32_ABS_MASK); // asm type annotation
 	ahy = (hy & FLOAT32_ABS_MASK); // asm type annotation
 
-	// Determine the sign of the result...
-	if ( sx && isOddf( y ) ) {
-		sx = -1.0;
+	if ( sn && isOddf( y ) ) {
+		sn = -1.0;
 	} else {
-		sx = 1.0;
+		sn = 1.0;
 	}
-	// Case 1: `|y|` is huge...
-
-	// |y| > 2^31
-	if ( ahy > HIGH_BIASED_EXP_31 ) {
-		// `|y| > 2^64`, then must over- or underflow...
-		if ( ahy > HIGH_BIASED_EXP_64 ) {
-			return yIsHuge( x, y );
-		}
-		// Over- or underflow if `x` is not close to unity...
+	// |y| is huge
 
+	// if |y| > 2^27
+	if( ahy > HIGH_BIASED_EXP_27 ) {
+	// Over- or underflow if `x` is not close to unity...
 		if ( ahx < HIGH_MAX_NEAR_UNITY ) {
 			// y < 0
-			if ( sy === 1 ) {
+			if ( sn === 1 ) {
 				// Signal overflow...
-				return sx * HUGE * HUGE;
+				return sn * HUGE * HUGE;
 			}
 			// Signal underflow...
-			return sx * TINY * TINY;
+			return sn * TINY * TINY;
 		}
-		if ( ahx > HIGH_BIASED_EXP_0 ) {
+		if ( ahx > BIASED_EXP_0 ) {
 			// y > 0
-			if ( sy === 0 ) {
+			if ( sn === 0 ) {
 				// Signal overflow...
-				return sx * HUGE * HUGE;
+				return sn * HUGE * HUGE;
 			}
 			// Signal underflow...
-			return sx * TINY * TINY;
+			return sn * TINY * TINY;
 		}
 		// At this point, `|1-x|` is tiny (`<= 2^-20`). Suffice to compute `log(x)` by `x - x^2/2 + x^3/3 - x^4/4`.
-		t = logxf( LOG_WORKSPACE, ax );
+		t = logx( LOG_WORKSPACE, ax );
 	}
 	// Case 2: `|y|` is not huge...
 	else {
-		t = log2axf( LOG_WORKSPACE, ax, ahx );
+		t = log2ax( LOG_WORKSPACE, ax, ahx );
 	}
 	// Split `y` into `y1 + y2` and compute `(y1+y2) * (t1+t2)`...
-	y1 = setLowWord( y, 0 );
-	lp = ( (y-y1)*t[0] ) + ( y*t[1] );
-	hp = y1 * t[0];
-	z = lp + hp;
-
-	// Note: *can* be more performant to use `getHighWord` and `getLowWord` directly, but using `toWords` looks cleaner.
-	toWords.assign( z, WORDS, 1, 0 );
-	j = uint32ToInt32( WORDS[0] );
-	i = uint32ToInt32( WORDS[1] );
-
-	// z >= 1024
-	if ( j >= HIGH_BIASED_EXP_10 ) {
-		// z > 1024
-		if ( ((j-HIGH_BIASED_EXP_10)|i) !== 0 ) {
-			// Signal overflow...
-			return sx * HUGE * HUGE;
-		}
+	ahs = fromWordf( y );
+	ahs = float64ToFloat32( ahs & HIGH_BIASED_EXP_NEG_64 );
+	y1 = toWordf( ahs );
+	lp = float64ToFloat32(( float64ToFloat32(y-y1)*t1 ) + float64ToFloat32( y*t2 )); // eslint-disable-line max-len
+	hp = float64ToFloat32( y1 * t1 );
+	z = float64ToFloat32( lp + hp );
+	j = fromWordf( z );
+
+	// z >= 128
+	if ( j > SMALL_BIASED_EXP_10 ) {
+		// Signal overflow
+		return sn * HUGE * HUGE;
+	}
+	// z == 128
+	else if ( j === SMALL_BIASED_EXP_10 ) {
 		if ( (lp+OVT) > (z-hp) ) {
 			// Signal overflow...
-			return sx * HUGE * HUGE;
+			return sn * HUGE * HUGE;
 		}
 	}
 	// z <= -150
@@ -367,7 +343,7 @@ function powf( x, y ) {
 		}
 	}
 	// Compute `2^(hp+lp)`...
-	z = pow2f( j, hp, lp );
+	z = pow2( j, hp, lp );
 
 	return sx * z;
 }