Special Functions

Strided array special math functions.

Installation

npm install @stdlib/math-strided-special

Usage

var ns = require( '@stdlib/math-strided-special' );

ns

Namespace containing strided array special math functions.

var special = ns;
// returns {...}

The namespace contains the following strided array functions:

• absBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the absolute value of each element retrieved from a strided input array via a callback function and assign each result to an element in a strided output array.
• abs( N, dtypeX, x, strideX, dtypeY, y, strideY ): compute the absolute value for each element in a strided array.
• abs2By( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the squared absolute value of each element retrieved from an input strided array via a callback function.
• abs2( N, dtypeX, x, strideX, dtypeY, y, strideY ): compute the squared absolute value for each element in a strided array.
• acosBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the arccosine of each element retrieved from an input strided array via a callback function.
• acoshBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the hyperbolic arccosine of each element retrieved from an input strided array via a callback function.
• acotBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse cotangent of each element retrieved from an input strided array via a callback function.
• acothBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse hyperbolic cotangent of each element retrieved from an input strided array via a callback function.
• acovercosBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse coversed cosine of each element retrieved from an input strided array via a callback function.
• acoversinBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse coversed sine of each element retrieved from an input strided array via a callback function.
• ahavercosBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse half-value versed cosine of each element retrieved from an input strided array via a callback function.
• ahaversinBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse half-value versed sine of each element retrieved from an input strided array via a callback function.
• asinBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the arcsine of each element retrieved from an input strided array via a callback function.
• asinhBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the hyperbolic arcsine of each element retrieved from an input strided array via a callback function.
• atanBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the arctangent of each element retrieved from an input strided array via a callback function.
• atanhBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the hyperbolic arctangent of each element retrieved from an input strided array via a callback function.
• avercosBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse versed cosine of each element retrieved from an input strided array via a callback function.
• aversinBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the inverse versed sine of each element retrieved from an input strided array via a callback function.
• besselj0By( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the Bessel function of the first kind of order zero for each element retrieved from an input strided array via a callback function.
• besselj1By( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the Bessel function of the first kind of order one for each element retrieved from an input strided array via a callback function.
• bessely0By( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the Bessel function of the second kind of order zero for each element retrieved from an input strided array via a callback function.
• bessely1By( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the Bessel function of the second kind of order one for each element retrieved from an input strided array via a callback function.
• binetBy( N, x, strideX, y, strideY, clbk[, thisArg] ): evaluate Binet's formula extended to real numbers for each element retrieved from an input strided array via a callback function.
• cbrtBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the cube root of each element retrieved from an input strided array via a callback function.
• cbrt( N, x, strideX, y, strideY ): compute the cube root of each element in a strided array.
• ceil( N, dtypeX, x, strideX, dtypeY, y, strideY ): round each element in a strided array toward positive infinity.
• cosBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the cosine for each element retrieved from an input strided array via a callback function.
• dabs( N, x, strideX, y, strideY ): compute the absolute value for each element in a double-precision floating-point strided array.
• dabs2( N, x, strideX, y, strideY ): compute the squared absolute value for each element in a double-precision floating-point strided array.
• dcbrtBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the cube root of each element retrieved from a double-precision floating-point strided array via a callback function.
• dcbrt( N, x, strideX, y, strideY ): compute the cube root of each element in a double-precision floating-point strided array.
• dceil( N, x, strideX, y, strideY ): round each element in a double-precision floating-point strided array toward positive infinity.
• ddeg2rad( N, x, strideX, y, strideY ): convert each element in a double-precision floating-point strided array from degrees to radians.
• deg2rad( N, dtypeX, x, strideX, dtypeY, y, strideY ): convert each element in a strided array from degrees to radians.
• dfloor( N, x, strideX, y, strideY ): round each element in a double-precision floating-point strided array toward negative infinity.
• dinv( N, x, strideX, y, strideY ): compute the multiplicative inverse for each element in a double-precision floating-point strided array.
• dmskabs( N, x, sx, m, sm, y, sy ): compute the absolute value for each element in a double-precision floating-point strided array according to a strided mask array.
• dmskabs2( N, x, sx, m, sm, y, sy ): compute the squared absolute value for each element in a double-precision floating-point strided array according to a strided mask array.
• dmskcbrt( N, x, sx, m, sm, y, sy ): compute the cube root for each element in a double-precision floating-point strided array according to a strided mask array.
• dmskceil( N, x, sx, m, sm, y, sy ): round each element in a double-precision floating-point strided array toward positive infinity according to a strided mask array.
• dmskdeg2rad( N, x, sx, m, sm, y, sy ): convert each element in a double-precision floating-point strided array from degrees to radians according to a strided mask array.
• dmskfloor( N, x, sx, m, sm, y, sy ): round each element in a double-precision floating-point strided array toward negative infinity according to a strided mask array.
• dmskinv( N, x, sx, m, sm, y, sy ): compute the multiplicative inverse for each element in a double-precision floating-point strided array according to a strided mask array.
• dmskramp( N, x, sx, m, sm, y, sy ): evaluate the ramp function for each element in a double-precision floating-point strided array according to a strided mask array.
• dmskrsqrt( N, x, sx, m, sm, y, sy ): compute the reciprocal square root for each element in a double-precision floating-point strided array according to a strided mask array.
• dmsksqrt( N, x, sx, m, sm, y, sy ): compute the principal square root for each element in a double-precision floating-point strided array according to a strided mask array.
• dmsktrunc( N, x, sx, m, sm, y, sy ): round each element in a double-precision floating-point strided array toward zero according to a strided mask array.
• dramp( N, x, strideX, y, strideY ): evaluate the ramp function for each element in a double-precision floating-point strided array.
• drsqrt( N, x, strideX, y, strideY ): compute the reciprocal square root for each element in a double-precision floating-point strided array.
• dsqrt( N, x, strideX, y, strideY ): compute the principal square root for each element in a double-precision floating-point strided array.
• dtrunc( N, x, strideX, y, strideY ): round each element in a double-precision floating-point strided array toward zero.
• floor( N, dtypeX, x, strideX, dtypeY, y, strideY ): round each element in a strided array toward negative infinity.
• inv( N, dtypeX, x, strideX, dtypeY, y, strideY ): compute the multiplicative inverse for each element in a strided array.
• ramp( N, dtypeX, x, strideX, dtypeY, y, strideY ): evaluate the ramp function for each element in a strided array.
• rsqrt( N, dtypeX, x, strideX, dtypeY, y, strideY ): compute the reciprocal square root for each element in a strided array.
• sabs( N, x, strideX, y, strideY ): compute the absolute value for each element in a single-precision floating-point strided array.
• sabs2( N, x, strideX, y, strideY ): compute the squared absolute value for each element in a single-precision floating-point strided array.
• scbrt( N, x, strideX, y, strideY ): compute the cube root of each element in a single-precision floating-point strided array.
• sceil( N, x, strideX, y, strideY ): round each element in a single-precision floating-point strided array toward positive infinity.
• sdeg2rad( N, x, strideX, y, strideY ): convert each element in a single-precision floating-point strided array from degrees to radians.
• sfloor( N, x, strideX, y, strideY ): round each element in a single-precision floating-point strided array toward negative infinity.
• sinBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the sine of each element retrieved from an input strided array via a callback function.
• sinv( N, x, strideX, y, strideY ): compute the multiplicative inverse for each element in a single-precision floating-point strided array.
• smskabs( N, x, sx, m, sm, y, sy ): compute the absolute value for each element in a single-precision floating-point strided array according to a strided mask array.
• smskabs2( N, x, sx, m, sm, y, sy ): compute the squared absolute value for each element in a single-precision floating-point strided array according to a strided mask array.
• smskcbrt( N, x, sx, m, sm, y, sy ): compute the cube root for each element in a single-precision floating-point strided array according to a strided mask array.
• smskceil( N, x, sx, m, sm, y, sy ): round each element in a single-precision floating-point strided array toward positive infinity according to a strided mask array.
• smskdeg2rad( N, x, sx, m, sm, y, sy ): convert each element in a single-precision floating-point strided array from degrees to radians according to a strided mask array.
• smskfloor( N, x, sx, m, sm, y, sy ): round each element in a single-precision floating-point strided array toward negative infinity according to a strided mask array.
• smskinv( N, x, sx, m, sm, y, sy ): compute the multiplicative inverse for each element in a single-precision floating-point strided array according to a strided mask array.
• smskramp( N, x, sx, m, sm, y, sy ): evaluate the ramp function for each element in a single-precision floating-point strided array according to a strided mask array.
• smskrsqrt( N, x, sx, m, sm, y, sy ): compute the reciprocal square root for each element in a single-precision floating-point strided array according to a strided mask array.
• smsksqrt( N, x, sx, m, sm, y, sy ): compute the principal square root for each element in a single-precision floating-point strided array according to a strided mask array.
• smsktrunc( N, x, sx, m, sm, y, sy ): round each element in a single-precision floating-point strided array toward zero according to a strided mask array.
• sqrtBy( N, x, strideX, y, strideY, clbk[, thisArg] ): compute the principal square root for each element retrieved from an input strided array via a callback function.
• sqrt( N, dtypeX, x, strideX, dtypeY, y, strideY ): compute the principal square root for each element in a strided array.
• sramp( N, x, strideX, y, strideY ): evaluate the ramp function for each element in a single-precision floating-point strided array.
• srsqrt( N, x, strideX, y, strideY ): compute the reciprocal square root for each element in a single-precision floating-point strided array.
• ssqrt( N, x, strideX, y, strideY ): compute the principal square root for each element in a single-precision floating-point strided array.
• strunc( N, x, strideX, y, strideY ): round each element in a single-precision floating-point strided array toward zero.
• trunc( N, dtypeX, x, strideX, dtypeY, y, strideY ): round each element in a strided array toward zero.

Examples

var objectKeys = require( '@stdlib/utils-keys' );
var ns = require( '@stdlib/math-strided-special' );

console.log( objectKeys( ns ) );

Notice

This package is part of stdlib, a standard library for JavaScript and Node.js, with an emphasis on numerical and scientific computing. The library provides a collection of robust, high performance libraries for mathematics, statistics, streams, utilities, and more.

For more information on the project, filing bug reports and feature requests, and guidance on how to develop stdlib, see the main project repository.

Community

License

See LICENSE.

Copyright

Copyright © 2016-2024. The Stdlib Authors.