docs: fix C examples

officiallyanee · officiallyanee · commit 4c152fd61ff5 · 2026-06-23T13:38:25.000+05:30
---
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_pkg_readmes
    status: passed
  - task: lint_markdown_docs
    status: na
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - 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: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/README.md b/lib/node_modules/@stdlib/blas/base/cgemv/README.md
@@ -309,7 +309,7 @@ float y[] = { 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 4.0f, 4.0f };
 const stdlib_complex64_t alpha = stdlib_complex64( 0.5f, 0.5f );
 const stdlib_complex64_t beta = stdlib_complex64( 0.5f, -0.5f );
 
-c_cgemv( CblasNoTrans, 4, 2, alpha, (void *)A, 1, 4, (void *)x, 1, 0, beta, (void *)y, 1, 0 );
+c_cgemv_ndarray( CblasNoTrans, 4, 2, alpha, (void *)A, 1, 4, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 );
 ```
 
 The function accepts the following arguments:
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnancount/README.md b/lib/node_modules/@stdlib/blas/ext/base/dnancount/README.md
@@ -177,7 +177,7 @@ console.log( v );
 Computes the number of non-`NaN` elements in a double-precision floating-point strided array.
 
 ```c
-const double x[] = { 1.0, 2.0, NaN, 4.0, 5.0, 6.0, NaN, 8.0 };
+const double x[] = { 1.0, 2.0, 0.0/0.0, 4.0, 5.0, 6.0, 0.0/0.0, 8.0 };
 
 int v = stdlib_strided_dnancount( 4, x, 2 );
 // returns 2
@@ -198,7 +198,7 @@ CBLAS_INT stdlib_strided_dnancount( const CBLAS_INT N, const double *X, const CB
 Computes the number of non-`NaN` elements in a double-precision floating-point strided array using alternative indexing semantics.
 
 ```c
-const double x[] = { 2.0, 1.0, NaN, -2.0, 3.0, 4.0, NaN, NaN };
+const double x[] = { 2.0, 1.0, 0.0/0.0, -2.0, 3.0, 4.0, 0.0/0.0, 0.0/0.0 };
 
 int v = stdlib_strided_dnancount_ndarray( 4, x, 2, 1 );
 // returns 3
diff --git a/lib/node_modules/@stdlib/blas/ext/base/znancount/README.md b/lib/node_modules/@stdlib/blas/ext/base/znancount/README.md
@@ -190,9 +190,9 @@ Computes the number of non-`NaN` elements in a double-precision complex floating
 
 const stdlib_complex128_t x[] = {
     stdlib_complex128( 2.0, 1.0 ),
-    stdlib_complex128( NaN, -2.0 ),
+    stdlib_complex128( 0.0/0.0, -2.0 ),
     stdlib_complex128( 3.0, 4.0 ),
-    stdlib_complex128( NaN, NaN )
+    stdlib_complex128( 0.0/0.0, 0.0/0.0 )
 };
 
 int v = stdlib_strided_znancount( 4, x, 1 );
@@ -218,9 +218,9 @@ Computes the number of non-`NaN` elements in a double-precision complex floating
 
 const stdlib_complex128_t x[] = {
     stdlib_complex128( 2.0, 1.0 ),
-    stdlib_complex128( NaN, -2.0 ),
+    stdlib_complex128( 0.0/0.0, -2.0 ),
     stdlib_complex128( 3.0, 4.0 ),
-    stdlib_complex128( NaN, NaN )
+    stdlib_complex128( 0.0/0.0, 0.0/0.0 )
 };
 
 int v = stdlib_strided_znancount_ndarray( 4, x, 1, 0 );
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-composite/README.md b/lib/node_modules/@stdlib/math/base/assert/is-composite/README.md
@@ -103,7 +103,7 @@ bool = isComposite( NaN );
 ### Usage
 
 ```c
-#include "stdlib/math/base/special/is_composite.h"
+#include "stdlib/math/base/assert/is_composite.h"
 ```
 
 #### stdlib_base_is_composite( x )
diff --git a/lib/node_modules/@stdlib/math/base/special/atan2/src/main.c b/lib/node_modules/@stdlib/math/base/special/atan2/src/main.c
@@ -71,11 +71,11 @@
 * // returns 0.0
 *
 * @example
-* double v = stdlib_base_atan2( 3.0, NaN );
+* double v = stdlib_base_atan2( 3.0, 0.0/0.0 );
 * // returns NaN
 *
 * @example
-* double v = stdlib_base_atan2( NaN, 2.0 );
+* double v = stdlib_base_atan2( 0.0/0.0, 2.0 );
 * // returns NaN
 */
 double stdlib_base_atan2( const double y, const double x ) {
diff --git a/lib/node_modules/@stdlib/math/base/special/atan2d/src/main.c b/lib/node_modules/@stdlib/math/base/special/atan2d/src/main.c
@@ -51,11 +51,11 @@
 * // returns 0.0
 *
 * @example
-* double v = stdlib_base_atan2d( 3.0, NaN );
+* double v = stdlib_base_atan2d( 3.0, 0.0/0.0 );
 * // returns NaN
 *
 * @example
-* double v = stdlib_base_atan2d( NaN, 2.0 );
+* double v = stdlib_base_atan2d( 0.0/0.0, 2.0 );
 * // returns NaN
 */
 double stdlib_base_atan2d( const double y, const double x ) {
diff --git a/lib/node_modules/@stdlib/math/base/special/cround/src/main.c b/lib/node_modules/@stdlib/math/base/special/cround/src/main.c
@@ -35,7 +35,12 @@
 * stdlib_complex128_t z = stdlib_complex128( -4.2, 5.5 );
 *
 * stdlib_complex128_t out = stdlib_base_cround( z );
-* // returns <Complex128>[ -5.0, 6.0 ]
+*
+* double re = stdlib_complex128_real( out );
+* // returns -4.0
+*
+* double im = stdlib_complex128_imag( out );
+* // returns 6.0
 */
 stdlib_complex128_t stdlib_base_cround( const stdlib_complex128_t z ) {
 	double re;
diff --git a/lib/node_modules/@stdlib/math/base/special/fast/max/src/main.c b/lib/node_modules/@stdlib/math/base/special/fast/max/src/main.c
@@ -30,11 +30,11 @@
 * // returns 4.2
 *
 * @example
-* double v = stdlib_base_fast_max( 3.14, NaN );
+* double v = stdlib_base_fast_max( 3.14, 0.0/0.0 );
 * // returns NaN
 *
 * @example
-* double v = stdlib_base_fast_max( NaN, 3.14 );
+* double v = stdlib_base_fast_max( 0.0/0.0, 3.14 );
 * // returns 3.14
 *
 * @example
diff --git a/lib/node_modules/@stdlib/math/base/special/gcd/src/main.c b/lib/node_modules/@stdlib/math/base/special/gcd/src/main.c
@@ -35,7 +35,7 @@ static const int64_t STDLIB_CONSTANT_INT64_MAX = 9223372036854775807;
 * @return     greatest common divisor
 *
 * @example
-* double out = largeIntegers( 1.2676506002282294.0e+30, 9007199254740992.0 );
+* double out = largeIntegers( 1.2676506002282294e+30, 9007199254740992.0 );
 * // returns 9007199254740992.0
 */
 static double largeIntegers( const double a, const double b ) {
diff --git a/lib/node_modules/@stdlib/math/base/special/pow/src/main.c b/lib/node_modules/@stdlib/math/base/special/pow/src/main.c
@@ -377,9 +377,11 @@ static double pow2( uint32_t j, const double hp, const double lp ) {
 * @param o2    destination for output2
 *
 * @example
+* double o1;
+* double o2;
 * logx( 9.0, &o1, &o2 );
 */
-void logx( const double ax, double *o1, double *o2 ) {
+static void logx( const double ax, double *o1, double *o2 ) {
 	double t2;
 	double t1;
 	double t;
@@ -408,9 +410,11 @@ void logx( const double ax, double *o1, double *o2 ) {
 * @param o2     destination for output2
 *
 * @example
+* double o1;
+* double o2;
 * log2ax( 9.0, 1075970048, &o1, &o2 );
 */
-void log2ax( const double ax, const int32_t ahx, double *o1, double *o2 ) {
+static void log2ax( const double ax, const int32_t ahx, double *o1, double *o2 ) {
 	uint32_t ahxcc;
 	uint32_t tmp;
 	int32_t ahxc;
diff --git a/lib/node_modules/@stdlib/math/base/special/powf/src/main.c b/lib/node_modules/@stdlib/math/base/special/powf/src/main.c
@@ -200,7 +200,7 @@ static float polyval_p( const float x ) {
 *
 * @example
 * float out = y_is_infinitef( -1.0f, 1.0f/0.0f );
-* // returns NaN
+* // returns 1.0f
 */
 static float y_is_infinitef( const float x, const float y ) {
 	if ( x == -1.0f ) {
@@ -328,9 +328,11 @@ static float pow2f( uint32_t j, const float hp, const float lp ) {
 * @param o2    destination for output2
 *
 * @example
+* float o1;
+* float o2;
 * logxf( 9.0f, &o1, &o2 );
 */
-void logxf( const float ax, float *o1, float *o2 ) {
+static void logxf( const float ax, float *o1, float *o2 ) {
 	uint32_t tmp;
 	float t2;
 	float t1;
@@ -361,9 +363,11 @@ void logxf( const float ax, float *o1, float *o2 ) {
 * @param o2     destination for output2
 *
 * @example
+* float o1;
+* float o2;
 * log2axf( 9.0f, 1075970048, &o1, &o2 );
 */
-void log2axf( const float ax, const int32_t ahx, float *o1, float *o2 ) {
+static void log2axf( const float ax, const int32_t ahx, float *o1, float *o2 ) {
 	uint32_t ahxcc;
 	uint32_t tmp;
 	int32_t ahxc;
diff --git a/lib/node_modules/@stdlib/ml/base/kmeans/algorithms/README.md b/lib/node_modules/@stdlib/ml/base/kmeans/algorithms/README.md
@@ -130,7 +130,7 @@ An enumeration of k-means clustering algorithms with the following fields:
 ```c
 #include "stdlib/ml/base/kmeans/algorithms.h"
 
-const enum STDLIB_ML_KMEANS_ALGORITHM v = STDLIB_ML_KMEANS_LLOYD;
+const enum STDLIB_ML_KMEANS_ALGORITHMS v = STDLIB_ML_KMEANS_LLOYD;
 ```
 
 </section>
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/README.md b/lib/node_modules/@stdlib/ndarray/base/every/README.md
@@ -204,6 +204,8 @@ void stdlib_ndarray_every_by_f_x_as_d_x(...) {...}
 
 is a function which accepts one single-precision floating-point input ndarray and one boolean output ndarray. However, the callback accepts double-precision floating-point numbers. Accordingly, the input values need to be cast using the following conversion sequence
 
+<!-- run-disable -->
+
 ```c
 #include <stdbool.h>
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/nullary/README.md b/lib/node_modules/@stdlib/ndarray/base/nullary/README.md
@@ -193,6 +193,8 @@ void stdlib_ndarray_f_as_d(...) {...}
 
 is a function which accepts one single-precision floating-point output ndarray. However, the callback returns double-precision floating-point numbers. Accordingly, the output values need to be cast using the following conversion sequence
 
+<!-- run-disable -->
+
 ```c
 // Evaluate the callback:
 double out = f();
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-accumulate/README.md b/lib/node_modules/@stdlib/ndarray/base/unary-accumulate/README.md
@@ -204,6 +204,8 @@ void stdlib_ndarray_accumulate_ff_f_as_dd_d(...) {...}
 
 is a function which performs accumulation in single-precision and accepts one single-precision floating-point input ndarray and one single-precision floating-point output ndarray. However, the callback accepts and returns double-precision floating-point numbers. Accordingly, the input and output values need to be cast using the following conversion sequence
 
+<!-- run-disable -->
+
 ```c
 // Convert the current accumulated value to double-precision:
 double curr = (double)acc;
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary/README.md b/lib/node_modules/@stdlib/ndarray/base/unary/README.md
@@ -217,6 +217,8 @@ void stdlib_ndarray_f_f_as_d_d(...) {...}
 
 is a function which accepts one single-precision floating-point input ndarray and one single-precision floating-point output ndarray. However, the callback accepts and returns double-precision floating-point numbers. Accordingly, the input and output values need to be cast using the following conversion sequence
 
+<!-- run-disable -->
+
 ```c
 // Convert each input array element to double-precision:
 double in1 = (double)x[ i ];
diff --git a/lib/node_modules/@stdlib/strided/base/mskunary/README.md b/lib/node_modules/@stdlib/strided/base/mskunary/README.md
@@ -224,6 +224,8 @@ stdlib_strided_mask_<input_data_type>_<output_data_type>[_as_<callback_arg_data_
 
 For example,
 
+<!-- run-disable -->
+
 ```c
 void stdlib_strided_mask_d_d(...) {...}
 ```
@@ -232,12 +234,16 @@ is a function which accepts one double-precision floating-point strided input ar
 
 To support callbacks whose input arguments and/or return values are of a different data type than the strided input and/or output array data types, the naming convention supports appending an `as` suffix. For example,
 
+<!-- run-disable -->
+
 ```c
 void stdlib_strided_mask_f_f_as_d_d(...) {...}
 ```
 
 is a function which accepts one single-precision floating-point strided input array and one single-precision floating-point strided output array. However, the callback accepts and returns double-precision floating-point numbers. Accordingly, the input and output values need to be cast using the following conversion sequence
 
+<!-- run-disable -->
+
 ```c
 // Convert each input array element to double-precision:
 double in1 = (double)x[ i ];
diff --git a/lib/node_modules/@stdlib/strided/base/unary/README.md b/lib/node_modules/@stdlib/strided/base/unary/README.md
@@ -231,6 +231,8 @@ void stdlib_strided_f_f_as_d_d(...) {...}
 
 is a function which accepts one single-precision floating-point strided input array and one single-precision floating-point strided output array. However, the callback accepts and returns double-precision floating-point numbers. Accordingly, the input and output values need to be cast using the following conversion sequence
 
+<!-- run-disable -->
+
 ```c
 // Convert each input array element to double-precision:
 double in1 = (double)x[ i ];

Original file line number	Diff line number	Diff line change
`@@ -71,11 +71,11 @@`
`71`	`71`	`* // returns 0.0`
`72`	`72`	`*`
`73`	`73`	`* @example`
`74`		`-* double v = stdlib_base_atan2( 3.0, NaN );`
	`74`	`+* double v = stdlib_base_atan2( 3.0, 0.0/0.0 );`
`75`	`75`	`* // returns NaN`
`76`	`76`	`*`
`77`	`77`	`* @example`
`78`		`-* double v = stdlib_base_atan2( NaN, 2.0 );`
	`78`	`+* double v = stdlib_base_atan2( 0.0/0.0, 2.0 );`
`79`	`79`	`* // returns NaN`
`80`	`80`	`*/`
`81`	`81`	`double stdlib_base_atan2( const double y, const double x ) {`
Original file line number	Diff line number	Diff line change
`@@ -51,11 +51,11 @@`
`51`	`51`	`* // returns 0.0`
`52`	`52`	`*`
`53`	`53`	`* @example`
`54`		`-* double v = stdlib_base_atan2d( 3.0, NaN );`
	`54`	`+* double v = stdlib_base_atan2d( 3.0, 0.0/0.0 );`
`55`	`55`	`* // returns NaN`
`56`	`56`	`*`
`57`	`57`	`* @example`
`58`		`-* double v = stdlib_base_atan2d( NaN, 2.0 );`
	`58`	`+* double v = stdlib_base_atan2d( 0.0/0.0, 2.0 );`
`59`	`59`	`* // returns NaN`
`60`	`60`	`*/`
`61`	`61`	`double stdlib_base_atan2d( const double y, const double x ) {`
Original file line number	Diff line number	Diff line change
`@@ -30,11 +30,11 @@`
`30`	`30`	`* // returns 4.2`
`31`	`31`	`*`
`32`	`32`	`* @example`
`33`		`-* double v = stdlib_base_fast_max( 3.14, NaN );`
	`33`	`+* double v = stdlib_base_fast_max( 3.14, 0.0/0.0 );`
`34`	`34`	`* // returns NaN`
`35`	`35`	`*`
`36`	`36`	`* @example`
`37`		`-* double v = stdlib_base_fast_max( NaN, 3.14 );`
	`37`	`+* double v = stdlib_base_fast_max( 0.0/0.0, 3.14 );`
`38`	`38`	`* // returns 3.14`
`39`	`39`	`*`
`40`	`40`	`* @example`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ static const int64_t STDLIB_CONSTANT_INT64_MAX = 9223372036854775807;`
`35`	`35`	`* @return greatest common divisor`
`36`	`36`	`*`
`37`	`37`	`* @example`
`38`		`-* double out = largeIntegers( 1.2676506002282294.0e+30, 9007199254740992.0 );`
	`38`	`+* double out = largeIntegers( 1.2676506002282294e+30, 9007199254740992.0 );`
`39`	`39`	`* // returns 9007199254740992.0`
`40`	`40`	`*/`
`41`	`41`	`static double largeIntegers( const double a, const double b ) {`