feat: add javascript and c implementation

---
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: 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: Deepak91168

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

@@ -33,17 +33,33 @@
 
 // MODULES //
 
-var exp10 = require( '@stdlib/math/base/special/exp10' );
-var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
+var floorf = require( '@stdlib/math/base/special/floorf' );
+var ldexpf = require( '@stdlib/math/base/special/ldexpf' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var PINF = require( '@stdlib/constants/float32/pinf' );
+var polyval = require( './polyval.js' );
+
+
+// VARIABLES //
+
+var LOG210 = 3.32192809488736234787e0;
+var LG102A = 3.00781250000000000000E-1;
+var LG102B = 2.48745663981195213739E-4;
+var MAXL10 = 38.230809449325611792;
 
 
 // MAIN //
 
 /**
 * Computes `10^x` for a single-precision floating-point number.
 *
+* ## Method
+*
+* -   Range reduction is accomplished by expressing the argument as \\( 10^x = 2^n 10^f \\), with \\( |f| < 0.5 \\log_{10}(2) \\).
+* -   A polynomial is used to approximate \\( 10^f \\).
+*
 * @param {number} x - input value
-* @returns {number} single-precision result
+* @returns {number} function value
 *
 * @example
 * var v = exp10f( 3.0 );
@@ -58,7 +74,33 @@ var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 * // returns NaN
 */
 function exp10f( x ) {
-	return float64ToFloat32( exp10( float64ToFloat32( x ) ) );
+	var px;
+	var n;
+
+	if ( isnanf( x ) ) {
+		return x;
+	}
+
+	if ( x === 0.0 ) {
+		return 1.0;
+	}
+	if ( x > MAXL10 ) {
+		return PINF;
+	}
+	if ( x < (-1 * MAXL10) ) {
+		return 0.0;
+	}
+
+	px = floorf( (LOG210*x) + 0.5 );
+	n = px;
+	x -= px * LG102A;
+	x -= px * LG102B;
+
+	// Polynomial approximation:
+	x = 1.0 + ( x * polyval( x ) );
+
+	// Multiply by power of 2:
+	return ldexpf( x, n );
 }
 
 

lib/node_modules/@stdlib/math/base/special/exp10f/lib/polyval.js

@@ -0,0 +1,47 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2022 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.
+*/
+
+/* This is a generated file. Do not edit directly. */
+'use strict';
+
+// MAIN //
+
+/**
+* Evaluates a polynomial.
+*
+* ## Notes
+*
+* -   The implementation uses [Horner's rule][horners-method] for efficient computation.
+*
+* [horners-method]: https://en.wikipedia.org/wiki/Horner%27s_method
+*
+* @private
+* @param {number} x - value at which to evaluate the polynomial
+* @returns {number} evaluated polynomial
+*/
+function evalpoly( x ) {
+	if ( x === 0.0 ) {
+		return 2.302585167056758;
+	}
+	return 2.302585167056758 + (x * (2.650948748208892 + (x * (2.034649854009453 + (x * (1.171292686296281 + (x * (0.5420251702225484 + (x * 0.2063216740311022))))))))); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = evalpoly;

lib/node_modules/@stdlib/math/base/special/exp10f/src/main.c

@@ -19,16 +19,6 @@
 *
 * The original C code, long comment, copyright, license, and constants are from [Cephes]{@link http://www.netlib.org/cephes}.
 * The implementation follows the original, but has been modified according to project conventions.
-*
-* Copyright 1984, 1991, 2000 by Stephen L. Moshier
-*
-* Some software in this archive may be from the book _Methods and Programs for Mathematical Functions_
-* (Prentice-Hall or Simon & Schuster International, 1989) or from the Cephes Mathematical Library,
-* a commercial product. In either event, it is copyrighted by the author.
-* What you see here may be used freely but it comes with no support or guarantee.
-*
-* Stephen L. Moshier
-* [email protected]
 */
 
 #include "stdlib/math/base/special/exp10f.h"
@@ -40,62 +30,64 @@
 #include "stdlib/math/base/special/ldexpf.h"
 #include <stdint.h>
 
-// Constants:
-static const float LOG210F  = 3.3219281f;
-static const float LG102AF  = 0.30102539f;
-static const float LG102BF  = 4.6050378e-06f;
+// Cephes constants:
 
-// Evaluate polynomial P(x):
-static float polyval_p( const float x ) {
-	return 2394.2374f + (x * (406.7173f + (x * (11.745273f + (x * 0.04099625f)))));
+static float LOG210 = 3.32192809488736234787e0;
+static float LG102A = 3.00781250000000000000E-1;
+static float LG102B = 2.48745663981195213739E-4;
+static float MAXL10 = 38.230809449325611792;
+/**
+* Evaluates a polynomial using Horner's rule.
+* P(x)=a5​+x(a4​+x(a3​+x(a2​+x(a1​+xa0​))))
+*
+* @param x     input value
+* @return      result of polynomial evaluation
+*/
+static float polyval( const float x ) {
+	return 2.302585167056758e+0f + x * (2.650948748208892e+0f + x * (2.034649854009453e+0f + x * (1.171292686296281e+0f + x * (5.420251702225484e-1f + x * 2.063216740311022e-1f))));
 }
 
-// Evaluate polynomial Q(x):
-static float polyval_q( const float x ) {
-	return 2079.6082f + (x * (1272.0927f + (x * (85.09362f + (x * 1.0f)))));
-}
 
 /**
-* Returns 10 raised to the x power (single-precision).
+* Computes 10^x for a single-precision floating-point number.
 *
 * ## Method
 *
-* -   Range reduction is done using 10^x = 2^n * 10^f, with |f| < 0.5 * log10(2)
-* -   The reduced part is evaluated with a rational approximation:
-*
-*     1 + 2x P(x^2) / (Q(x^2) - P(x^2))
+* -   Performs range reduction: 10^x = 2^n * 10^f, where |f| < 0.5*log10(2)
+* -   Approximates 10^f using a polynomial expansion from Cephes
 *
 * @param x  input value
-* @return   10^x
+* @return   single-precision result of 10^x
 */
 float stdlib_base_exp10f( const float x ) {
 	float xc;
 	float px;
-	float xx;
 	int32_t n;
 
 	if ( stdlib_base_is_nanf( x ) ) {
 		return 0.0f / 0.0f;
 	}
-	if ( x > STDLIB_CONSTANT_FLOAT32_MAX_BASE10_EXPONENT ) {
+	if ( x > MAXL10 ) {
 		return STDLIB_CONSTANT_FLOAT32_PINF;
 	}
+	if ( x < -MAXL10 ) {
+		return 0.0f;
+	}
+	if ( x == 0.0f ) {
+		return 1.0f;
+	}
 
-	// Compute n = round(x * log2(10)):
-	px = stdlib_base_floorf( (LOG210F * x) + 0.5f );
+	// Range reduction:
+	px = stdlib_base_floorf( (LOG210 * x) + 0.5f );
 	n = (int32_t)px;
-
-	// Compute f = x - n * log10(2):
 	xc = x;
-	xc -= (px * LG102AF);
-	xc -= (px * LG102BF);
+	xc -= px * LG102A;
+	xc -= px * LG102B;
 
-	// Evaluate rational approximation for 10^f:
-	xx = xc * xc;
-	px = xc * polyval_p( xx );
-	xc = px / (polyval_q( xx ) - px);
-	xc = 1.0f + stdlib_base_ldexpf( xc, 1 );
+	// Polynomial approximation: 10^f ≈ 1 + f * P(f)
+	px = xc * polyval( xc );
+	xc = 1.0f + px;
 
-	// Return result:
+	// Multiply by power of 2: 10^x = 10^f * 2^n
 	return stdlib_base_ldexpf( xc, n );
 }

lib/node_modules/@stdlib/math/base/special/exp10f/test/test.native.js

@@ -172,7 +172,7 @@ tape( 'the function returns `0.0` for negative large `x`', opts, function test(
 
 tape( 'the function returns `0.0` if provided `-infinity`', opts, function test( t ) {
 	var val = exp10f( NINF );
-	t.strictEqual( isPositiveZerof( val ), false, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( val ), true, 'returns expected value' );
 	t.end();
 });