fix: correct typo in enum name and fix C examples

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:

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

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 );

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 )

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 ) {

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 ) {

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;

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

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 ) {

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;

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;

lib/node_modules/@stdlib/ml/base/kmeans/algorithms/include/stdlib/ml/base/kmeans/algorithms.h

@@ -22,7 +22,7 @@
 /**
 * Enumeration of k-means clustering algorithms.
 */
-enum STDLIB_ML_KMEANS_ALGORITHMS {
+enum STDLIB_ML_KMEANS_ALGORITHM {
 	// Classic EM-style algorithm:
 	STDLIB_ML_KMEANS_LLOYD = 0,
 

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>
 

lib/node_modules/@stdlib/ndarray/base/flatten-shape-from/src/main.c

@@ -35,7 +35,7 @@
 * const int64_t shape[] = { 2, 3, 10 };
 * int64_t out[ 2 ];
 *
-* stdlib_ndarray_flatten_shape( ndims, shape, 1, out );
+* stdlib_ndarray_flatten_shape_from( ndims, shape, 1, out );
 */
 int8_t stdlib_ndarray_flatten_shape_from( const int64_t ndims, const int64_t *shape, const int64_t dim, int64_t *out ) {
 	int64_t d;

lib/node_modules/@stdlib/ndarray/base/function-object/README.md

@@ -107,6 +107,8 @@ console.log( headerDir );
 
 Structure for grouping ndarray function information.
 
+<!-- run-disable -->
+
 ```c
 struct ndarrayFunctionObject {
     // ndarray function name:

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();

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;

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 ];

lib/node_modules/@stdlib/ndarray/ctor/README.md

@@ -721,6 +721,8 @@ str = JSON.stringify( arr.toJSON() );
 
 Structure holding ndarray data.
 
+<!-- run-disable -->
+
 ```c
 #include "stdlib/ndarray/dtypes.h"
 #include "stdlib/ndarray/index_modes.h"

lib/node_modules/@stdlib/stats/base/ztest/one-sample/results/float32/README.md

@@ -320,6 +320,8 @@ console.log( str );
 
 Structure for holding single-precision floating-point test results.
 
+<!-- run-disable -->
+
 ```c
 #include <stdbool.h>
 #include <stdint.h>

lib/node_modules/@stdlib/stats/base/ztest/one-sample/results/float64/README.md

@@ -320,6 +320,8 @@ console.log( str );
 
 Structure for holding double-precision floating-point test results.
 
+<!-- run-disable -->
+
 ```c
 #include <stdbool.h>
 #include <stdint.h>

lib/node_modules/@stdlib/stats/base/ztest/two-sample/results/float32/README.md

@@ -338,6 +338,8 @@ console.log( str );
 
 Structure for holding single-precision floating-point test results.
 
+<!-- run-disable -->
+
 ```c
 #include <stdbool.h>
 #include <stdint.h>

lib/node_modules/@stdlib/stats/base/ztest/two-sample/results/float64/README.md

@@ -338,6 +338,8 @@ console.log( str );
 
 Structure for holding double-precision floating-point test results.
 
+<!-- run-disable -->
+
 ```c
 #include <stdbool.h>
 #include <stdint.h>

lib/node_modules/@stdlib/strided/base/function-object/README.md

@@ -107,6 +107,8 @@ console.log( headerDir );
 
 Structure for grouping strided array function information.
 
+<!-- run-disable -->
+
 ```c
 struct StridedFunctionObject {
     // Strided array function name:

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 ];