diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dcovarmtk/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/dcovarmtk/README.md
index ee9209b46c76..d01191130450 100644
--- a/lib/node_modules/@stdlib/stats/base/ndarray/dcovarmtk/README.md
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dcovarmtk/README.md
@@ -186,6 +186,219 @@ console.log( v );
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+#include "stdlib/stats/base/ndarray/dcovarmtk.h"
+```
+
+#### stdlib_stats_dcovarmtk( arrays )
+
+Computes the covariance of two one-dimensional double-precision floating-point ndarrays provided known means and using a one-pass textbook algorithm.
+
+```c
+#include "stdlib/ndarray/ctor.h"
+#include "stdlib/ndarray/dtypes.h"
+#include "stdlib/ndarray/index_modes.h"
+#include "stdlib/ndarray/orders.h"
+#include "stdlib/ndarray/base/bytes_per_element.h"
+#include
+
+// Create input ndarrays:
+const double xdata[] = { 1.0, -2.0, 2.0 };
+const double ydata[] = { 2.0, -2.0, 1.0 };
+int64_t shape[] = { 3 };
+int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };
+int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };
+
+struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)xdata, 1, shape, strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );
+struct ndarray *y = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)ydata, 1, shape, strides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );
+
+// Create an ndarray for specifying the degrees of freedom adjustment:
+const double cdata[] = { 1.0 };
+int64_t sstrides[] = { 0 };
+struct ndarray *corr = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)cdata, 0, NULL, sstrides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );
+
+// Create ndarrays for specifying the known means:
+const double mxdata[] = { 1.0/3.0 };
+const double mydata[] = { 1.0/3.0 };
+struct ndarray *meanx = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)mxdata, 0, NULL, sstrides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );
+struct ndarray *meany = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)mydata, 0, NULL, sstrides, 0, STDLIB_NDARRAY_ROW_MAJOR, STDLIB_NDARRAY_INDEX_ERROR, 1, submodes );
+
+// Compute the result:
+const struct ndarray *arrays[] = { x, y, corr, meanx, meany };
+double v = stdlib_stats_dcovarmtk( arrays );
+// returns ~3.8333
+
+// Free allocated memory:
+stdlib_ndarray_free( x );
+stdlib_ndarray_free( y );
+stdlib_ndarray_free( corr );
+stdlib_ndarray_free( meanx );
+stdlib_ndarray_free( meany );
+```
+
+The function accepts the following arguments:
+
+- **arrays**: `[in] struct ndarray**` list containing the following ndarrays:
+
+ - `[in] struct ndarray*` first one-dimensional input ndarray.
+ - `[in] struct ndarray*` second one-dimensional input ndarray.
+ - `[in] struct ndarray*` a zero-dimensional ndarray specifying the degrees of freedom adjustment. Setting this parameter to a value other than `0` has the effect of adjusting the divisor during the calculation of the [covariance][covariance] according to `N-c` where `c` corresponds to the provided degrees of freedom adjustment and `N` corresponds to the number of elements in each input ndarray. When computing the population [covariance][covariance], setting this parameter to `0` is the standard choice (i.e., the provided arrays contain data constituting entire populations). When computing the unbiased sample [covariance][covariance], setting this parameter to `1` is the standard choice (i.e., the provided arrays contain data sampled from larger populations; this is commonly referred to as Bessel's correction).
+ - `[in] struct ndarray*` a zero-dimensional ndarray specifying the mean of the first one-dimensional ndarray.
+ - `[in] struct ndarray*` a zero-dimensional ndarray specifying the mean of the second one-dimensional ndarray.
+
+```c
+double stdlib_stats_dcovarmtk( const struct ndarray *arrays[] );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+#include "stdlib/stats/base/ndarray/dcovarmtk.h"
+#include "stdlib/ndarray/ctor.h"
+#include "stdlib/ndarray/dtypes.h"
+#include "stdlib/ndarray/index_modes.h"
+#include "stdlib/ndarray/orders.h"
+#include "stdlib/ndarray/base/bytes_per_element.h"
+#include
+#include
+#include
+
+int main( void ) {
+ // Create data buffers:
+ const double xdata[] = { 1.0, -2.0, 3.0, -4.0, 5.0, -6.0, 7.0, -8.0 };
+ const double ydata[] = { 2.0, -2.0, 1.0, -4.0, 3.0, -6.0, 5.0, -8.0 };
+
+ // Specify the number of array dimensions:
+ const int64_t ndims = 1;
+
+ // Specify the array shape:
+ int64_t shape[] = { 4 };
+
+ // Specify the array strides:
+ int64_t strides[] = { 2 * STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };
+
+ // Specify the byte offset:
+ const int64_t offset = 0;
+
+ // Specify the array order:
+ const enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;
+
+ // Specify the index mode:
+ const enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;
+
+ // Specify the subscript index modes:
+ int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };
+ const int64_t nsubmodes = 1;
+
+ // Create the first input ndarray:
+ struct ndarray *x = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)xdata, ndims, shape, strides, offset, order, imode, nsubmodes, submodes );
+ if ( x == NULL ) {
+ fprintf( stderr, "Error allocating memory.\n" );
+ exit( 1 );
+ }
+
+ // Create the second input ndarray:
+ struct ndarray *y = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)ydata, ndims, shape, strides, offset, order, imode, nsubmodes, submodes );
+ if ( y == NULL ) {
+ fprintf( stderr, "Error allocating memory.\n" );
+ exit( 1 );
+ }
+
+ // Create a data buffer for an ndarray specifying the degrees of freedom adjustment:
+ const double cdata[] = { 1.0 };
+
+ // Create data buffers for ndarrays specifying the means of the input ndarrays:
+ const double mxdata[] = { 4.0 };
+ const double mydata[] = { 2.75 };
+
+ // Specify the array strides for zero-dimensional ndarrays:
+ int64_t sstrides[] = { 0 };
+
+ // Create an ndarray for the degrees of freedom adjustment:
+ struct ndarray *corr = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)cdata, 0, NULL, sstrides, 0, order, imode, nsubmodes, submodes );
+ if ( corr == NULL ) {
+ fprintf( stderr, "Error allocating memory.\n" );
+ exit( 1 );
+ }
+
+ // Create an ndarray for the mean of the first input ndarray:
+ struct ndarray *meanx = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)mxdata, 0, NULL, sstrides, 0, order, imode, nsubmodes, submodes );
+ if ( meanx == NULL ) {
+ fprintf( stderr, "Error allocating memory.\n" );
+ exit( 1 );
+ }
+
+ // Create an ndarray for the mean of the second input ndarray:
+ struct ndarray *meany = stdlib_ndarray_allocate( STDLIB_NDARRAY_FLOAT64, (uint8_t *)mydata, 0, NULL, sstrides, 0, order, imode, nsubmodes, submodes );
+ if ( meany == NULL ) {
+ fprintf( stderr, "Error allocating memory.\n" );
+ exit( 1 );
+ }
+
+ // Define a list of ndarrays:
+ const struct ndarray *arrays[] = { x, y, corr, meanx, meany };
+
+ // Compute the result:
+ double v = stdlib_stats_dcovarmtk( arrays );
+
+ // Print the result:
+ printf( "result: %lf\n", v );
+
+ // Free allocated memory:
+ stdlib_ndarray_free( x );
+ stdlib_ndarray_free( y );
+ stdlib_ndarray_free( corr );
+ stdlib_ndarray_free( meanx );
+ stdlib_ndarray_free( meany );
+}
+```
+
+
+
+
+
+
+
+
+