fix: main structure as per convention

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

@@ -15,6 +15,7 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
+*
 * ## Notice
 *
 * 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 for JavaScript.
@@ -51,12 +52,25 @@ var MAXL10 = 38.230809449325611792;
 // MAIN //
 
 /**
-* Computes `10^x` for a single-precision floating-point number.
+* Returns `10` raised to the `x` power.
 *
 * ## 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 \\).
+* -   Range reduction is accomplished by expressing the argument as \\( 10^x = 2^n 10^f \\), with \\( |f| < 0.5 log_{10}(2) \\). The Pade' form
+*
+*     ```tex
+*     10^f \approx 1 + f \cdot P(f)
+*     ```
+*
+*     is used to approximate \\( 10^f \\).
+*
+* ## Notes
+*
+* -   Relative error:
+*
+*     | arithmetic | domain      | # trials | peak    | rms     |
+*     |:----------:|:-----------:|:--------:|:-------:|:-------:|
+*     | IEEE       | -38,+38     |  30000   | 9.8e-8  | 2.8e-8  |
 *
 * @param {number} x - input value
 * @returns {number} function value
@@ -66,6 +80,10 @@ var MAXL10 = 38.230809449325611792;
 * // returns 1000.0
 *
 * @example
+* var v = exp10f( -9.0 );
+* // returns 9.999999717180685e-10
+*
+* @example
 * var v = exp10f( 0.0 );
 * // returns 1.0
 *
@@ -90,13 +108,13 @@ function exp10f( x ) {
 	if ( x < (-1 * MAXL10) ) {
 		return 0.0;
 	}
-
+	// Express 10^x = 10^g 2^n = 10^g 10^( n log10(2) ) = 10^( g + n log10(2) )
 	px = floorf( (LOG210*x) + 0.5 );
 	n = px;
 	x -= px * LG102A;
 	x -= px * LG102B;
 
-	// Polynomial approximation:
+	// Polynomial approximation for fractional part: 10^f ≈ 1 + f * P(f)
 	x = 1.0 + ( x * polyval( x ) );
 
 	// Multiply by power of 2:

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

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2022 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.

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

@@ -15,10 +15,19 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
+*
 * ## Notice
 *
-* 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.
+* 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.
+*
+* ```text
+* 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
+* moshier@na-net.ornl.gov
+* ```
 */
 
 #include "stdlib/math/base/special/exp10f.h"
@@ -30,42 +39,70 @@
 #include "stdlib/math/base/special/ldexpf.h"
 #include <stdint.h>
 
-// Cephes constants:
-
 static float LOG210 = 3.32192809488736234787e0;
 static float LG102A = 3.00781250000000000000E-1;
 static float LG102B = 2.48745663981195213739E-4;
 static float MAXL10 = 38.230809449325611792;
+
+/* Begin auto-generated functions. The following functions are auto-generated. Do not edit directly. */
+
+// BEGIN: polyval
+
 /**
-* Evaluates a polynomial using Horner's rule.
-* P(x)=a5​+x(a4​+x(a3​+x(a2​+x(a1​+xa0​))))
+* Evaluates a polynomial.
+*
+* ## Notes
+*
+* -   The implementation uses [Horner's rule][horners-method] for efficient computation.
 *
-* @param x     input value
-* @return      result of polynomial evaluation
+* [horners-method]: https://en.wikipedia.org/wiki/Horner%27s_method
+*
+* @param x     value at which to evaluate the polynomial
+* @return      evaluated polynomial
 */
 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))));
 }
 
+// END: polyval
+
+/* End auto-generated functions. */
 
 /**
-* Computes 10^x for a single-precision floating-point number.
+* Returns `10` raised to the `x` power.
 *
 * ## Method
 *
-* -   Performs range reduction: 10^x = 2^n * 10^f, where |f| < 0.5*log10(2)
-* -   Approximates 10^f using a polynomial expansion from Cephes
+* -   Range reduction is accomplished by expressing the argument as \\( 10^x = 2^n 10^f \\), with \\( |f| < 0.5 log_{10}(2) \\). The Pade' form
+*
+*     ```tex
+*     10^f \approx 1 + f \cdot P(f)
+*     ```
+*
+*     is used to approximate \\( 10^f \\).
+*
+* ## Notes
+*
+* -   Relative error:
+*
+*     | arithmetic | domain      | # trials | peak    | rms     |
+*     |:----------:|:-----------:|:--------:|:-------:|:-------:|
+*     | IEEE       | -38,+38     |  30000   | 9.8e-8  | 2.8e-8  |
 *
 * @param x  input value
-* @return   single-precision result of 10^x
+* @return   output value
+*
+* @example
+* float v = stdlib_base_exp10f( 2.0 );
+* // returns 100.0
 */
 float stdlib_base_exp10f( const float x ) {
 	float xc;
 	float px;
 	int32_t n;
 
 	if ( stdlib_base_is_nanf( x ) ) {
-		return 0.0f / 0.0f;
+		return 0.0f / 0.0f; // NaN
 	}
 	if ( x > MAXL10 ) {
 		return STDLIB_CONSTANT_FLOAT32_PINF;
@@ -76,18 +113,17 @@ float stdlib_base_exp10f( const float x ) {
 	if ( x == 0.0f ) {
 		return 1.0f;
 	}
-
-	// Range reduction:
+	// Express 10^x = 10^g 2^n = 10^g 10^( n log10(2) ) = 10^( g + n log10(2) )
 	px = stdlib_base_floorf( (LOG210 * x) + 0.5f );
 	n = (int32_t)px;
 	xc = x;
 	xc -= px * LG102A;
 	xc -= px * LG102B;
 
-	// Polynomial approximation: 10^f ≈ 1 + f * P(f)
+	// Polynomial approximation for fractional part: 10^f ≈ 1 + f * P(f)
 	px = xc * polyval( xc );
 	xc = 1.0f + px;
 
-	// Multiply by power of 2: 10^x = 10^f * 2^n
+	// Multiply by power of 2:
 	return stdlib_base_ldexpf( xc, n );
 }