docs: update REPL namespace documentation

PR-URL: #4304

Co-authored-by: Philipp Burckhardt <[email protected]>
Reviewed-by: Philipp Burckhardt <[email protected]>
Signed-off-by: stdlib-bot <[email protected]>

Author: stdlib-bot

lib/node_modules/@stdlib/repl/code-blocks/data/data.csv

@@ -1732,8 +1732,8 @@ base.strided.dmap2,"\nbase.strided.dmap2( N:integer, x:Float64Array, sx:integer,
 base.strided.dmap2.ndarray,"\nbase.strided.dmap2.ndarray( N:integer, x:Float64Array, sx:integer, ox:integer, \n  y:Float64Array, sy:integer, oy:integer, z:Float64Array, sz:integer, \n  oz:integer, fcn:Function )\n    Applies a unary function to each element retrieved from a strided input\n    array according to a callback function and assigns results to a strided\n    output array using alternative indexing semantics.\n"
 base.strided.dmax,"\nbase.strided.dmax( N:integer, x:Float64Array, strideX:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array.\n"
 base.strided.dmax.ndarray,"\nbase.strided.dmax.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer )\n    Computes the maximum value of a double-precision floating-point strided\n    array using alternative indexing semantics.\n"
-base.strided.dmaxabs,"\nbase.strided.dmaxabs( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array.\n"
-base.strided.dmaxabs.ndarray,"\nbase.strided.dmaxabs.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array using alternative indexing semantics.\n"
+base.strided.dmaxabs,"\nbase.strided.dmaxabs( N:integer, x:Float64Array, strideX:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array.\n"
+base.strided.dmaxabs.ndarray,"\nbase.strided.dmaxabs.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer )\n    Computes the maximum absolute value of a double-precision floating-point\n    strided array using alternative indexing semantics.\n"
 base.strided.dmaxabssorted,"\nbase.strided.dmaxabssorted( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum absolute value of a sorted double-precision floating-\n    point strided array.\n"
 base.strided.dmaxabssorted.ndarray,"\nbase.strided.dmaxabssorted.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a sorted double-precision floating-\n    point strided array using alternative indexing semantics.\n"
 base.strided.dmaxsorted,"\nbase.strided.dmaxsorted( N:integer, x:Float64Array, stride:integer )\n    Computes the maximum value of a sorted double-precision floating-point\n    strided array.\n"
@@ -2315,10 +2315,10 @@ base.strided.smediansorted,"\nbase.strided.smediansorted( N:integer, x:Float32Ar
 base.strided.smediansorted.ndarray,"\nbase.strided.smediansorted.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the median value of a sorted single-precision floating-point\n    strided array using alternative indexing semantics.\n"
 base.strided.smidrange,"\nbase.strided.smidrange( N:integer, x:Float32Array, stride:integer )\n    Computes the mid-range of a single-precision floating-point strided array.\n"
 base.strided.smidrange.ndarray,"\nbase.strided.smidrange.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the mid-range of a single-precision floating-point strided array\n    using alternative indexing semantics.\n"
-base.strided.smin,"\nbase.strided.smin( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array.\n"
-base.strided.smin.ndarray,"\nbase.strided.smin.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array using alternative indexing semantics.\n"
-base.strided.sminabs,"\nbase.strided.sminabs( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array.\n"
-base.strided.sminabs.ndarray,"\nbase.strided.sminabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array using alternative indexing semantics.\n"
+base.strided.smin,"\nbase.strided.smin( N:integer, x:Float32Array, strideX:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array.\n"
+base.strided.smin.ndarray,"\nbase.strided.smin.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array using alternative indexing semantics.\n"
+base.strided.sminabs,"\nbase.strided.sminabs( N:integer, x:Float32Array, strideX:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array.\n"
+base.strided.sminabs.ndarray,"\nbase.strided.sminabs.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array using alternative indexing semantics.\n"
 base.strided.sminsorted,"\nbase.strided.sminsorted( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum value of a sorted single-precision floating-point\n    strided array.\n"
 base.strided.sminsorted.ndarray,"\nbase.strided.sminsorted.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a sorted single-precision floating-point\n    strided array using alternative indexing semantics.\n"
 base.strided.smskabs,"\nbase.strided.smskabs( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Computes the absolute value for each element in a single-precision floating-\n    point strided array `x` according to a strided mask array and assigns the\n    results to elements in a single-precision floating-point strided array `y`.\n"
@@ -2353,8 +2353,8 @@ base.strided.smsksqrt,"\nbase.strided.smsksqrt( N:integer, x:Float32Array, sx:in
 base.strided.smsksqrt.ndarray,"\nbase.strided.smsksqrt.ndarray( N:integer, x:Float32Array, sx:integer, \n  ox:integer, m:Float32Array, sm:integer, om:integer, y:Float32Array, \n  sy:integer, oy:integer )\n    Computes the principal square root for each element in a single-precision\n    floating-point strided array `x` according to a strided mask array and\n    assigns the results to elements in a single-precision floating-point strided\n    array `y` using alternative indexing semantics.\n"
 base.strided.smsktrunc,"\nbase.strided.smsktrunc( N:integer, x:Float32Array, sx:integer, m:Uint8Array, \n  sm:integer, y:Float32Array, sy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward zero according to a strided mask array and assigns the results to\n    elements in a single-precision floating-point strided array `y`.\n"
 base.strided.smsktrunc.ndarray,"\nbase.strided.smsktrunc.ndarray( N:integer, x:Float32Array, sx:integer, \n  ox:integer, m:Float32Array, sm:integer, om:integer, y:Float32Array, \n  sy:integer, oy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward zero according to a strided mask array and assigns the results to\n    elements in a single-precision floating-point strided array `y` using\n    alternative indexing semantics.\n"
-base.strided.snanmax,"\nbase.strided.snanmax( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
-base.strided.snanmax.ndarray,"\nbase.strided.snanmax.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
+base.strided.snanmax,"\nbase.strided.snanmax( N:integer, x:Float32Array, strideX:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
+base.strided.snanmax.ndarray,"\nbase.strided.snanmax.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
 base.strided.snanmaxabs,"\nbase.strided.snanmaxabs( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
 base.strided.snanmaxabs.ndarray,"\nbase.strided.snanmaxabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
 base.strided.snanmean,"\nbase.strided.snanmean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
@@ -2365,8 +2365,8 @@ base.strided.snanmeanpn,"\nbase.strided.snanmeanpn( N:integer, x:Float32Array, s
 base.strided.snanmeanpn.ndarray,"\nbase.strided.snanmeanpn.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using a two-pass error correction algorithm\n    and alternative indexing semantics.\n"
 base.strided.snanmeanwd,"\nbase.strided.snanmeanwd( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using Welford's algorithm.\n"
 base.strided.snanmeanwd.ndarray,"\nbase.strided.snanmeanwd.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using Welford's algorithm and alternative\n    indexing semantics.\n"
-base.strided.snanmin,"\nbase.strided.snanmin( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
-base.strided.snanmin.ndarray,"\nbase.strided.snanmin.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
+base.strided.snanmin,"\nbase.strided.snanmin( N:integer, x:Float32Array, strideX:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
+base.strided.snanmin.ndarray,"\nbase.strided.snanmin.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
 base.strided.snanminabs,"\nbase.strided.snanminabs( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
 base.strided.snanminabs.ndarray,"\nbase.strided.snanminabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
 base.strided.snanmskmax,"\nbase.strided.snanmskmax( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values.\n"
@@ -2415,8 +2415,8 @@ base.strided.snrm2,"\nbase.strided.snrm2( N:integer, x:Float32Array, stride:inte
 base.strided.snrm2.ndarray,"\nbase.strided.snrm2.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the L2-norm of a single-precision floating-point vector using\n    alternative indexing semantics.\n"
 base.strided.sramp,"\nbase.strided.sramp( N:integer, x:Float32Array, strideX:integer, y:Float32Array, \n  strideY:integer )\n    Evaluates the ramp function for each element in a single-precision floating-\n    point strided array `x` and assigns the results to elements in a single-\n    precision floating-point strided array `y`.\n"
 base.strided.sramp.ndarray,"\nbase.strided.sramp.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, y:Float32Array, strideY:integer, offsetY:integer )\n    Evaluates the ramp function for each element in a single-precision floating-\n    point strided array `x` and assigns the results to elements in a single-\n    precision floating-point strided array `y` using alternative indexing\n    semantics.\n"
-base.strided.srange,"\nbase.strided.srange( N:integer, x:Float32Array, stride:integer )\n    Computes the range of a single-precision floating-point strided array.\n"
-base.strided.srange.ndarray,"\nbase.strided.srange.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the range of a single-precision floating-point strided array using\n    alternative indexing semantics.\n"
+base.strided.srange,"\nbase.strided.srange( N:integer, x:Float32Array, strideX:integer )\n    Computes the range of a single-precision floating-point strided array.\n"
+base.strided.srange.ndarray,"\nbase.strided.srange.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the range of a single-precision floating-point strided array using\n    alternative indexing semantics.\n"
 base.strided.srev,"\nbase.strided.srev( N:integer, x:Float32Array, stride:integer )\n    Reverses a single-precision floating-point strided array in-place.\n"
 base.strided.srev.ndarray,"\nbase.strided.srev.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Reverses a single-precision floating-point strided array in-place using\n    alternative indexing semantics.\n"
 base.strided.srsqrt,"\nbase.strided.srsqrt( N:integer, x:Float32Array, strideX:integer, \n  y:Float32Array, strideY:integer )\n    Computes the reciprocal square root for each element in a single-precision\n    floating-point strided array `x` and assigns the results to elements in a\n    single-precision floating-point strided array `y`.\n"

lib/node_modules/@stdlib/repl/code-blocks/data/data.json

@@ -1733,8 +1733,8 @@ base.strided.dmap2,"base.strided.dmap2( N, x, sx, y, sy, z, sz, fcn )"
 base.strided.dmap2.ndarray,"base.strided.dmap2.ndarray( N, x, sx, ox, y, sy, oy, z, sz, oz, fcn )"
 base.strided.dmax,"base.strided.dmax( N, x, strideX )"
 base.strided.dmax.ndarray,"base.strided.dmax.ndarray( N, x, strideX, offsetX )"
-base.strided.dmaxabs,"base.strided.dmaxabs( N, x, stride )"
-base.strided.dmaxabs.ndarray,"base.strided.dmaxabs.ndarray( N, x, stride, offset )"
+base.strided.dmaxabs,"base.strided.dmaxabs( N, x, strideX )"
+base.strided.dmaxabs.ndarray,"base.strided.dmaxabs.ndarray( N, x, strideX, offsetX )"
 base.strided.dmaxabssorted,"base.strided.dmaxabssorted( N, x, stride )"
 base.strided.dmaxabssorted.ndarray,"base.strided.dmaxabssorted.ndarray( N, x, stride, offset )"
 base.strided.dmaxsorted,"base.strided.dmaxsorted( N, x, stride )"
@@ -2316,10 +2316,10 @@ base.strided.smediansorted,"base.strided.smediansorted( N, x, stride )"
 base.strided.smediansorted.ndarray,"base.strided.smediansorted.ndarray( N, x, stride, offset )"
 base.strided.smidrange,"base.strided.smidrange( N, x, stride )"
 base.strided.smidrange.ndarray,"base.strided.smidrange.ndarray( N, x, stride, offset )"
-base.strided.smin,"base.strided.smin( N, x, stride )"
-base.strided.smin.ndarray,"base.strided.smin.ndarray( N, x, stride, offset )"
-base.strided.sminabs,"base.strided.sminabs( N, x, stride )"
-base.strided.sminabs.ndarray,"base.strided.sminabs.ndarray( N, x, stride, offset )"
+base.strided.smin,"base.strided.smin( N, x, strideX )"
+base.strided.smin.ndarray,"base.strided.smin.ndarray( N, x, strideX, offsetX )"
+base.strided.sminabs,"base.strided.sminabs( N, x, strideX )"
+base.strided.sminabs.ndarray,"base.strided.sminabs.ndarray( N, x, strideX, offsetX )"
 base.strided.sminsorted,"base.strided.sminsorted( N, x, stride )"
 base.strided.sminsorted.ndarray,"base.strided.sminsorted.ndarray( N, x, stride, offset )"
 base.strided.smskabs,"base.strided.smskabs( N, x, sx, m, sm, y, sy )"
@@ -2354,8 +2354,8 @@ base.strided.smsksqrt,"base.strided.smsksqrt( N, x, sx, m, sm, y, sy )"
 base.strided.smsksqrt.ndarray,"base.strided.smsksqrt.ndarray( N, x, sx, ox, m, sm, om, y, sy, oy )"
 base.strided.smsktrunc,"base.strided.smsktrunc( N, x, sx, m, sm, y, sy )"
 base.strided.smsktrunc.ndarray,"base.strided.smsktrunc.ndarray( N, x, sx, ox, m, sm, om, y, sy, oy )"
-base.strided.snanmax,"base.strided.snanmax( N, x, stride )"
-base.strided.snanmax.ndarray,"base.strided.snanmax.ndarray( N, x, stride, offset )"
+base.strided.snanmax,"base.strided.snanmax( N, x, strideX )"
+base.strided.snanmax.ndarray,"base.strided.snanmax.ndarray( N, x, strideX, offsetX )"
 base.strided.snanmaxabs,"base.strided.snanmaxabs( N, x, stride )"
 base.strided.snanmaxabs.ndarray,"base.strided.snanmaxabs.ndarray( N, x, stride, offset )"
 base.strided.snanmean,"base.strided.snanmean( N, x, stride )"
@@ -2366,8 +2366,8 @@ base.strided.snanmeanpn,"base.strided.snanmeanpn( N, x, stride )"
 base.strided.snanmeanpn.ndarray,"base.strided.snanmeanpn.ndarray( N, x, stride, offset )"
 base.strided.snanmeanwd,"base.strided.snanmeanwd( N, x, stride )"
 base.strided.snanmeanwd.ndarray,"base.strided.snanmeanwd.ndarray( N, x, stride, offset )"
-base.strided.snanmin,"base.strided.snanmin( N, x, stride )"
-base.strided.snanmin.ndarray,"base.strided.snanmin.ndarray( N, x, stride, offset )"
+base.strided.snanmin,"base.strided.snanmin( N, x, strideX )"
+base.strided.snanmin.ndarray,"base.strided.snanmin.ndarray( N, x, strideX, offsetX )"
 base.strided.snanminabs,"base.strided.snanminabs( N, x, stride )"
 base.strided.snanminabs.ndarray,"base.strided.snanminabs.ndarray( N, x, stride, offset )"
 base.strided.snanmskmax,"base.strided.snanmskmax( N, x, strideX, mask, strideMask )"
@@ -2416,8 +2416,8 @@ base.strided.snrm2,"base.strided.snrm2( N, x, stride )"
 base.strided.snrm2.ndarray,"base.strided.snrm2.ndarray( N, x, stride, offset )"
 base.strided.sramp,"base.strided.sramp( N, x, strideX, y, strideY )"
 base.strided.sramp.ndarray,"base.strided.sramp.ndarray( N, x, strideX, offsetX, y, strideY, offsetY )"
-base.strided.srange,"base.strided.srange( N, x, stride )"
-base.strided.srange.ndarray,"base.strided.srange.ndarray( N, x, stride, offset )"
+base.strided.srange,"base.strided.srange( N, x, strideX )"
+base.strided.srange.ndarray,"base.strided.srange.ndarray( N, x, strideX, offsetX )"
 base.strided.srev,"base.strided.srev( N, x, stride )"
 base.strided.srev.ndarray,"base.strided.srev.ndarray( N, x, stride, offset )"
 base.strided.srsqrt,"base.strided.srsqrt( N, x, strideX, y, strideY )"