From d42154be99d9276a85813c1e0d679eb94e37a5f9 Mon Sep 17 00:00:00 2001 From: kgryte <2643044+kgryte@users.noreply.github.com> Date: Thu, 30 Oct 2025 04:04:39 +0000 Subject: [PATCH] feat: update math scaffold databases Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> --- .../@stdlib/math/special/data/unary.json | 10249 +++++++++------- 1 file changed, 5692 insertions(+), 4557 deletions(-) diff --git a/lib/node_modules/@stdlib/math/special/data/unary.json b/lib/node_modules/@stdlib/math/special/data/unary.json index eb93f194313f..9ddecb0e8d1e 100644 --- a/lib/node_modules/@stdlib/math/special/data/unary.json +++ b/lib/node_modules/@stdlib/math/special/data/unary.json @@ -152,7 +152,144 @@ "math.abs" ] }, - "@stdlib/math/base/special/cabsf": {}, + "@stdlib/math/base/special/cabsf": { + "$schema": "math/base@v1.0", + "base_alias": "abs", + "alias": "cabsf", + "pkg_desc": "compute the absolute value of a single-precision complex floating-point number", + "desc": "computes the absolute value of a single-precision complex floating-point number", + "short_desc": "absolute value", + "parameters": [ + { + "name": "z", + "desc": "input value", + "type": { + "javascript": "Complex64", + "jsdoc": "Complex64", + "c": "stdlib_complex64_t", + "dtype": "complex64" + }, + "domain": null, + "rand": { + "prng": "random/base/uniform", + "parameters": [ + [ + -10, + 10 + ], + [ + -10, + 10 + ] + ] + }, + "example_values": [ + { + "re": -3.14, + "im": -1.5 + }, + { + "re": 0, + "im": 0 + }, + { + "re": -1.5, + "im": 2.5 + }, + { + "re": 2.5, + "im": -1.5 + }, + { + "re": 0, + "im": -3.7 + }, + { + "re": 4.2, + "im": 0 + }, + { + "re": 21.2, + "im": 3 + }, + { + "re": 11, + "im": -5 + }, + { + "re": 33, + "im": -14.67 + }, + { + "re": -42, + "im": 9.3 + }, + { + "re": -3, + "im": 3 + }, + { + "re": 73, + "im": 31 + }, + { + "re": -2.45, + "im": 1.23 + }, + { + "re": 2.45, + "im": -1.23 + }, + { + "re": 1.77, + "im": -3.14 + }, + { + "re": -7.5, + "im": 8.2 + }, + { + "re": 5.5, + "im": -12.3 + }, + { + "re": -15.8, + "im": 0.4 + }, + { + "re": 0.99, + "im": -0.99 + }, + { + "re": 0.43, + "im": 0.91 + } + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "absolute value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "abs", + "absolute", + "magnitude", + "modulus", + "distance", + "complex", + "cmplx" + ], + "extra_keywords": [ + "math.abs" + ] + }, "@stdlib/math/base/special/cabs": { "$schema": "math/base@v1.0", "base_alias": "abs", @@ -444,136 +581,639 @@ "math.abs" ] }, - "@stdlib/math/base/special/cabs2f": {}, - "@stdlib/math/base/special/cabs2": {}, - "@stdlib/math/base/special/absgammalnf": { + "@stdlib/math/base/special/cabs2f": { "$schema": "math/base@v1.0", - "base_alias": "absgammaln", - "alias": "absgammalnf", - "pkg_desc": "evaluate the natural logarithm of the absolute value of the gamma function", - "desc": "evaluates the natural logarithm of the absolute value of the gamma function", - "short_desc": "natural logarithm of the absolute value of the gamma function", + "base_alias": "abs2", + "alias": "cabs2f", + "pkg_desc": "compute the squared absolute value of a single-precision complex floating-point number", + "desc": "computes the squared absolute value of a single-precision complex floating-point number", + "short_desc": "squared absolute value", "parameters": [ { - "name": "x", + "name": "z", "desc": "input value", "type": { - "javascript": "number", - "jsdoc": "number", - "c": "float", - "dtype": "float32" + "javascript": "Complex64", + "jsdoc": "Complex64", + "c": "stdlib_complex64_t", + "dtype": "complex64" }, - "domain": [ - { - "min": "-infinity", - "max": "infinity" - } - ], + "domain": null, "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + [ + -10, + 10 + ], + [ + -10, + 10 + ] ] }, "example_values": [ - 64, - 27, - 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 - ] - } - ], - "output_policy": "real_floating_point_and_generic", - "returns": { - "desc": "natural logarithm of the absolute value of the gamma function", - "type": { - "javascript": "number", - "jsdoc": "number", - "c": "float", - "dtype": "float32" - } - }, - "keywords": [ - "absgammalnf", - "gamma", - "log", - "logarithm", - "natural", - "absolute", - "lgamma", - "lgammaf", - "single", - "precision" - ], - "extra_keywords": [] - }, - "@stdlib/math/base/special/gammaln": {}, - "@stdlib/math/base/special/acosf": { - "$schema": "math/base@v1.0", - "base_alias": "acos", - "alias": "acosf", - "pkg_desc": "compute the arccosine (in radians) of a single-precision floating-point number", - "desc": "computes the arccosine (in radians) of a single-precision floating-point number", - "short_desc": "arccosine", - "parameters": [ - { - "name": "x", - "desc": "input value", - "type": { - "javascript": "number", - "jsdoc": "number", - "c": "float", - "dtype": "float32" - }, - "domain": [ { - "min": -1, - "max": 1 - } - ], - "rand": { - "prng": "random/base/uniform", - "parameters": [ - -1, - 1 - ] - }, - "example_values": [ - 0.84, - -0.37, - 0.12, - -0.93, - 0.65, - -0.18, - 0.48, - -0.79, - 0.05, - -0.66, - 0.9, - -0.11, - -0.52, - 0.27, - 0.33, - -0.74, - 0, - 0.71, + "re": -3.14, + "im": -1.5 + }, + { + "re": 0, + "im": 0 + }, + { + "re": -1.5, + "im": 2.5 + }, + { + "re": 2.5, + "im": -1.5 + }, + { + "re": 0, + "im": -3.7 + }, + { + "re": 4.2, + "im": 0 + }, + { + "re": 21.2, + "im": 3 + }, + { + "re": 11, + "im": -5 + }, + { + "re": 33, + "im": -14.67 + }, + { + "re": -42, + "im": 9.3 + }, + { + "re": -3, + "im": 3 + }, + { + "re": 73, + "im": 31 + }, + { + "re": -2.45, + "im": 1.23 + }, + { + "re": 2.45, + "im": -1.23 + }, + { + "re": 1.77, + "im": -3.14 + }, + { + "re": -7.5, + "im": 8.2 + }, + { + "re": 5.5, + "im": -12.3 + }, + { + "re": -15.8, + "im": 0.4 + }, + { + "re": 0.99, + "im": -0.99 + }, + { + "re": 0.43, + "im": 0.91 + } + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "absolute value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "abs2", + "squared", + "absolute", + "magnitude", + "distance", + "complex", + "cmplx" + ], + "extra_keywords": [ + "math.abs" + ] + }, + "@stdlib/math/base/special/cabs2": { + "$schema": "math/base@v1.0", + "base_alias": "abs2", + "alias": "cabs2", + "pkg_desc": "compute the squared absolute value of a complex number", + "desc": "computes the squared absolute value of a complex number", + "short_desc": "squared absolute value", + "parameters": [ + { + "name": "z", + "desc": "input value", + "type": { + "javascript": "Complex128", + "jsdoc": "Complex128", + "c": "stdlib_complex128_t", + "dtype": "complex128" + }, + "domain": null, + "rand": { + "prng": "random/base/uniform", + "parameters": [ + [ + -10, + 10 + ], + [ + -10, + 10 + ] + ] + }, + "example_values": [ + { + "re": -3.14, + "im": -1.5 + }, + { + "re": 0, + "im": 0 + }, + { + "re": -1.5, + "im": 2.5 + }, + { + "re": 2.5, + "im": -1.5 + }, + { + "re": 0, + "im": -3.7 + }, + { + "re": 4.2, + "im": 0 + }, + { + "re": 21.2, + "im": 3 + }, + { + "re": 11, + "im": -5 + }, + { + "re": 33, + "im": -14.67 + }, + { + "re": -42, + "im": 9.3 + }, + { + "re": -3, + "im": 3 + }, + { + "re": 73, + "im": 31 + }, + { + "re": -2.45, + "im": 1.23 + }, + { + "re": 2.45, + "im": -1.23 + }, + { + "re": 1.77, + "im": -3.14 + }, + { + "re": -7.5, + "im": 8.2 + }, + { + "re": 5.5, + "im": -12.3 + }, + { + "re": -15.8, + "im": 0.4 + }, + { + "re": 0.99, + "im": -0.99 + }, + { + "re": 0.43, + "im": 0.91 + } + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "absolute value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "abs2", + "squared", + "absolute", + "magnitude", + "distance", + "complex", + "cmplx" + ], + "extra_keywords": [ + "math.abs" + ] + }, + "@stdlib/math/base/special/absgammalnf": { + "$schema": "math/base@v1.0", + "base_alias": "absgammaln", + "alias": "absgammalnf", + "pkg_desc": "evaluate the natural logarithm of the absolute value of the gamma function", + "desc": "evaluates the natural logarithm of the absolute value of the gamma function", + "short_desc": "natural logarithm of the absolute value of the gamma function", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -10, + 10 + ] + }, + "example_values": [ + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "natural logarithm of the absolute value of the gamma function", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "absgammalnf", + "gamma", + "log", + "logarithm", + "natural", + "absolute", + "lgamma", + "lgammaf", + "single", + "precision" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/gammaln": {}, + "@stdlib/math/base/special/acosf": { + "$schema": "math/base@v1.0", + "base_alias": "acos", + "alias": "acosf", + "pkg_desc": "compute the arccosine (in radians) of a single-precision floating-point number", + "desc": "computes the arccosine (in radians) of a single-precision floating-point number", + "short_desc": "arccosine", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": -1, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -1, + 1 + ] + }, + "example_values": [ + 0.84, + -0.37, + 0.12, + -0.93, + 0.65, + -0.18, + 0.48, + -0.79, + 0.05, + -0.66, + 0.9, + -0.11, + -0.52, + 0.27, + 0.33, + -0.74, + 0, + 0.71, + -0.25, + 0.58 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arccosine (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "acosf", + "arccosine", + "cosine", + "inverse", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/acos": { + "$schema": "math/base@v1.0", + "base_alias": "acos", + "alias": "acos", + "pkg_desc": "compute the arccosine (in radians) of a double-precision floating-point number", + "desc": "computes the arccosine (in radians) of a double-precision floating-point number", + "short_desc": "arccosine", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": -1, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -1, + 1 + ] + }, + "example_values": [ + 0.84, + -0.37, + 0.12, + -0.93, + 0.65, + -0.18, + 0.48, + -0.79, + 0.05, + -0.66, + 0.9, + -0.11, + -0.52, + 0.27, + 0.33, + -0.74, + 0, + 0.71, + -0.25, + 0.58 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arccosine (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acos", + "arccosine", + "inverse", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/acosdf": { + "$schema": "math/base@v1.0", + "base_alias": "acosd", + "alias": "acosdf", + "pkg_desc": "compute the arccosine (in degrees) of a single-precision floating-point number", + "desc": "computes the arccosine (in degrees) of a single-precision floating-point number", + "short_desc": "arccosine", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": -1, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -1, + 1 + ] + }, + "example_values": [ + 0.84, + -0.37, + 0.12, + -0.93, + 0.65, + -0.18, + 0.48, + -0.79, + 0.05, + -0.66, + 0.9, + -0.11, + -0.52, + 0.27, + 0.33, + -0.74, + 0, + 0.71, + -0.25, + 0.58 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arccosine (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "arccosine", + "cosine", + "inverse", + "trig", + "trigonometry", + "degrees" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/acosd": { + "$schema": "math/base@v1.0", + "base_alias": "acosd", + "alias": "acosd", + "pkg_desc": "compute the arccosine (in degrees) of a double-precision floating-point number", + "desc": "computes the arccosine (in degrees) of a double-precision floating-point number", + "short_desc": "arccosine", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": -1, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -1, + 1 + ] + }, + "example_values": [ + 0.84, + -0.37, + 0.12, + -0.93, + 0.65, + -0.18, + 0.48, + -0.79, + 0.05, + -0.66, + 0.9, + -0.11, + -0.52, + 0.27, + 0.33, + -0.74, + 0, + 0.71, -0.25, 0.58 ] @@ -581,7 +1221,322 @@ ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosine (in radians)", + "desc": "arccosine (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acosd", + "arccosine", + "inverse", + "trig", + "trigonometry", + "degrees" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/acosh": { + "$schema": "math/base@v1.0", + "base_alias": "acosh", + "alias": "acosh", + "pkg_desc": "compute the hyperbolic arccosine of double-precision floating-point number", + "desc": "computes the hyperbolic arccosine of double-precision floating-point number", + "short_desc": "hyperbolic arccosine", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1, + 10 + ] + }, + "example_values": [ + 64, + 27, + 1.1, + 6.5, + 9, + 8, + 1, + 125, + 10.2, + 11.3, + 12.4, + 3.5, + 1.6, + 15.7, + 16, + 17.9, + 188, + 19.11, + 200, + 21.15 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic arccosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acosh", + "hyperbolic", + "inverse", + "cosine", + "cos", + "arc", + "arccosine", + "trig", + "trigonometry" + ], + "extra_keywords": [ + "math.acosh" + ] + }, + "@stdlib/math/base/special/acotf": { + "$schema": "math/base@v1.0", + "base_alias": "acot", + "alias": "acotf", + "pkg_desc": "compute the inverse cotangent (in radians) of a single-precision floating-point number", + "desc": "computes the inverse cotangent (in radians) of a single-precision floating-point number", + "short_desc": "inverse cotangent", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -10, + 10 + ] + }, + "example_values": [ + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse cotangent (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "inverse", + "cotangent", + "acot", + "cot", + "arc", + "arccotangent", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [ + "math.acot" + ] + }, + "@stdlib/math/base/special/acot": { + "$schema": "math/base@v1.0", + "base_alias": "acot", + "alias": "acot", + "pkg_desc": "compute the inverse cotangent (in radians) of a double-precision floating-point number", + "desc": "computes the inverse cotangent (in radians) of a double-precision floating-point number", + "short_desc": "inverse cotangent", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -10, + 10 + ] + }, + "example_values": [ + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse cotangent (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "inverse", + "cotangent", + "acot", + "cot", + "arc", + "arccotangent", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [ + "math.acot" + ] + }, + "@stdlib/math/base/special/acotdf": { + "$schema": "math/base@v1.0", + "base_alias": "acotd", + "alias": "acotdf", + "pkg_desc": "compute the inverse cotangent (in degrees) of a single-precision floating-point number", + "desc": "computes the inverse cotangent (in degrees) of a single-precision floating-point number", + "short_desc": "inverse cotangent", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -10, + 10 + ] + }, + "example_values": [ + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse cotangent (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -590,25 +1545,28 @@ } }, "keywords": [ - "acosf", - "arccosine", - "cosine", "inverse", + "cotangent", + "acot", + "cot", + "arc", + "arccotangent", "trig", "trigonometry", - "radians" + "degrees", + "angle" ], "extra_keywords": [ - "math.acos" + "math.acot" ] }, - "@stdlib/math/base/special/acos": { + "@stdlib/math/base/special/acotd": { "$schema": "math/base@v1.0", - "base_alias": "acos", - "alias": "acos", - "pkg_desc": "compute the arccosine (in radians) of a double-precision floating-point number", - "desc": "computes the arccosine (in radians) of a double-precision floating-point number", - "short_desc": "arccosine", + "base_alias": "acotd", + "alias": "acotd", + "pkg_desc": "compute the inverse cotangent (in degrees) of a double-precision floating-point number", + "desc": "computes the inverse cotangent (in degrees) of a double-precision floating-point number", + "short_desc": "inverse cotangent", "parameters": [ { "name": "x", @@ -621,44 +1579,44 @@ }, "domain": [ { - "min": -1, - "max": 1 + "min": "-infinity", + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -1, - 1 + -10, + 10 ] }, "example_values": [ - 0.84, - -0.37, - 0.12, - -0.93, - 0.65, - -0.18, - 0.48, - -0.79, - 0.05, - -0.66, - 0.9, - -0.11, - -0.52, - 0.27, - 0.33, - -0.74, + 64, + 27, 0, - 0.71, - -0.25, - 0.58 + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosine (in radians)", + "desc": "inverse cotangent (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -667,24 +1625,28 @@ } }, "keywords": [ - "acos", - "arccosine", "inverse", + "cotangent", + "acot", + "cot", + "arc", + "arccotangent", "trig", "trigonometry", - "radians" + "degrees", + "angle" ], "extra_keywords": [ - "math.acos" + "math.acot" ] }, - "@stdlib/math/base/special/acosdf": { + "@stdlib/math/base/special/acoth": { "$schema": "math/base@v1.0", - "base_alias": "acosd", - "alias": "acosdf", - "pkg_desc": "compute the arccosine (in degrees) of a single-precision floating-point number", - "desc": "computes the arccosine (in degrees) of a single-precision floating-point number", - "short_desc": "arccosine", + "base_alias": "acoth", + "alias": "acoth", + "pkg_desc": "compute the inverse hyperbolic cotangent of a number", + "desc": "computes the inverse hyperbolic cotangent of a number", + "short_desc": "inverse hyperbolic cotangent", "parameters": [ { "name": "x", @@ -692,75 +1654,84 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { - "min": -1, - "max": 1 + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -1, - 1 + 1.1, + 10 ] }, "example_values": [ - 0.84, - -0.37, - 0.12, - -0.93, - 0.65, - -0.18, - 0.48, - -0.79, - 0.05, - -0.66, - 0.9, - -0.11, - -0.52, - 0.27, - 0.33, - -0.74, - 0, - 0.71, - -0.25, - 0.58 + 64, + 27, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15, + -1.2, + 1.7 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosine (in degrees)", + "desc": "inverse hyperbolic cotangent", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "arccosine", - "cosine", "inverse", + "cotangent", + "acot", + "cot", + "coth", + "arc", + "arccotangent", "trig", "trigonometry", - "degrees" + "radians", + "angle" ], "extra_keywords": [ - "math.acos" + "math.atanh" ] }, - "@stdlib/math/base/special/acosd": { + "@stdlib/math/base/special/acovercosf": { "$schema": "math/base@v1.0", - "base_alias": "acosd", - "alias": "acosd", - "pkg_desc": "compute the arccosine (in degrees) of a double-precision floating-point number", - "desc": "computes the arccosine (in degrees) of a double-precision floating-point number", - "short_desc": "arccosine", + "base_alias": "acovercos", + "alias": "acovercosf", + "pkg_desc": "compute the inverse coversed cosine of a single-precision floating-point number (in radians)", + "desc": "computes the inverse coversed cosine of a single-precision floating-point number (in radians)", + "short_desc": "inverse coversed cosine", "parameters": [ { "name": "x", @@ -768,75 +1739,87 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { - "min": -1, - "max": 1 + "min": 0, + "max": 2 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -1, - 1 + 0, + 2 ] }, "example_values": [ 0.84, - -0.37, + 1.37, 0.12, - -0.93, + 1.93, 0.65, - -0.18, + 1.18, 0.48, - -0.79, + 1.79, 0.05, - -0.66, + 1.66, 0.9, - -0.11, - -0.52, + 1.11, + 1.52, 0.27, 0.33, - -0.74, + 1.74, 0, 0.71, - -0.25, + 1.25, 0.58 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosine (in degrees)", + "desc": "inverse coversed cosine", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "acosd", - "arccosine", - "inverse", + "acovercos", + "acovercosin", + "acovercosine", + "arccovercos", + "arccovercosin", + "versed cosine", + "acovercosinus", + "acvc", + "arc", + "versed", + "coversed", + "cosine", + "cos", + "asin", "trig", "trigonometry", - "degrees" + "radians", + "angle" ], "extra_keywords": [ - "math.acos" + "math.asin" ] }, - "@stdlib/math/base/special/acosh": { + "@stdlib/math/base/special/acovercos": { "$schema": "math/base@v1.0", - "base_alias": "acosh", - "alias": "acosh", - "pkg_desc": "compute the hyperbolic arccosine of double-precision floating-point number", - "desc": "computes the hyperbolic arccosine of double-precision floating-point number", - "short_desc": "hyperbolic arccosine", + "base_alias": "acovercos", + "alias": "acovercos", + "pkg_desc": "compute the inverse coversed cosine", + "desc": "computes the inverse coversed cosine", + "short_desc": "inverse coversed cosine", "parameters": [ { "name": "x", @@ -849,44 +1832,44 @@ }, "domain": [ { - "min": 1, - "max": "infinity" + "min": 0, + "max": 2 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 1, - 10 + 0, + 2 ] }, "example_values": [ - 64, - 27, - 1.1, - 6.5, - 9, - 8, - 1, - 125, - 10.2, - 11.3, - 12.4, - 3.5, - 1.6, - 15.7, - 16, - 17.9, - 188, - 19.11, - 200, - 21.15 + 0.84, + 1.37, + 0.12, + 1.93, + 0.65, + 1.18, + 0.48, + 1.79, + 0.05, + 1.66, + 0.9, + 1.11, + 1.52, + 0.27, + 0.33, + 1.74, + 0, + 0.71, + 1.25, + 0.58 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic arccosine", + "desc": "inverse coversed cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -895,31 +1878,40 @@ } }, "keywords": [ - "acosh", - "hyperbolic", - "inverse", + "acovercos", + "acovercosin", + "acovercosine", + "arccovercos", + "arccovercosin", + "versed cosine", + "acovercosinus", + "acvc", + "arc", + "versed", + "coversed", "cosine", "cos", - "arc", - "arccosine", + "asin", "trig", - "trigonometry" + "trigonometry", + "radians", + "angle" ], "extra_keywords": [ - "math.acosh" + "math.asin" ] }, - "@stdlib/math/base/special/acotf": { + "@stdlib/math/base/special/acoversinf": { "$schema": "math/base@v1.0", - "base_alias": "acot", - "alias": "acotf", - "pkg_desc": "compute the inverse cotangent (in radians) of a single-precision floating-point number", - "desc": "computes the inverse cotangent (in radians) of a single-precision floating-point number", - "short_desc": "inverse cotangent", + "base_alias": "acoversin", + "alias": "acoversinf", + "pkg_desc": "compute the inverse coversed sine of a single-precision floating-point number (in radians)", + "desc": "computes the inverse coversed sine of a single-precision floating-point number (in radians)", + "short_desc": "inverse coversed sine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -928,44 +1920,44 @@ }, "domain": [ { - "min": "-infinity", - "max": "infinity" + "min": 0, + "max": 2 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + 0, + 2 ] }, "example_values": [ - 64, - 27, 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 0.05, + 0.12, + 0.27, + 0.33, + 0.48, + 0.58, + 0.65, + 0.71, + 0.84, + 0.9, + 1.11, + 1.18, + 1.25, + 1.37, + 1.52, + 1.66, + 1.74, + 1.79, + 1.93 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse cotangent (in radians)", + "desc": "inverse coversed sine", "type": { "javascript": "number", "jsdoc": "number", @@ -974,32 +1966,39 @@ } }, "keywords": [ - "inverse", - "cotangent", - "acot", - "cot", + "acoversin", + "acoversine", + "arccoversin", + "arccoversine", + "coversed sine", + "versed sine", + "acoversinus", + "arcvers", + "covers", + "cover", + "acvs", "arc", - "arccotangent", - "trig", - "trigonometry", - "radians", - "angle" + "versed", + "coversed", + "sine", + "sin", + "asin" ], "extra_keywords": [ - "math.acot" + "math.asin" ] }, - "@stdlib/math/base/special/acot": { + "@stdlib/math/base/special/acoversin": { "$schema": "math/base@v1.0", - "base_alias": "acot", - "alias": "acot", - "pkg_desc": "compute the inverse cotangent (in radians) of a double-precision floating-point number", - "desc": "computes the inverse cotangent (in radians) of a double-precision floating-point number", - "short_desc": "inverse cotangent", + "base_alias": "acoversin", + "alias": "acoversin", + "pkg_desc": "compute the inverse coversed sine of a double-precision floating-point number (in radians)", + "desc": "computes the inverse coversed sine of a double-precision floating-point number (in radians)", + "short_desc": "inverse coversed sine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -1008,74 +2007,81 @@ }, "domain": [ { - "min": "-infinity", - "max": "infinity" + "min": 0, + "max": 2 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + 0, + 2 ] }, "example_values": [ - 64, - 27, 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 0.05, + 0.12, + 0.27, + 0.33, + 0.48, + 0.58, + 0.65, + 0.71, + 0.84, + 0.9, + 1.11, + 1.18, + 1.25, + 1.37, + 1.52, + 1.66, + 1.74, + 1.79, + 1.93 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse cotangent (in radians)", + "desc": "inverse coversed sine", "type": { "javascript": "number", "jsdoc": "number", "c": "double", "dtype": "float64" - } - }, - "keywords": [ - "inverse", - "cotangent", - "acot", - "cot", + } + }, + "keywords": [ + "acoversin", + "acoversine", + "arccoversin", + "arccoversine", + "coversed sine", + "versed sine", + "acoversinus", + "arcvers", + "covers", + "cover", + "acvs", "arc", - "arccotangent", - "trig", - "trigonometry", - "radians", - "angle" + "versed", + "coversed", + "sine", + "sin", + "asin" ], "extra_keywords": [ - "math.acot" + "math.asin" ] }, - "@stdlib/math/base/special/acotdf": { + "@stdlib/math/base/special/acscf": { "$schema": "math/base@v1.0", - "base_alias": "acotd", - "alias": "acotdf", - "pkg_desc": "compute the inverse cotangent (in degrees) of a single-precision floating-point number", - "desc": "computes the inverse cotangent (in degrees) of a single-precision floating-point number", - "short_desc": "inverse cotangent", + "base_alias": "acsc", + "alias": "acscf", + "pkg_desc": "compute the arccosecant of a single-precision floating-point number", + "desc": "computes the arccosecant of a single-precision floating-point number", + "short_desc": "arccosecant", "parameters": [ { "name": "x", @@ -1089,43 +2095,47 @@ "domain": [ { "min": "-infinity", + "max": -1 + }, + { + "min": 1, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + 1.1, + 5.1 ] }, "example_values": [ - 64, - 27, - 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + -5, + -4.2, + -3.7, + -3.1, + -2.6, + -2.2, + -1.7, + -1.3, + -1.1, + -1.01, + 1.01, + 1.1, + 1.3, + 1.7, + 2.2, + 2.6, + 3.1, + 3.7, + 4.2, + 5 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse cotangent (in degrees)", + "desc": "arccosecant", "type": { "javascript": "number", "jsdoc": "number", @@ -1134,28 +2144,24 @@ } }, "keywords": [ + "acscf", + "acsc", + "arccosecant", + "cosecant", "inverse", - "cotangent", - "acot", - "cot", - "arc", - "arccotangent", - "trig", - "trigonometry", - "degrees", "angle" ], "extra_keywords": [ - "math.acot" + "math.asin" ] }, - "@stdlib/math/base/special/acotd": { + "@stdlib/math/base/special/acsc": { "$schema": "math/base@v1.0", - "base_alias": "acotd", - "alias": "acotd", - "pkg_desc": "compute the inverse cotangent (in degrees) of a double-precision floating-point number", - "desc": "computes the inverse cotangent (in degrees) of a double-precision floating-point number", - "short_desc": "inverse cotangent", + "base_alias": "acsc", + "alias": "acsc", + "pkg_desc": "compute the arccosecant", + "desc": "computes the arccosecant", + "short_desc": "arccosecant", "parameters": [ { "name": "x", @@ -1169,43 +2175,47 @@ "domain": [ { "min": "-infinity", + "max": -1 + }, + { + "min": 1, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -10, + 1.1, 10 ] }, "example_values": [ - 64, - 27, - 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 2, + -2, + 1.5, + -3.7, + 5, + -8.2, + 10, + -12.5, + 3.3, + -4.4, + 7.7, + -9.9, + 15, + -20, + 1.2, + -1.3, + 2.5, + -2.6, + 3.14, + -3.14 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse cotangent (in degrees)", + "desc": "arccosecant", "type": { "javascript": "number", "jsdoc": "number", @@ -1215,27 +2225,24 @@ }, "keywords": [ "inverse", - "cotangent", - "acot", - "cot", + "cosecant", + "acsc", "arc", - "arccotangent", - "trig", - "trigonometry", - "degrees", - "angle" + "arccosecant", + "angle", + "sin" ], "extra_keywords": [ - "math.acot" + "math.asin" ] }, - "@stdlib/math/base/special/acoth": { + "@stdlib/math/base/special/acscdf": { "$schema": "math/base@v1.0", - "base_alias": "acoth", - "alias": "acoth", - "pkg_desc": "compute the inverse hyperbolic cotangent of a number", - "desc": "computes the inverse hyperbolic cotangent of a number", - "short_desc": "inverse hyperbolic cotangent", + "base_alias": "acscd", + "alias": "acscdf", + "pkg_desc": "compute the arccosecant (in degrees) of a single-precision floating-point number", + "desc": "computes the arccosecant (in degrees) of a single-precision floating-point number", + "short_desc": "arccosecant (degrees)", "parameters": [ { "name": "x", @@ -1243,8 +2250,8 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { @@ -1260,67 +2267,61 @@ "prng": "random/base/uniform", "parameters": [ 1.1, - 10 + 5.1 ] }, "example_values": [ - 64, - 27, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15, - -1.2, - 1.7 + -20, + -12.5, + -9.9, + -8.2, + -4.4, + -3.7, + -2.6, + -2, + -1.3, + -1.1, + 1.1, + 1.5, + 2.5, + 3.3, + 5, + 7.7, + 10, + 12.5, + 15, + 20 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse hyperbolic cotangent", + "desc": "arccosecant (degrees)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "inverse", - "cotangent", - "acot", - "cot", - "coth", - "arc", - "arccotangent", - "trig", - "trigonometry", - "radians", - "angle" + "acsc", + "degree", + "arccosecant", + "cosecant", + "inverse" ], "extra_keywords": [ - "math.atanh" + "math.asin" ] }, - "@stdlib/math/base/special/acovercosf": { + "@stdlib/math/base/special/acscd": { "$schema": "math/base@v1.0", - "base_alias": "acovercos", - "alias": "acovercosf", - "pkg_desc": "compute the inverse coversed cosine of a single-precision floating-point number (in radians)", - "desc": "computes the inverse coversed cosine of a single-precision floating-point number (in radians)", - "short_desc": "inverse coversed cosine", + "base_alias": "acscd", + "alias": "acscd", + "pkg_desc": "compute the arccosecant (in degrees) of a double-precision floating-point number", + "desc": "computes the arccosecant (in degrees) of a double-precision floating-point number", + "short_desc": "arccosecant (degrees)", "parameters": [ { "name": "x", @@ -1328,87 +2329,78 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { - "min": 0, - "max": 2 + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, - 2 + 1.1, + 10 ] }, "example_values": [ - 0.84, - 1.37, - 0.12, - 1.93, - 0.65, - 1.18, - 0.48, - 1.79, - 0.05, - 1.66, - 0.9, - 1.11, - 1.52, - 0.27, - 0.33, - 1.74, - 0, - 0.71, - 1.25, - 0.58 + -20, + -12.5, + -9.9, + -8.2, + -4.4, + -3.7, + -2.6, + -2, + -1.3, + -1.1, + 1.1, + 1.5, + 2.5, + 3.3, + 5, + 7.7, + 10, + 12.5, + 15, + 20 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse coversed cosine", + "desc": "arccosecant (degrees)", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "acovercos", - "acovercosin", - "acovercosine", - "arccovercos", - "arccovercosin", - "versed cosine", - "acovercosinus", - "acvc", - "arc", - "versed", - "coversed", - "cosine", - "cos", "asin", - "trig", - "trigonometry", - "radians", - "angle" + "degree", + "arccosecant", + "sine", + "inverse" ], "extra_keywords": [ "math.asin" ] }, - "@stdlib/math/base/special/acovercos": { + "@stdlib/math/base/special/acsch": { "$schema": "math/base@v1.0", - "base_alias": "acovercos", - "alias": "acovercos", - "pkg_desc": "compute the inverse coversed cosine", - "desc": "computes the inverse coversed cosine", - "short_desc": "inverse coversed cosine", + "base_alias": "acsch", + "alias": "acsch", + "pkg_desc": "compute the hyperbolic arccosecant of a double-precision floating-point number", + "desc": "computes the hyperbolic arccosecant of a double-precision floating-point number", + "short_desc": "hyperbolic arccosecant", "parameters": [ { "name": "x", @@ -1420,45 +2412,49 @@ "dtype": "float64" }, "domain": [ + { + "min": "-infinity", + "max": 0 + }, { "min": 0, - "max": 2 + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, - 2 + 0.5, + 5 ] }, "example_values": [ - 0.84, - 1.37, - 0.12, - 1.93, - 0.65, - 1.18, - 0.48, - 1.79, - 0.05, - 1.66, - 0.9, - 1.11, - 1.52, - 0.27, - 0.33, - 1.74, - 0, - 0.71, - 1.25, - 0.58 + -5, + -3.7, + -2.9, + -2.1, + -1.7, + -1.3, + -1.1, + -0.7, + -0.51, + -0.25, + 0.25, + 0.51, + 0.7, + 1.1, + 1.3, + 1.7, + 2.1, + 2.9, + 3.7, + 5 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse coversed cosine", + "desc": "hyperbolic arccosecant", "type": { "javascript": "number", "jsdoc": "number", @@ -1467,36 +2463,27 @@ } }, "keywords": [ - "acovercos", - "acovercosin", - "acovercosine", - "arccovercos", - "arccovercosin", - "versed cosine", - "acovercosinus", - "acvc", + "acsch", + "hyperbolic", + "inverse", + "cosecant", + "csc", "arc", - "versed", - "coversed", - "cosine", - "cos", - "asin", - "trig", - "trigonometry", - "radians", - "angle" + "arccosecant", + "angle", + "asinh" ], "extra_keywords": [ - "math.asin" + "math.asinh" ] }, - "@stdlib/math/base/special/acoversinf": { + "@stdlib/math/base/special/ahavercosf": { "$schema": "math/base@v1.0", - "base_alias": "acoversin", - "alias": "acoversinf", - "pkg_desc": "compute the inverse coversed sine of a single-precision floating-point number (in radians)", - "desc": "computes the inverse coversed sine of a single-precision floating-point number (in radians)", - "short_desc": "inverse coversed sine", + "base_alias": "ahavercos", + "alias": "ahavercosf", + "pkg_desc": "compute the inverse half-value versed cosine of a single-precision floating-point number (in radians)", + "desc": "computes the inverse half-value versed cosine of a single-precision floating-point number (in radians)", + "short_desc": "inverse half-value versed cosine", "parameters": [ { "name": "x", @@ -1510,80 +2497,78 @@ "domain": [ { "min": 0, - "max": 2 + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ 0, - 2 + 1 ] }, "example_values": [ 0, 0.05, - 0.12, - 0.27, - 0.33, - 0.48, - 0.58, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, 0.65, - 0.71, - 0.84, + 0.7, + 0.75, + 0.8, + 0.85, 0.9, - 1.11, - 1.18, - 1.25, - 1.37, - 1.52, - 1.66, - 1.74, - 1.79, - 1.93 + 0.95 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse coversed sine", + "desc": "inverse half-value versed cosine", "type": { "javascript": "number", - "jsdoc": "number", - "c": "float", - "dtype": "float32" - } - }, - "keywords": [ - "acoversin", - "acoversine", - "arccoversin", - "arccoversine", - "coversed sine", - "versed sine", - "acoversinus", - "arcvers", - "covers", - "cover", - "acvs", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "ahavercos", + "ahavercosin", + "ahavercosine", + "arcvercos", + "arcvercosin", + "arcvercosine", + "versed cosine", + "ahavercosinus", + "ahvc", "arc", "versed", - "coversed", - "sine", - "sin", - "asin" + "half-value", + "cosine", + "cos", + "acos" ], "extra_keywords": [ - "math.asin" + "math.acos" ] }, - "@stdlib/math/base/special/acoversin": { + "@stdlib/math/base/special/ahavercos": { "$schema": "math/base@v1.0", - "base_alias": "acoversin", - "alias": "acoversin", - "pkg_desc": "compute the inverse coversed sine of a double-precision floating-point number (in radians)", - "desc": "computes the inverse coversed sine of a double-precision floating-point number (in radians)", - "short_desc": "inverse coversed sine", + "base_alias": "ahavercos", + "alias": "ahavercos", + "pkg_desc": "compute the inverse half-value versed cosine of a double-precision floating-point number (in radians)", + "desc": "computes the inverse half-value versed cosine of a double-precision floating-point number (in radians)", + "short_desc": "inverse half-value versed cosine", "parameters": [ { "name": "x", @@ -1597,43 +2582,43 @@ "domain": [ { "min": 0, - "max": 2 + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ 0, - 2 + 1 ] }, "example_values": [ 0, 0.05, - 0.12, - 0.27, - 0.33, - 0.48, - 0.58, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, 0.65, - 0.71, - 0.84, + 0.7, + 0.75, + 0.8, + 0.85, 0.9, - 1.11, - 1.18, - 1.25, - 1.37, - 1.52, - 1.66, - 1.74, - 1.79, - 1.93 + 0.95 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse coversed sine", + "desc": "inverse half-value versed cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -1642,39 +2627,37 @@ } }, "keywords": [ - "acoversin", - "acoversine", - "arccoversin", - "arccoversine", - "coversed sine", - "versed sine", - "acoversinus", - "arcvers", - "covers", - "cover", - "acvs", + "ahavercos", + "ahavercosin", + "ahavercosine", + "arcvercos", + "arcvercosin", + "arcvercosine", + "versed cosine", + "ahavercosinus", + "ahvc", "arc", "versed", - "coversed", - "sine", - "sin", - "asin" + "half-value", + "cosine", + "cos", + "acos" ], "extra_keywords": [ - "math.asin" + "math.acos" ] }, - "@stdlib/math/base/special/acscf": { + "@stdlib/math/base/special/ahaversinf": { "$schema": "math/base@v1.0", - "base_alias": "acsc", - "alias": "acscf", - "pkg_desc": "compute the arccosecant of a single-precision floating-point number", - "desc": "computes the arccosecant of a single-precision floating-point number", - "short_desc": "arccosecant", + "base_alias": "ahaversin", + "alias": "ahaversinf", + "pkg_desc": "compute the inverse half-value versed sine of a single-precision floating-point number (in radians)", + "desc": "computes the inverse half-value versed sine of a single-precision floating-point number (in radians)", + "short_desc": "inverse half-value versed sine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -1683,48 +2666,44 @@ }, "domain": [ { - "min": "-infinity", - "max": -1 - }, - { - "min": 1, - "max": "infinity" + "min": 0, + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 1.1, - 5.1 + 0, + 1 ] }, "example_values": [ - -5, - -4.2, - -3.7, - -3.1, - -2.6, - -2.2, - -1.7, - -1.3, - -1.1, - -1.01, - 1.01, - 1.1, - 1.3, - 1.7, - 2.2, - 2.6, - 3.1, - 3.7, - 4.2, - 5 + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0.95 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosecant", + "desc": "inverse half-value versed sine", "type": { "javascript": "number", "jsdoc": "number", @@ -1733,28 +2712,42 @@ } }, "keywords": [ - "acscf", - "acsc", - "arccosecant", - "cosecant", - "inverse", - "angle" + "ahaversin", + "ahaversine", + "arcversin", + "arcversine", + "versed sine", + "ahaversinus", + "haversine", + "haversin", + "archav", + "invhav", + "ahav", + "ahvs", + "ahv", + "hav", + "arc", + "versed", + "half-value", + "sine", + "sin", + "asin" ], "extra_keywords": [ "math.asin" ] }, - "@stdlib/math/base/special/acsc": { + "@stdlib/math/base/special/ahaversin": { "$schema": "math/base@v1.0", - "base_alias": "acsc", - "alias": "acsc", - "pkg_desc": "compute the arccosecant", - "desc": "computes the arccosecant", - "short_desc": "arccosecant", + "base_alias": "ahaversin", + "alias": "ahaversin", + "pkg_desc": "compute the inverse half-value versed sine of a double-precision floating-point number (in radians)", + "desc": "computes the inverse half-value versed sine of a double-precision floating-point number (in radians)", + "short_desc": "inverse half-value versed sine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -1763,48 +2756,44 @@ }, "domain": [ { - "min": "-infinity", - "max": -1 - }, - { - "min": 1, - "max": "infinity" + "min": 0, + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 1.1, - 10 + 0, + 1 ] }, "example_values": [ - 2, - -2, - 1.5, - -3.7, - 5, - -8.2, - 10, - -12.5, - 3.3, - -4.4, - 7.7, - -9.9, - 15, - -20, - 1.2, - -1.3, - 2.5, - -2.6, - 3.14, - -3.14 + 0, + 0.05, + 0.1, + 0.15, + 0.2, + 0.25, + 0.3, + 0.35, + 0.4, + 0.45, + 0.5, + 0.55, + 0.6, + 0.65, + 0.7, + 0.75, + 0.8, + 0.85, + 0.9, + 0.95 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosecant", + "desc": "inverse half-value versed sine", "type": { "javascript": "number", "jsdoc": "number", @@ -1813,25 +2802,38 @@ } }, "keywords": [ - "inverse", - "cosecant", - "acsc", + "ahaversin", + "ahaversine", + "arcversin", + "arcversine", + "versed sine", + "ahaversinus", + "haversine", + "haversin", + "archav", + "invhav", + "ahav", + "ahvs", + "ahv", + "hav", "arc", - "arccosecant", - "angle", - "sin" + "versed", + "half-value", + "sine", + "sin", + "asin" ], "extra_keywords": [ "math.asin" ] }, - "@stdlib/math/base/special/acscdf": { + "@stdlib/math/base/special/asecf": { "$schema": "math/base@v1.0", - "base_alias": "acscd", - "alias": "acscdf", - "pkg_desc": "compute the arccosecant (in degrees) of a single-precision floating-point number", - "desc": "computes the arccosecant (in degrees) of a single-precision floating-point number", - "short_desc": "arccosecant (degrees)", + "base_alias": "asec", + "alias": "asecf", + "pkg_desc": "compute the inverse (arc) secant of a single-precision floating-point number", + "desc": "computes the inverse (arc) secant of a single-precision floating-point number", + "short_desc": "inverse (arc) secant", "parameters": [ { "name": "x", @@ -1860,32 +2862,32 @@ ] }, "example_values": [ - -20, - -12.5, - -9.9, - -8.2, - -4.4, - -3.7, - -2.6, - -2, - -1.3, - -1.1, - 1.1, - 1.5, - 2.5, - 3.3, - 5, - 7.7, - 10, - 12.5, - 15, - 20 + 905.5, + -123.75, + 1.001, + -1.08, + 66.2, + -201.9, + 13.7, + -3.81, + 4.43, + -19.6, + 2.28, + -7.33, + 150.25, + -11.2, + 5.04, + -1.36, + 1.21, + -88.65, + 37.9, + -402.3 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosecant (degrees)", + "desc": "arcsecant", "type": { "javascript": "number", "jsdoc": "number", @@ -1894,23 +2896,26 @@ } }, "keywords": [ - "acsc", - "degree", - "arccosecant", - "cosecant", - "inverse" + "asecf", + "inverse", + "cosine", + "cos", + "arc", + "arccosine", + "secant", + "arcsecant" ], "extra_keywords": [ - "math.asin" + "math.acos" ] }, - "@stdlib/math/base/special/acscd": { + "@stdlib/math/base/special/asec": { "$schema": "math/base@v1.0", - "base_alias": "acscd", - "alias": "acscd", - "pkg_desc": "compute the arccosecant (in degrees) of a double-precision floating-point number", - "desc": "computes the arccosecant (in degrees) of a double-precision floating-point number", - "short_desc": "arccosecant (degrees)", + "base_alias": "asec", + "alias": "asec", + "pkg_desc": "compute the inverse (arc) secant of a double-precision floating-point number", + "desc": "computes the inverse (arc) secant of a double-precision floating-point number", + "short_desc": "inverse (arc) secant", "parameters": [ { "name": "x", @@ -1939,32 +2944,32 @@ ] }, "example_values": [ - -20, - -12.5, - -9.9, - -8.2, - -4.4, - -3.7, - -2.6, - -2, - -1.3, - -1.1, - 1.1, - 1.5, - 2.5, - 3.3, - 5, - 7.7, - 10, - 12.5, - 15, - 20 + 1506.98, + -237.4, + 1.0002, + -1.0005, + 42.01, + -77.3, + 9.31, + -3.47, + 100, + -12.61, + 5.73, + -999.9, + 2.19, + -7.42, + 1.67, + -2.88, + 321.5, + -1.23, + 19.3, + -15.8 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arccosecant (degrees)", + "desc": "inverse (arc) secant", "type": { "javascript": "number", "jsdoc": "number", @@ -1973,23 +2978,26 @@ } }, "keywords": [ - "asin", - "degree", - "arccosecant", - "sine", - "inverse" + "asec", + "inverse", + "cosine", + "cos", + "arc", + "arccosine", + "secant", + "arcsecant" ], "extra_keywords": [ - "math.asin" + "math.acos" ] }, - "@stdlib/math/base/special/acsch": { + "@stdlib/math/base/special/asecdf": { "$schema": "math/base@v1.0", - "base_alias": "acsch", - "alias": "acsch", - "pkg_desc": "compute the hyperbolic arccosecant of a double-precision floating-point number", - "desc": "computes the hyperbolic arccosecant of a double-precision floating-point number", - "short_desc": "hyperbolic arccosecant", + "base_alias": "asecd", + "alias": "asecdf", + "pkg_desc": "compute the arcsecant (in degrees) of a single-precision floating-point number", + "desc": "computes the arcsecant (in degrees) of a single-precision floating-point number", + "short_desc": "arcsecant", "parameters": [ { "name": "x", @@ -1997,171 +3005,161 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { "min": "-infinity", - "max": 0 + "max": -1 }, { - "min": 0, + "min": 1, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.5, - 5 + 1.1, + 5.1 ] }, "example_values": [ - -5, - -3.7, - -2.9, - -2.1, - -1.7, - -1.3, - -1.1, - -0.7, - -0.51, - -0.25, - 0.25, - 0.51, - 0.7, - 1.1, - 1.3, - 1.7, - 2.1, - 2.9, - 3.7, - 5 + 150.4, + -1.12, + 2.63, + -4.05, + 33.7, + -487.2, + 8.91, + -13.45, + 1.07, + -1.37, + 95.2, + -2.18, + 5.42, + -6.71, + 1200.5, + -10.9, + 17.6, + -72.3, + 241.9, + -3.01 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic arccosecant", + "desc": "arcsecant (in degrees)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" - } - }, - "keywords": [ - "acsch", - "hyperbolic", - "inverse", - "cosecant", - "csc", - "arc", - "arccosecant", - "angle", - "asinh" + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "asec", + "degree", + "arcsecant", + "secant", + "inverse" ], "extra_keywords": [ - "math.asinh" + "math.acos" ] }, - "@stdlib/math/base/special/ahavercosf": { + "@stdlib/math/base/special/asecd": { "$schema": "math/base@v1.0", - "base_alias": "ahavercos", - "alias": "ahavercosf", - "pkg_desc": "compute the inverse half-value versed cosine of a single-precision floating-point number (in radians)", - "desc": "computes the inverse half-value versed cosine of a single-precision floating-point number (in radians)", - "short_desc": "inverse half-value versed cosine", + "base_alias": "asecd", + "alias": "asecd", + "pkg_desc": "compute the arcsecant (in degrees) of a double-precision floating-point number", + "desc": "computes the arcsecant (in degrees) of a double-precision floating-point number", + "short_desc": "arcsecant", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { - "min": 0, - "max": 1 + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, - 1 + 1.1, + 10 ] }, "example_values": [ - 0, - 0.05, - 0.1, - 0.15, - 0.2, - 0.25, - 0.3, - 0.35, - 0.4, - 0.45, - 0.5, - 0.55, - 0.6, - 0.65, - 0.7, - 0.75, - 0.8, - 0.85, - 0.9, - 0.95 + 100, + -1.07, + 2.51, + -4.73, + 19.5, + -212.3, + 7.66, + -9.38, + 3.41, + -5.28, + 12.3, + -20, + 1.96, + -1.21, + 9.91, + -6.7, + 15.4, + -3.36, + 1506.98, + -1000 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse half-value versed cosine", + "desc": "arcsecant (in degrees)", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "ahavercos", - "ahavercosin", - "ahavercosine", - "arcvercos", - "arcvercosin", - "arcvercosine", - "versed cosine", - "ahavercosinus", - "ahvc", - "arc", - "versed", - "half-value", + "acos", + "degree", + "arcsecant", "cosine", - "cos", - "acos" + "inverse" ], "extra_keywords": [ "math.acos" ] }, - "@stdlib/math/base/special/ahavercos": { + "@stdlib/math/base/special/asech": { "$schema": "math/base@v1.0", - "base_alias": "ahavercos", - "alias": "ahavercos", - "pkg_desc": "compute the inverse half-value versed cosine of a double-precision floating-point number (in radians)", - "desc": "computes the inverse half-value versed cosine of a double-precision floating-point number (in radians)", - "short_desc": "inverse half-value versed cosine", + "base_alias": "asech", + "alias": "asech", + "pkg_desc": "compute the hyperbolic arcsecant of a double-precision floating-point number", + "desc": "computes the hyperbolic arcsecant of a double-precision floating-point number", + "short_desc": "hyperbolic arcsecant", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -2177,37 +3175,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - 0, + 0.05, 1 ] }, "example_values": [ - 0, - 0.05, - 0.1, - 0.15, - 0.2, - 0.25, - 0.3, + 0.92, + 0.31, + 0.57, + 0.11, + 0.79, + 0.23, + 0.44, + 0.68, + 0.16, 0.35, - 0.4, - 0.45, - 0.5, - 0.55, - 0.6, - 0.65, - 0.7, - 0.75, - 0.8, - 0.85, - 0.9, - 0.95 + 0.97, + 0.04, + 0.83, + 0.26, + 0.52, + 0.07, + 0.63, + 0.2, + 0.48, + 0.89 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse half-value versed cosine", + "desc": "hyperbolic arcsecant", "type": { "javascript": "number", "jsdoc": "number", @@ -2216,33 +3214,27 @@ } }, "keywords": [ - "ahavercos", - "ahavercosin", - "ahavercosine", - "arcvercos", - "arcvercosin", - "arcvercosine", - "versed cosine", - "ahavercosinus", - "ahvc", - "arc", - "versed", - "half-value", + "asech", + "hyperbolic", + "inverse", "cosine", "cos", - "acos" + "arc", + "arccosine", + "secant", + "arcsecant" ], "extra_keywords": [ - "math.acos" + "math.acosh" ] }, - "@stdlib/math/base/special/ahaversinf": { + "@stdlib/math/base/special/asinf": { "$schema": "math/base@v1.0", - "base_alias": "ahaversin", - "alias": "ahaversinf", - "pkg_desc": "compute the inverse half-value versed sine of a single-precision floating-point number (in radians)", - "desc": "computes the inverse half-value versed sine of a single-precision floating-point number (in radians)", - "short_desc": "inverse half-value versed sine", + "base_alias": "asin", + "alias": "asinf", + "pkg_desc": "compute the arcsine of a single-precision floating-point number", + "desc": "computes the arcsine of a single-precision floating-point number", + "short_desc": "arcsine", "parameters": [ { "name": "x", @@ -2255,84 +3247,71 @@ }, "domain": [ { - "min": 0, + "min": -1, "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, + -1, 1 ] }, "example_values": [ + -1, + -0.95, + -0.9, + -0.85, + -0.75, + -0.66, + -0.5, + -0.33, + -0.25, + -0.11, 0, - 0.05, - 0.1, - 0.15, - 0.2, + 0.11, 0.25, - 0.3, - 0.35, - 0.4, - 0.45, + 0.33, 0.5, - 0.55, - 0.6, - 0.65, - 0.7, + 0.66, 0.75, - 0.8, 0.85, 0.9, - 0.95 - ] - } - ], - "output_policy": "real_floating_point_and_generic", - "returns": { - "desc": "inverse half-value versed sine", - "type": { - "javascript": "number", - "jsdoc": "number", - "c": "float", - "dtype": "float32" - } - }, - "keywords": [ - "ahaversin", - "ahaversine", - "arcversin", - "arcversine", - "versed sine", - "ahaversinus", - "haversine", - "haversin", - "archav", - "invhav", - "ahav", - "ahvs", - "ahv", - "hav", - "arc", - "versed", - "half-value", + 0.95, + 1 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arcsine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "asinf", + "asin", + "arcsine", "sine", - "sin", - "asin" + "inverse", + "angle" ], "extra_keywords": [ "math.asin" ] }, - "@stdlib/math/base/special/ahaversin": { + "@stdlib/math/base/special/asin": { "$schema": "math/base@v1.0", - "base_alias": "ahaversin", - "alias": "ahaversin", - "pkg_desc": "compute the inverse half-value versed sine of a double-precision floating-point number (in radians)", - "desc": "computes the inverse half-value versed sine of a double-precision floating-point number (in radians)", - "short_desc": "inverse half-value versed sine", + "base_alias": "asin", + "alias": "asin", + "pkg_desc": "compute the arcsine of a double-precision floating-point number", + "desc": "computes the arcsine of a double-precision floating-point number", + "short_desc": "arcsine", "parameters": [ { "name": "x", @@ -2345,44 +3324,45 @@ }, "domain": [ { - "min": 0, + "min": -1, "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, + -1, 1 ] }, "example_values": [ + -1, + -0.95, + -0.9, + -0.85, + -0.75, + -0.66, + -0.5, + -0.33, + -0.25, + -0.11, 0, - 0.05, - 0.1, - 0.15, - 0.2, + 0.11, 0.25, - 0.3, - 0.35, - 0.4, - 0.45, + 0.33, 0.5, - 0.55, - 0.6, - 0.65, - 0.7, + 0.66, 0.75, - 0.8, 0.85, 0.9, - 0.95 + 0.95, + 1 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse half-value versed sine", + "desc": "arcsine", "type": { "javascript": "number", "jsdoc": "number", @@ -2391,38 +3371,25 @@ } }, "keywords": [ - "ahaversin", - "ahaversine", - "arcversin", - "arcversine", - "versed sine", - "ahaversinus", - "haversine", - "haversin", - "archav", - "invhav", - "ahav", - "ahvs", - "ahv", - "hav", - "arc", - "versed", - "half-value", + "asin", + "arcsine", "sine", - "sin", - "asin" + "inverse", + "angle", + "polyfill", + "ponyfill" ], "extra_keywords": [ "math.asin" ] }, - "@stdlib/math/base/special/asecf": { + "@stdlib/math/base/special/asindf": { "$schema": "math/base@v1.0", - "base_alias": "asec", - "alias": "asecf", - "pkg_desc": "compute the inverse (arc) secant of a single-precision floating-point number", - "desc": "computes the inverse (arc) secant of a single-precision floating-point number", - "short_desc": "inverse (arc) secant", + "base_alias": "asind", + "alias": "asindf", + "pkg_desc": "compute the arcsine (in degrees) of a single-precision floating-point number", + "desc": "computes the arcsine (in degrees) of a single-precision floating-point number", + "short_desc": "arcsine", "parameters": [ { "name": "x", @@ -2435,48 +3402,44 @@ }, "domain": [ { - "min": "-infinity", - "max": -1 - }, - { - "min": 1, - "max": "infinity" + "min": -1, + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 1.1, - 5.1 + -1, + 1 ] }, "example_values": [ - 905.5, - -123.75, - 1.001, - -1.08, - 66.2, - -201.9, - 13.7, - -3.81, - 4.43, - -19.6, - 2.28, - -7.33, - 150.25, - -11.2, - 5.04, - -1.36, - 1.21, - -88.65, - 37.9, - -402.3 + -0.88, + 0.95, + -0.03, + 0.62, + -0.47, + 0.14, + -0.7, + 0.29, + -0.22, + 0.51, + -0.97, + 0.74, + -0.39, + 0.83, + -0.11, + 0.06, + -0.55, + 0.2, + -0.64, + 1 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arcsecant", + "desc": "arcsine (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -2485,26 +3448,23 @@ } }, "keywords": [ - "asecf", - "inverse", - "cosine", - "cos", - "arc", - "arccosine", - "secant", - "arcsecant" + "asin", + "degree", + "arcsine", + "sine", + "inverse" ], "extra_keywords": [ - "math.acos" + "math.asin" ] }, - "@stdlib/math/base/special/asec": { + "@stdlib/math/base/special/asind": { "$schema": "math/base@v1.0", - "base_alias": "asec", - "alias": "asec", - "pkg_desc": "compute the inverse (arc) secant of a double-precision floating-point number", - "desc": "computes the inverse (arc) secant of a double-precision floating-point number", - "short_desc": "inverse (arc) secant", + "base_alias": "asind", + "alias": "asind", + "pkg_desc": "compute the arcsine (in degrees) of a double-precision floating-point number", + "desc": "computes the arcsine (in degrees) of a double-precision floating-point number", + "short_desc": "arcsine", "parameters": [ { "name": "x", @@ -2517,48 +3477,44 @@ }, "domain": [ { - "min": "-infinity", - "max": -1 - }, - { - "min": 1, - "max": "infinity" + "min": -1, + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 1.1, - 10 + -1, + 1 ] }, "example_values": [ - 1506.98, - -237.4, - 1.0002, - -1.0005, - 42.01, - -77.3, - 9.31, - -3.47, - 100, - -12.61, - 5.73, - -999.9, - 2.19, - -7.42, - 1.67, - -2.88, - 321.5, - -1.23, - 19.3, - -15.8 + 0.58, + -0.73, + 0.11, + -0.94, + 0.37, + -0.06, + 0.98, + -0.21, + 0.44, + -0.77, + 0.59, + -0.14, + 0.27, + -0.35, + 0.86, + -0.01, + -0.41, + 0.18, + -0.66, + 1 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse (arc) secant", + "desc": "arcsine (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -2567,26 +3523,23 @@ } }, "keywords": [ - "asec", - "inverse", - "cosine", - "cos", - "arc", - "arccosine", - "secant", - "arcsecant" + "asin", + "degree", + "arcsine", + "sine", + "inverse" ], "extra_keywords": [ - "math.acos" + "math.asin" ] }, - "@stdlib/math/base/special/asecdf": { + "@stdlib/math/base/special/asinh": { "$schema": "math/base@v1.0", - "base_alias": "asecd", - "alias": "asecdf", - "pkg_desc": "compute the arcsecant (in degrees) of a single-precision floating-point number", - "desc": "computes the arcsecant (in degrees) of a single-precision floating-point number", - "short_desc": "arcsecant", + "base_alias": "asinh", + "alias": "asinh", + "pkg_desc": "compute the hyperbolic arcsine of a double-precision floating-point number", + "desc": "computes the hyperbolic arcsine of a double-precision floating-point number", + "short_desc": "hyperbolic arcsine", "parameters": [ { "name": "x", @@ -2594,78 +3547,74 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { "min": "-infinity", - "max": -1 - }, - { - "min": 1, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 1.1, - 5.1 + -5, + 5 ] }, "example_values": [ - 150.4, - -1.12, - 2.63, - -4.05, - 33.7, - -487.2, - 8.91, - -13.45, - 1.07, - -1.37, - 95.2, - -2.18, - 5.42, - -6.71, - 1200.5, - -10.9, - 17.6, - -72.3, - 241.9, - -3.01 + 100, + -37.5, + 0.42, + -250.8, + 3.78, + -0.42, + 1.97, + -4.63, + 0.12, + -1.55, + 4.41, + -0.93, + 2.88, + -3.37, + 0.68, + -2.46, + 5, + -0.17, + -100, + 250.3 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arcsecant (in degrees)", + "desc": "hyperbolic arcsine", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "asec", - "degree", - "arcsecant", - "secant", - "inverse" + "asinh", + "hyperbolic", + "inverse", + "arcsine", + "sine" ], "extra_keywords": [ - "math.acos" + "math.asinh" ] }, - "@stdlib/math/base/special/asecd": { + "@stdlib/math/base/special/atanf": { "$schema": "math/base@v1.0", - "base_alias": "asecd", - "alias": "asecd", - "pkg_desc": "compute the arcsecant (in degrees) of a double-precision floating-point number", - "desc": "computes the arcsecant (in degrees) of a double-precision floating-point number", - "short_desc": "arcsecant", + "base_alias": "atan", + "alias": "atanf", + "pkg_desc": "compute the arctangent (in radians) of a single-precision floating-point number", + "desc": "computes the arctangent (in radians) of a single-precision floating-point number", + "short_desc": "arctangent", "parameters": [ { "name": "x", @@ -2673,78 +3622,73 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { "min": "-infinity", - "max": -1 - }, - { - "min": 1, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 1.1, - 10 + -50, + 50 ] }, "example_values": [ - 100, - -1.07, - 2.51, - -4.73, - 19.5, - -212.3, - 7.66, - -9.38, - 3.41, - -5.28, - 12.3, - -20, - 1.96, - -1.21, - 9.91, - -6.7, - 15.4, - -3.36, - 1506.98, - -1000 + -0.91, + 23.4, + -11.7, + 0.03, + 77.8, + -2.2, + 5.6, + -39.1, + 1.01, + -0.47, + 14.9, + -8.3, + 0, + 3.33, + -25.6, + 6.7, + -4.2, + 41.5, + -19.9, + 95.2 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arcsecant (in degrees)", + "desc": "arctangent (in radians)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "acos", - "degree", - "arcsecant", - "cosine", + "atanf", + "arctangent", + "tangent", "inverse" ], "extra_keywords": [ - "math.acos" + "math.atan" ] }, - "@stdlib/math/base/special/asech": { + "@stdlib/math/base/special/atan": { "$schema": "math/base@v1.0", - "base_alias": "asech", - "alias": "asech", - "pkg_desc": "compute the hyperbolic arcsecant of a double-precision floating-point number", - "desc": "computes the hyperbolic arcsecant of a double-precision floating-point number", - "short_desc": "hyperbolic arcsecant", + "base_alias": "atan", + "alias": "atan", + "pkg_desc": "compute the arctangent (in radians) of a double-precision floating-point number", + "desc": "computes the arctangent (in radians) of a double-precision floating-point number", + "short_desc": "arctangent", "parameters": [ { "name": "x", @@ -2757,44 +3701,44 @@ }, "domain": [ { - "min": 0, - "max": 1 + "min": "-infinity", + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.05, - 1 + -100, + 100 ] }, "example_values": [ - 0.92, - 0.31, - 0.57, - 0.11, - 0.79, - 0.23, - 0.44, - 0.68, - 0.16, - 0.35, - 0.97, - 0.04, - 0.83, - 0.26, - 0.52, - 0.07, - 0.63, - 0.2, - 0.48, - 0.89 + 0.33, + -57.2, + 1.2, + -0.77, + 1000, + -3.41, + 8.9, + -250.5, + 0.01, + 42, + -19.7, + 73.6, + -0.58, + 5.5, + -99.9, + 7.25, + -12.3, + 0, + 315.8, + -1.1 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic arcsecant", + "desc": "arctangent (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -2803,31 +3747,28 @@ } }, "keywords": [ - "asech", - "hyperbolic", - "inverse", - "cosine", - "cos", + "atan", + "arctangent", + "tangent", + "tan", "arc", - "arccosine", - "secant", - "arcsecant" + "inverse" ], "extra_keywords": [ - "math.acosh" + "math.atan" ] }, - "@stdlib/math/base/special/asinf": { + "@stdlib/math/base/special/atandf": { "$schema": "math/base@v1.0", - "base_alias": "asin", - "alias": "asinf", - "pkg_desc": "compute the arcsine of a single-precision floating-point number", - "desc": "computes the arcsine of a single-precision floating-point number", - "short_desc": "arcsine", + "base_alias": "atand", + "alias": "atandf", + "pkg_desc": "compute the arctangent (in degrees) of a single-precision floating-point number", + "desc": "computes the arctangent (in degrees) of a single-precision floating-point number", + "short_desc": "arctangent", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -2835,46 +3776,45 @@ "dtype": "float32" }, "domain": [ - { - "min": -1, - "max": 1 + { + "min": "-infinity", + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -1, - 1 + -50, + 50 ] }, "example_values": [ - -1, - -0.95, - -0.9, - -0.85, - -0.75, - -0.66, - -0.5, - -0.33, - -0.25, - -0.11, + 0.21, + -77.3, + 6.4, + -0.18, + 19.7, + -41.2, + 2.05, + -9.9, + 73.3, + -25.6, 0, - 0.11, - 0.25, - 0.33, - 0.5, - 0.66, - 0.75, - 0.85, - 0.9, - 0.95, - 1 + 38.9, + -4.7, + 101.5, + -12.1, + 5.8, + -33.4, + 1.03, + 250.2, + -150.7 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arcsine", + "desc": "arctangent (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -2883,28 +3823,26 @@ } }, "keywords": [ - "asinf", - "asin", - "arcsine", - "sine", - "inverse", - "angle" + "degree", + "arctangent", + "tangent", + "inverse" ], "extra_keywords": [ - "math.asin" + "math.atan" ] }, - "@stdlib/math/base/special/asin": { + "@stdlib/math/base/special/atand": { "$schema": "math/base@v1.0", - "base_alias": "asin", - "alias": "asin", - "pkg_desc": "compute the arcsine of a double-precision floating-point number", - "desc": "computes the arcsine of a double-precision floating-point number", - "short_desc": "arcsine", + "base_alias": "atand", + "alias": "atand", + "pkg_desc": "compute the arctangent (in degrees) of a double-precision floating-point number", + "desc": "computes the arctangent (in degrees) of a double-precision floating-point number", + "short_desc": "arctangent", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -2913,45 +3851,44 @@ }, "domain": [ { - "min": -1, - "max": 1 + "min": "-infinity", + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -1, - 1 + -100, + 100 ] }, "example_values": [ - -1, - -0.95, - -0.9, - -0.85, - -0.75, - -0.66, - -0.5, - -0.33, - -0.25, - -0.11, + 180.2, + -3.7, + 0.42, + -98.5, + 5.4, + -0.06, + 73.1, + -41.3, + 9.9, + -12.2, 0, - 0.11, - 0.25, - 0.33, - 0.5, - 0.66, - 0.75, - 0.85, - 0.9, - 0.95, - 1 + 31.8, + -7.5, + 250.7, + -0.9, + 14.2, + -66.4, + 1.01, + 1000, + -325.6 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arcsine", + "desc": "arctangent (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -2960,25 +3897,22 @@ } }, "keywords": [ - "asin", - "arcsine", - "sine", - "inverse", - "angle", - "polyfill", - "ponyfill" + "degree", + "arctangent", + "tangent", + "inverse" ], "extra_keywords": [ - "math.asin" + "math.atan" ] }, - "@stdlib/math/base/special/asindf": { + "@stdlib/math/base/special/atanh": { "$schema": "math/base@v1.0", - "base_alias": "asind", - "alias": "asindf", - "pkg_desc": "compute the arcsine (in degrees) of a single-precision floating-point number", - "desc": "computes the arcsine (in degrees) of a single-precision floating-point number", - "short_desc": "arcsine", + "base_alias": "atanh", + "alias": "atanh", + "pkg_desc": "compute the hyperbolic arctangent of a double-precision floating-point number", + "desc": "computes the hyperbolic arctangent of a double-precision floating-point number", + "short_desc": "hyperbolic arctangent", "parameters": [ { "name": "x", @@ -2986,8 +3920,8 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { @@ -2998,62 +3932,62 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -1, - 1 + -0.95, + 0.95 ] }, "example_values": [ - -0.88, - 0.95, - -0.03, - 0.62, + -0.99, + 0.72, + -0.15, + 0.93, + -0.61, + 0.05, + -0.84, + 0.31, -0.47, - 0.14, - -0.7, - 0.29, - -0.22, - 0.51, - -0.97, - 0.74, - -0.39, - 0.83, - -0.11, - 0.06, - -0.55, - 0.2, - -0.64, - 1 + 0.12, + -0.72, + 0.6, + -0.03, + 0.89, + -0.27, + 0, + 0.41, + -0.66, + 0.18, + -0.91 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arcsine (in degrees)", + "desc": "hyperbolic arctangent", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "asin", - "degree", - "arcsine", - "sine", - "inverse" + "atanh", + "hyperbolic", + "inverse", + "tangent", + "tan" ], "extra_keywords": [ - "math.asin" + "math.atanh" ] }, - "@stdlib/math/base/special/asind": { + "@stdlib/math/base/special/avercosf": { "$schema": "math/base@v1.0", - "base_alias": "asind", - "alias": "asind", - "pkg_desc": "compute the arcsine (in degrees) of a double-precision floating-point number", - "desc": "computes the arcsine (in degrees) of a double-precision floating-point number", - "short_desc": "arcsine", + "base_alias": "avercos", + "alias": "avercosf", + "pkg_desc": "compute the inverse versed cosine (in radians) of a single-precision floating-point number", + "desc": "computes the inverse versed cosine (in radians) of a single-precision floating-point number", + "short_desc": "inverse versed cosine", "parameters": [ { "name": "x", @@ -3061,74 +3995,82 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { - "min": -1, - "max": 1 + "min": -2, + "max": 0 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -1, - 1 + -2, + 0 ] }, "example_values": [ - 0.58, - -0.73, - 0.11, - -0.94, - 0.37, - -0.06, - 0.98, - -0.21, - 0.44, - -0.77, - 0.59, - -0.14, - 0.27, - -0.35, - 0.86, - -0.01, - -0.41, - 0.18, - -0.66, - 1 + -0.08, + -1.64, + -0.91, + -0.21, + -1.09, + -0.59, + -1.87, + -0.33, + -1.42, + -0.79, + -0.16, + -1.19, + -0.53, + -1.01, + -0.73, + -1.71, + -0.27, + -1.29, + -0.46, + -1.81 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arcsine (in degrees)", + "desc": "inverse versed cosine (in radians)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "asin", - "degree", - "arcsine", - "sine", - "inverse" + "avercos", + "avercosin", + "avercosine", + "arcvercos", + "arcvercosin", + "versed cosine", + "avercosinus", + "avcs", + "arc", + "versed", + "cosine", + "cos", + "acos" ], "extra_keywords": [ - "math.asin" + "math.acos" ] }, - "@stdlib/math/base/special/asinh": { + "@stdlib/math/base/special/avercos": { "$schema": "math/base@v1.0", - "base_alias": "asinh", - "alias": "asinh", - "pkg_desc": "compute the hyperbolic arcsine of a double-precision floating-point number", - "desc": "computes the hyperbolic arcsine of a double-precision floating-point number", - "short_desc": "hyperbolic arcsine", + "base_alias": "avercos", + "alias": "avercos", + "pkg_desc": "compute the inverse versed cosine (in radians) of a double-precision floating-point number", + "desc": "computes the inverse versed cosine (in radians) of a double-precision floating-point number", + "short_desc": "inverse versed cosine", "parameters": [ { "name": "x", @@ -3141,44 +4083,44 @@ }, "domain": [ { - "min": "-infinity", - "max": "infinity" + "min": -2, + "max": 0 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -5, - 5 + -2, + 0 ] }, "example_values": [ - 100, - -37.5, - 0.42, - -250.8, - 3.78, - -0.42, - 1.97, - -4.63, - 0.12, - -1.55, - 4.41, - -0.93, - 2.88, - -3.37, - 0.68, - -2.46, - 5, - -0.17, - -100, - 250.3 + -0.04, + -1.7, + -0.96, + -0.25, + -1.13, + -0.62, + -1.91, + -0.37, + -1.48, + -0.83, + -0.12, + -1.23, + -0.57, + -1.03, + -0.7, + -1.66, + -0.19, + -1.34, + -0.49, + -1.85 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic arcsine", + "desc": "inverse versed cosine (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -3187,23 +4129,31 @@ } }, "keywords": [ - "asinh", - "hyperbolic", - "inverse", - "arcsine", - "sine" + "avercos", + "avercosin", + "avercosine", + "arcvercos", + "arcvercosin", + "versed cosine", + "avercosinus", + "avcs", + "arc", + "versed", + "cosine", + "cos", + "acos" ], "extra_keywords": [ - "math.asinh" + "math.acos" ] }, - "@stdlib/math/base/special/atanf": { + "@stdlib/math/base/special/aversinf": { "$schema": "math/base@v1.0", - "base_alias": "atan", - "alias": "atanf", - "pkg_desc": "compute the arctangent (in radians) of a single-precision floating-point number", - "desc": "computes the arctangent (in radians) of a single-precision floating-point number", - "short_desc": "arctangent", + "base_alias": "aversin", + "alias": "aversinf", + "pkg_desc": "compute the inverse versed sine (in radians) of a single-precision floating-point number", + "desc": "computes the inverse versed sine (in radians) of a single-precision floating-point number", + "short_desc": "inverse versed sine", "parameters": [ { "name": "x", @@ -3216,44 +4166,44 @@ }, "domain": [ { - "min": "-infinity", - "max": "infinity" + "min": 0, + "max": 2 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -50, - 50 + 0, + 2 ] }, "example_values": [ - -0.91, - 23.4, - -11.7, - 0.03, - 77.8, - -2.2, - 5.6, - -39.1, - 1.01, - -0.47, - 14.9, - -8.3, - 0, - 3.33, - -25.6, - 6.7, - -4.2, - 41.5, - -19.9, - 95.2 + 0.09, + 1.69, + 0.9, + 0.2, + 1.04, + 0.58, + 1.86, + 0.31, + 1.4, + 0.77, + 0.17, + 1.16, + 0.51, + 0.99, + 0.72, + 1.74, + 0.25, + 1.27, + 0.43, + 1.79 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arctangent (in radians)", + "desc": "inverse versed sine (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -3262,22 +4212,32 @@ } }, "keywords": [ - "atanf", - "arctangent", - "tangent", - "inverse" + "aversin", + "aversine", + "arcversin", + "arcversine", + "versed sine", + "aversinus", + "arcvers", + "avers", + "aver", + "arc", + "versed", + "sine", + "sin", + "acos" ], "extra_keywords": [ - "math.atan" + "math.acos" ] }, - "@stdlib/math/base/special/atan": { + "@stdlib/math/base/special/aversin": { "$schema": "math/base@v1.0", - "base_alias": "atan", - "alias": "atan", - "pkg_desc": "compute the arctangent (in radians) of a double-precision floating-point number", - "desc": "computes the arctangent (in radians) of a double-precision floating-point number", - "short_desc": "arctangent", + "base_alias": "aversin", + "alias": "aversin", + "pkg_desc": "compute the inverse versed sine (in radians) of a double-precision floating-point number", + "desc": "computes the inverse versed sine (in radians) of a double-precision floating-point number", + "short_desc": "inverse versed sine", "parameters": [ { "name": "x", @@ -3290,44 +4250,44 @@ }, "domain": [ { - "min": "-infinity", - "max": "infinity" - } - ], - "rand": { - "prng": "random/base/uniform", - "parameters": [ - -100, - 100 - ] - }, - "example_values": [ - 0.33, - -57.2, - 1.2, - -0.77, - 1000, - -3.41, - 8.9, - -250.5, - 0.01, - 42, - -19.7, - 73.6, - -0.58, - 5.5, - -99.9, - 7.25, - -12.3, - 0, - 315.8, - -1.1 + "min": 0, + "max": 2 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 2 + ] + }, + "example_values": [ + 0.06, + 1.72, + 0.94, + 0.18, + 1.07, + 0.6, + 1.92, + 0.29, + 1.37, + 0.81, + 0.14, + 1.21, + 0.55, + 1.02, + 0.76, + 1.68, + 0.23, + 1.31, + 0.47, + 1.84 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arctangent (in radians)", + "desc": "inverse versed sine (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -3336,98 +4296,96 @@ } }, "keywords": [ - "atan", - "arctangent", - "tangent", - "tan", + "aversin", + "aversine", + "arcversin", + "arcversine", + "versed sine", + "aversinus", + "arcvers", + "avers", + "aver", "arc", - "inverse" + "versed", + "sine", + "sin", + "acos" ], "extra_keywords": [ - "math.atan" + "math.acos" ] }, - "@stdlib/math/base/special/atandf": { + "@stdlib/math/base/special/bernoullif": {}, + "@stdlib/math/base/special/bernoulli": { "$schema": "math/base@v1.0", - "base_alias": "atand", - "alias": "atandf", - "pkg_desc": "compute the arctangent (in degrees) of a single-precision floating-point number", - "desc": "computes the arctangent (in degrees) of a single-precision floating-point number", - "short_desc": "arctangent", + "base_alias": "bernoulli", + "alias": "bernoulli", + "pkg_desc": "compute the nth Bernoulli number", + "desc": "computes the nth Bernoulli number", + "short_desc": "Bernoulli number", "parameters": [ { - "name": "x", + "name": "n", "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { - "min": "-infinity", + "min": 0, "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - -50, - 50 + 0, + 30 ] }, "example_values": [ - 0.21, - -77.3, - 6.4, - -0.18, - 19.7, - -41.2, - 2.05, - -9.9, - 73.3, - -25.6, 0, - 38.9, - -4.7, - 101.5, - -12.1, - 5.8, - -33.4, - 1.03, - 250.2, - -150.7 + 1, + 2, + 3, + 4, + 5, + 6, + 10, + 20, + 15, + 18, + 25, + 21, + 22 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arctangent (in degrees)", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "degree", - "arctangent", - "tangent", - "inverse" + "bernoulli" ], - "extra_keywords": [ - "math.atan" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/atand": { + "@stdlib/math/base/special/besselj0": { "$schema": "math/base@v1.0", - "base_alias": "atand", - "alias": "atand", - "pkg_desc": "compute the arctangent (in degrees) of a double-precision floating-point number", - "desc": "computes the arctangent (in degrees) of a double-precision floating-point number", - "short_desc": "arctangent", + "base_alias": "besselj0", + "alias": "besselj0", + "pkg_desc": "compute the Bessel function of the first kind of order zero for a double-precision floating-point number", + "desc": "computes the Bessel function of the first kind of order zero for a double-precision floating-point number", + "short_desc": "Bessel function of the first kind of order zero", "parameters": [ { "name": "x", @@ -3452,32 +4410,32 @@ ] }, "example_values": [ - 180.2, - -3.7, - 0.42, - -98.5, - 5.4, - -0.06, - 73.1, - -41.3, - 9.9, - -12.2, + -250.3, + 0.12, + 3.7, + -5.9, + 10.4, + -1.01, + 42, + -77.6, 0, - 31.8, - -7.5, - 250.7, - -0.9, - 14.2, - -66.4, - 1.01, - 1000, - -325.6 + 6.28, + -19.1, + 85.2, + -33.3, + 1.5, + -0.43, + 9.81, + -123.4, + 57.9, + -2.7, + 1000 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "arctangent (in degrees)", + "desc": "evaluated Bessel function", "type": { "javascript": "number", "jsdoc": "number", @@ -3486,22 +4444,18 @@ } }, "keywords": [ - "degree", - "arctangent", - "tangent", - "inverse" + "bessel", + "j0" ], - "extra_keywords": [ - "math.atan" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/atanh": { + "@stdlib/math/base/special/besselj1": { "$schema": "math/base@v1.0", - "base_alias": "atanh", - "alias": "atanh", - "pkg_desc": "compute the hyperbolic arctangent of a double-precision floating-point number", - "desc": "computes the hyperbolic arctangent of a double-precision floating-point number", - "short_desc": "hyperbolic arctangent", + "base_alias": "besselj1", + "alias": "besselj1", + "pkg_desc": "compute the Bessel function of the first kind of order one for a double-precision floating-point number", + "desc": "computes the Bessel function of the first kind of order one for a double-precision floating-point number", + "short_desc": "Bessel function of the first kind of order one", "parameters": [ { "name": "x", @@ -3514,44 +4468,44 @@ }, "domain": [ { - "min": -1, - "max": 1 + "min": "-infinity", + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -0.95, - 0.95 + -100, + 100 ] }, "example_values": [ - -0.99, - 0.72, - -0.15, - 0.93, - -0.61, - 0.05, - -0.84, - 0.31, - -0.47, - 0.12, - -0.72, - 0.6, - -0.03, - 0.89, - -0.27, + 0.2, + -0.87, + 4.1, + -6.3, + 12.7, + -2.25, + 50.9, + -99.4, + 8.2, + -3.6, 0, - 0.41, - -0.66, - 0.18, - -0.91 + 31.4, + -15.9, + 72.3, + -41.2, + 1.07, + -250.8, + 5.5, + -27.3, + 1000 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic arctangent", + "desc": "evaluated Bessel function", "type": { "javascript": "number", "jsdoc": "number", @@ -3560,23 +4514,18 @@ } }, "keywords": [ - "atanh", - "hyperbolic", - "inverse", - "tangent", - "tan" + "bessel", + "j1" ], - "extra_keywords": [ - "math.atanh" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/avercosf": { - "$schema": "math/base@v1.0", - "base_alias": "avercos", - "alias": "avercosf", - "pkg_desc": "compute the inverse versed cosine (in radians) of a single-precision floating-point number", - "desc": "computes the inverse versed cosine (in radians) of a single-precision floating-point number", - "short_desc": "inverse versed cosine", + "@stdlib/math/base/special/bessely0": { + "$schema": "math/base@v1.0", + "base_alias": "bessely0", + "alias": "bessely0", + "pkg_desc": "compute the Bessel function of the second kind of order zero for a double-precision floating-point number", + "desc": "computes the Bessel function of the second kind of order zero for a double-precision floating-point number", + "short_desc": "Bessel function of the second kind of order zero", "parameters": [ { "name": "x", @@ -3584,82 +4533,69 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { - "min": -2, - "max": 0 + "min": 0, + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -2, - 0 + 0.01, + 100 ] }, "example_values": [ - -0.08, - -1.64, - -0.91, - -0.21, - -1.09, - -0.59, - -1.87, - -0.33, - -1.42, - -0.79, - -0.16, - -1.19, - -0.53, - -1.01, - -0.73, - -1.71, - -0.27, - -1.29, - -0.46, - -1.81 + 73.4, + 0.11, + 5.07, + 120.8, + 0.63, + 44.2, + 2.9, + 89.5, + 0.02, + 15.3, + 33.7, + 0.95, + 7.8, + 58.1, + 101.3, + 0.27, + 24.6, + 12.9, + 66.4, + 150.2 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse versed cosine (in radians)", + "desc": "evaluated Bessel function", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "avercos", - "avercosin", - "avercosine", - "arcvercos", - "arcvercosin", - "versed cosine", - "avercosinus", - "avcs", - "arc", - "versed", - "cosine", - "cos", - "acos" + "bessel", + "y0" ], - "extra_keywords": [ - "math.acos" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/avercos": { + "@stdlib/math/base/special/bessely1": { "$schema": "math/base@v1.0", - "base_alias": "avercos", - "alias": "avercos", - "pkg_desc": "compute the inverse versed cosine (in radians) of a double-precision floating-point number", - "desc": "computes the inverse versed cosine (in radians) of a double-precision floating-point number", - "short_desc": "inverse versed cosine", + "base_alias": "bessely1", + "alias": "bessely1", + "pkg_desc": "compute the Bessel function of the second kind of order one for a double-precision floating-point number", + "desc": "computes the Bessel function of the second kind of order one for a double-precision floating-point number", + "short_desc": "Bessel function of the second kind of order one", "parameters": [ { "name": "x", @@ -3672,44 +4608,44 @@ }, "domain": [ { - "min": -2, - "max": 0 + "min": 0, + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -2, - 0 + 0.01, + 100 ] }, "example_values": [ - -0.04, - -1.7, - -0.96, - -0.25, - -1.13, - -0.62, - -1.91, - -0.37, - -1.48, - -0.83, - -0.12, - -1.23, - -0.57, - -1.03, - -0.7, - -1.66, - -0.19, - -1.34, - -0.49, - -1.85 + 73.2, + 0.03, + 5.41, + 121.7, + 0.67, + 44.9, + 2.85, + 89.1, + 0.12, + 15.8, + 33.05, + 0.98, + 7.43, + 58.6, + 101.9, + 0.29, + 24.1, + 12.2, + 66.9, + 140.3 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse versed cosine (in radians)", + "desc": "evaluated Bessel function", "type": { "javascript": "number", "jsdoc": "number", @@ -3718,31 +4654,18 @@ } }, "keywords": [ - "avercos", - "avercosin", - "avercosine", - "arcvercos", - "arcvercosin", - "versed cosine", - "avercosinus", - "avcs", - "arc", - "versed", - "cosine", - "cos", - "acos" + "bessel", + "y1" ], - "extra_keywords": [ - "math.acos" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/aversinf": { + "@stdlib/math/base/special/binet": { "$schema": "math/base@v1.0", - "base_alias": "aversin", - "alias": "aversinf", - "pkg_desc": "compute the inverse versed sine (in radians) of a single-precision floating-point number", - "desc": "computes the inverse versed sine (in radians) of a single-precision floating-point number", - "short_desc": "inverse versed sine", + "base_alias": "binet", + "alias": "binet", + "pkg_desc": "evaluate Binet's formula extended to real numbers for a double-precision floating-point number", + "desc": "evaluates Binet's formula extended to real numbers for a double-precision floating-point number", + "short_desc": "Binet's formula", "parameters": [ { "name": "x", @@ -3750,83 +4673,72 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { - "min": 0, - "max": 2 + "min": "-infinity", + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, - 2 + -50, + 50 ] }, "example_values": [ - 0.09, - 1.69, - 0.9, - 0.2, - 1.04, - 0.58, - 1.86, - 0.31, - 1.4, - 0.77, - 0.17, - 1.16, - 0.51, - 0.99, - 0.72, - 1.74, - 0.25, - 1.27, - 0.43, - 1.79 + 250.8, + -41.2, + 0.37, + -120.5, + 73.1, + -7.6, + 12.3, + -0.95, + 19.8, + -25.7, + 5.5, + -3.9, + 34.6, + -88.4, + 1.7, + 0, + 47.8, + -15.4, + 102.6, + -10.3 ] - } - ], - "output_policy": "real_floating_point_and_generic", - "returns": { - "desc": "inverse versed sine (in radians)", - "type": { - "javascript": "number", - "jsdoc": "number", - "c": "float", - "dtype": "float32" - } - }, - "keywords": [ - "aversin", - "aversine", - "arcversin", - "arcversine", - "versed sine", - "aversinus", - "arcvers", - "avers", - "aver", - "arc", - "versed", - "sine", - "sin", - "acos" + } ], - "extra_keywords": [ - "math.acos" - ] + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "real-valued result", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "binet", + "fibonacci", + "fib", + "number", + "reals" + ], + "extra_keywords": [] }, - "@stdlib/math/base/special/aversin": { + "@stdlib/math/base/special/cbrtf": { "$schema": "math/base@v1.0", - "base_alias": "aversin", - "alias": "aversin", - "pkg_desc": "compute the inverse versed sine (in radians) of a double-precision floating-point number", - "desc": "computes the inverse versed sine (in radians) of a double-precision floating-point number", - "short_desc": "inverse versed sine", + "base_alias": "cbrt", + "alias": "cbrtf", + "pkg_desc": "compute the cube root of a single-precision floating-point number", + "desc": "computes the cube root of a single-precision floating-point number", + "short_desc": "cube root", "parameters": [ { "name": "x", @@ -3834,85 +4746,73 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { - "min": 0, - "max": 2 + "min": "-infinity", + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, - 2 + -10, + 10 ] }, "example_values": [ - 0.06, - 1.72, - 0.94, - 0.18, - 1.07, - 0.6, - 1.92, - 0.29, - 1.37, - 0.81, - 0.14, - 1.21, - 0.55, - 1.02, - 0.76, - 1.68, - 0.23, - 1.31, - 0.47, - 1.84 + 64, + 27, + 0, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15, + -23.4 ] } ], - "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "inverse versed sine (in radians)", + "desc": "cube root", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "aversin", - "aversine", - "arcversin", - "arcversine", - "versed sine", - "aversinus", - "arcvers", - "avers", - "aver", - "arc", - "versed", - "sine", - "sin", - "acos" + "cube", + "root", + "cbrt", + "cubic", + "power" ], "extra_keywords": [ - "math.acos" + "math.cbrt" ] }, - "@stdlib/math/base/special/bernoullif": {}, - "@stdlib/math/base/special/bernoulli": {}, - "@stdlib/math/base/special/besselj0": { + "@stdlib/math/base/special/cbrt": { "$schema": "math/base@v1.0", - "base_alias": "besselj0", - "alias": "besselj0", - "pkg_desc": "compute the Bessel function of the first kind of order zero for a double-precision floating-point number", - "desc": "computes the Bessel function of the first kind of order zero for a double-precision floating-point number", - "short_desc": "Bessel function of the first kind of order zero", + "base_alias": "cbrt", + "alias": "cbrt", + "pkg_desc": "compute the cube root", + "desc": "computes the cube root", + "short_desc": "cube root", "parameters": [ { "name": "x", @@ -3932,37 +4832,36 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -100, - 100 + -10, + 10 ] }, "example_values": [ - -250.3, - 0.12, - 3.7, - -5.9, - 10.4, - -1.01, - 42, - -77.6, + 64, + 27, 0, - 6.28, - -19.1, - 85.2, - -33.3, - 1.5, - -0.43, - 9.81, - -123.4, - 57.9, - -2.7, - 1000 + 0.9, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], - "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "evaluated Bessel function", + "desc": "cube root", "type": { "javascript": "number", "jsdoc": "number", @@ -3971,18 +4870,26 @@ } }, "keywords": [ - "bessel", - "j0" + "cube", + "root", + "cbrt", + "cubic", + "power" ], - "extra_keywords": [] + "extra_keywords": [ + "math.cbrt" + ] }, - "@stdlib/math/base/special/besselj1": { + "@stdlib/number/int8/base/identity": {}, + "@stdlib/number/int16/base/identity": {}, + "@stdlib/number/int32/base/identity": {}, + "@stdlib/math/base/special/ceilf": { "$schema": "math/base@v1.0", - "base_alias": "besselj1", - "alias": "besselj1", - "pkg_desc": "compute the Bessel function of the first kind of order one for a double-precision floating-point number", - "desc": "computes the Bessel function of the first kind of order one for a double-precision floating-point number", - "short_desc": "Bessel function of the first kind of order one", + "base_alias": "ceil", + "alias": "ceilf", + "pkg_desc": "round a single-precision floating-point number toward positive infinity", + "desc": "rounds a single-precision floating-point number toward positive infinity", + "short_desc": "", "parameters": [ { "name": "x", @@ -3990,8 +4897,8 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { @@ -4002,57 +4909,63 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -100, - 100 + -50, + 50 ] }, "example_values": [ - 0.2, - -0.87, - 4.1, - -6.3, - 12.7, - -2.25, - 50.9, - -99.4, - 8.2, - -3.6, + 11.11, + -0.01, + 31.6, + -7.2, + 0.49, + 49.99, + 2.3, + -13.7, 0, - 31.4, - -15.9, - 72.3, - -41.2, - 1.07, - -250.8, - 5.5, - -27.3, - 1000 + 7.01, + -0.9, + 19.7, + 3.99, + 0.02, + 42.05, + 1.01, + 23.4, + 5.6, + 15.2, + 9.9 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "evaluated Bessel function", + "desc": "rounded value", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "bessel", - "j1" + "ceil", + "round", + "integer", + "nearest", + "ceiling", + "floor" ], - "extra_keywords": [] + "extra_keywords": [ + "math.ceil" + ] }, - "@stdlib/math/base/special/bessely0": { + "@stdlib/math/base/special/ceil": { "$schema": "math/base@v1.0", - "base_alias": "bessely0", - "alias": "bessely0", - "pkg_desc": "compute the Bessel function of the second kind of order zero for a double-precision floating-point number", - "desc": "computes the Bessel function of the second kind of order zero for a double-precision floating-point number", - "short_desc": "Bessel function of the second kind of order zero", + "base_alias": "ceil", + "alias": "ceil", + "pkg_desc": "round a number toward positive infinity", + "desc": "rounds a number toward positive infinity", + "short_desc": "ceil", "parameters": [ { "name": "x", @@ -4065,44 +4978,44 @@ }, "domain": [ { - "min": 0, + "min": "-infinity", "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.01, - 100 + -10, + 10 ] }, "example_values": [ - 73.4, - 0.11, - 5.07, - 120.8, - 0.63, - 44.2, - 2.9, - 89.5, - 0.02, - 15.3, - 33.7, - 0.95, - 7.8, - 58.1, - 101.3, - 0.27, - 24.6, - 12.9, - 66.4, - 150.2 + 64.5, + 27.6, + 0.9, + 0.1, + -9.2, + 8.3, + -1.4, + 125.01, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], - "output_policy": "real_floating_point_and_generic", + "output_policy": "real_and_generic", "returns": { - "desc": "evaluated Bessel function", + "desc": "rounded value", "type": { "javascript": "number", "jsdoc": "number", @@ -4111,18 +5024,155 @@ } }, "keywords": [ - "bessel", - "y0" + "ceil", + "round", + "integer", + "nearest", + "value" ], - "extra_keywords": [] + "extra_keywords": [ + "math.ceil" + ] }, - "@stdlib/math/base/special/bessely1": { + "@stdlib/math/base/special/cceilf": {}, + "@stdlib/math/base/special/cceil": { "$schema": "math/base@v1.0", - "base_alias": "bessely1", - "alias": "bessely1", - "pkg_desc": "compute the Bessel function of the second kind of order one for a double-precision floating-point number", - "desc": "computes the Bessel function of the second kind of order one for a double-precision floating-point number", - "short_desc": "Bessel function of the second kind of order one", + "base_alias": "ceil", + "alias": "cceil", + "pkg_desc": "round each component of a complex number toward positive infinity", + "desc": "rounds each component of a complex number toward positive infinity", + "short_desc": "", + "parameters": [ + { + "name": "z", + "desc": "input value", + "type": { + "javascript": "Complex128", + "jsdoc": "Complex128", + "c": "stdlib_complex128_t", + "dtype": "complex128" + }, + "domain": null, + "rand": { + "prng": "random/base/uniform", + "parameters": [ + [ + -10, + 10 + ], + [ + -10, + 10 + ] + ] + }, + "example_values": [ + { + "re": -3.14, + "im": -1.5 + }, + { + "re": 0, + "im": 0 + }, + { + "re": -1.5, + "im": 2.5 + }, + { + "re": 2.5, + "im": -1.5 + }, + { + "re": 0, + "im": -3.7 + }, + { + "re": 4.2, + "im": 0 + }, + { + "re": 21.2, + "im": 3 + }, + { + "re": 11, + "im": -5 + }, + { + "re": 33, + "im": -14.67 + }, + { + "re": -42, + "im": 9.3 + }, + { + "re": -3, + "im": 3 + }, + { + "re": 73, + "im": 31 + }, + { + "re": -2.45, + "im": 1.23 + }, + { + "re": 2.45, + "im": -1.23 + }, + { + "re": 1.77, + "im": -3.14 + }, + { + "re": -7.5, + "im": 8.2 + }, + { + "re": 5.5, + "im": -12.3 + }, + { + "re": -15.8, + "im": 0.4 + }, + { + "re": 0.99, + "im": -0.99 + } + ] + } + ], + "returns": { + "desc": "result", + "type": { + "javascript": "Complex128", + "jsdoc": "Complex128", + "c": "stdlib_complex128_t", + "dtype": "complex128" + } + }, + "keywords": [ + "ceil", + "cceil", + "round", + "complex", + "ceiling" + ], + "extra_keywords": [ + "math.ceil" + ] + }, + "@stdlib/math/base/special/ceil10": { + "$schema": "math/base@v1.0", + "base_alias": "ceil10", + "alias": "ceil10", + "pkg_desc": "round a number to the nearest power of 10 toward positive infinity", + "desc": "rounds a number to the nearest power of 10 toward positive infinity", + "short_desc": "", "parameters": [ { "name": "x", @@ -4135,44 +5185,44 @@ }, "domain": [ { - "min": 0, - "max": "infinity" - } - ], - "rand": { - "prng": "random/base/uniform", - "parameters": [ - 0.01, - 100 - ] - }, - "example_values": [ - 73.2, - 0.03, - 5.41, - 121.7, - 0.67, - 44.9, - 2.85, - 89.1, - 0.12, - 15.8, - 33.05, - 0.98, - 7.43, - 58.6, - 101.9, - 0.29, - 24.1, - 12.2, - 66.9, - 140.3 + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -100, + 100 + ] + }, + "example_values": [ + 64.78, + 27.5, + 0, + 0.1, + -91.1, + 18.2, + -13.5, + 125, + -10.2, + 11.3, + -12.4, + 3.567, + -100.67, + 15.7, + -162, + 172.49, + -188.98, + 19.11, + -200.23, + 21.151 ] } ], - "output_policy": "real_floating_point_and_generic", + "output_policy": "real_and_generic", "returns": { - "desc": "evaluated Bessel function", + "desc": "rounded value", "type": { "javascript": "number", "jsdoc": "number", @@ -4181,18 +5231,25 @@ } }, "keywords": [ - "bessel", - "y1" + "ceil", + "ceil10", + "round", + "power", + "ten", + "nearest", + "value" ], - "extra_keywords": [] + "extra_keywords": [ + "math.ceil" + ] }, - "@stdlib/math/base/special/binet": { + "@stdlib/math/base/special/ceil2": { "$schema": "math/base@v1.0", - "base_alias": "binet", - "alias": "binet", - "pkg_desc": "evaluate Binet's formula extended to real numbers for a double-precision floating-point number", - "desc": "evaluates Binet's formula extended to real numbers for a double-precision floating-point number", - "short_desc": "Binet's formula", + "base_alias": "ceil2", + "alias": "ceil2", + "pkg_desc": "round a double-precision floating-point number to the nearest power of two toward positive infinity", + "desc": "rounds a double-precision floating-point number to the nearest power of two toward positive infinity", + "short_desc": "", "parameters": [ { "name": "x", @@ -4212,37 +5269,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -50, - 50 + -100, + 100 ] }, "example_values": [ - 250.8, - -41.2, - 0.37, - -120.5, - 73.1, - -7.6, - 12.3, - -0.95, - 19.8, - -25.7, - 5.5, - -3.9, - 34.6, - -88.4, - 1.7, + 47.95, + -311.8, + 0.07, + 123.4, + -0.02, + 2.49, + 2049.9, + -73.45, + 6.88, + 1.17, + 79.6, + -5.06, + 511.2, 0, - 47.8, - -15.4, - 102.6, - -10.3 + 21.3, + -0.83, + 4.63, + 9.01, + 0.28, + 13.57 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "real-valued result", + "desc": "rounded value", "type": { "javascript": "number", "jsdoc": "number", @@ -4251,25 +5308,29 @@ } }, "keywords": [ - "binet", - "fibonacci", - "fib", - "number", - "reals" + "ceil", + "ceil2", + "round", + "nextpow2", + "prevpow2", + "nearest", + "number" ], - "extra_keywords": [] + "extra_keywords": [ + "math.ceil" + ] }, - "@stdlib/math/base/special/cbrtf": { + "@stdlib/math/base/special/cosf": { "$schema": "math/base@v1.0", - "base_alias": "cbrt", - "alias": "cbrtf", - "pkg_desc": "compute the cube root of a single-precision floating-point number", - "desc": "computes the cube root of a single-precision floating-point number", - "short_desc": "cube root", + "base_alias": "cos", + "alias": "cosf", + "pkg_desc": "compute the cosine of a single-precision floating-point number (in radians)", + "desc": "computes the cosine of a single-precision floating-point number (in radians)", + "short_desc": "cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -4293,6 +5354,7 @@ 64, 27, 0, + 0.1, -9, 8, -1, @@ -4308,13 +5370,13 @@ -188, 19.11, -200, - 21.15, - -23.4 + 21.15 ] } ], + "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cube root", + "desc": "cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -4323,27 +5385,28 @@ } }, "keywords": [ - "cube", - "root", - "cbrt", - "cubic", - "power" + "cos", + "cosf", + "cosine", + "trig", + "trigonometry", + "radians" ], "extra_keywords": [ - "math.cbrt" + "math.cos" ] }, - "@stdlib/math/base/special/cbrt": { + "@stdlib/math/base/special/cos": { "$schema": "math/base@v1.0", - "base_alias": "cbrt", - "alias": "cbrt", - "pkg_desc": "compute the cube root", - "desc": "computes the cube root", - "short_desc": "cube root", + "base_alias": "cos", + "alias": "cos", + "pkg_desc": "compute the cosine", + "desc": "computes the cosine", + "short_desc": "cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -4367,7 +5430,7 @@ 64, 27, 0, - 0.9, + 0.1, -9, 8, -1, @@ -4387,8 +5450,9 @@ ] } ], + "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cube root", + "desc": "cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -4397,30 +5461,27 @@ } }, "keywords": [ - "cube", - "root", - "cbrt", - "cubic", - "power" + "cos", + "cosine", + "trig", + "trigonometry", + "radians" ], "extra_keywords": [ - "math.cbrt" + "math.cos" ] }, - "@stdlib/number/int8/base/identity": {}, - "@stdlib/number/int16/base/identity": {}, - "@stdlib/number/int32/base/identity": {}, - "@stdlib/math/base/special/ceilf": { + "@stdlib/math/base/special/cosdf": { "$schema": "math/base@v1.0", - "base_alias": "ceil", - "alias": "ceilf", - "pkg_desc": "round a single-precision floating-point number toward positive infinity", - "desc": "rounds a single-precision floating-point number toward positive infinity", - "short_desc": "", + "base_alias": "cosd", + "alias": "cosdf", + "pkg_desc": "compute the cosine", + "desc": "computes the cosine", + "short_desc": "cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -4436,37 +5497,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -50, - 50 + -360, + 360 ] }, "example_values": [ - 11.11, - -0.01, - 31.6, - -7.2, - 0.49, - 49.99, - 2.3, - -13.7, 0, - 7.01, - -0.9, - 19.7, - 3.99, - 0.02, - 42.05, - 1.01, - 23.4, - 5.6, - 15.2, - 9.9 + 30, + 45, + 60, + 90, + 120, + 180, + -30, + -45, + -60, + -90, + -120, + -180, + 270, + -270, + 360, + -360, + 220, + -80, + -40 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "rounded value", + "desc": "cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -4475,28 +5536,28 @@ } }, "keywords": [ - "ceil", - "round", - "integer", - "nearest", - "ceiling", - "floor" + "cos", + "cosdf", + "cosine", + "trig", + "trigonometry", + "degrees" ], "extra_keywords": [ - "math.ceil" + "math.cos" ] }, - "@stdlib/math/base/special/ceil": { + "@stdlib/math/base/special/cosd": { "$schema": "math/base@v1.0", - "base_alias": "ceil", - "alias": "ceil", - "pkg_desc": "round a number toward positive infinity", - "desc": "rounds a number toward positive infinity", - "short_desc": "ceil", + "base_alias": "cos", + "alias": "cosd", + "pkg_desc": "compute the cosine", + "desc": "computes the cosine", + "short_desc": "cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -4512,37 +5573,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + -360, + 360 ] }, "example_values": [ - 64.5, - 27.6, - 0.9, - 0.1, - -9.2, - 8.3, - -1.4, - 125.01, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 0, + 30, + 45, + 60, + 90, + 120, + 180, + -30, + -45, + -60, + -90, + -120, + -180, + 270, + -270, + 360, + -360, + 220, + -80, + -40 ] } ], - "output_policy": "real_and_generic", + "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "rounded value", + "desc": "cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -4551,164 +5612,106 @@ } }, "keywords": [ - "ceil", - "round", - "integer", - "nearest", - "value" + "cos", + "cosd", + "cosine", + "trig", + "trigonometry", + "degrees" ], "extra_keywords": [ - "math.ceil" + "math.cos" ] }, - "@stdlib/math/base/special/cceilf": {}, - "@stdlib/math/base/special/cceil": { + "@stdlib/math/base/special/cosh": { "$schema": "math/base@v1.0", - "base_alias": "ceil", - "alias": "cceil", - "pkg_desc": "round each component of a complex number toward positive infinity", - "desc": "rounds each component of a complex number toward positive infinity", - "short_desc": "", + "base_alias": "cosh", + "alias": "cosh", + "pkg_desc": "compute the hyperbolic cosine of a double-precision floating-point number", + "desc": "computes the hyperbolic cosine of a double-precision floating-point number", + "short_desc": "hyperbolic cosine", "parameters": [ { - "name": "z", + "name": "x", "desc": "input value", "type": { - "javascript": "Complex128", - "jsdoc": "Complex128", - "c": "stdlib_complex128_t", - "dtype": "complex128" + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" }, - "domain": null, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], "rand": { "prng": "random/base/uniform", "parameters": [ - [ - -10, - 10 - ], - [ - -10, - 10 - ] + -50, + 50 ] }, "example_values": [ - { - "re": -3.14, - "im": -1.5 - }, - { - "re": 0, - "im": 0 - }, - { - "re": -1.5, - "im": 2.5 - }, - { - "re": 2.5, - "im": -1.5 - }, - { - "re": 0, - "im": -3.7 - }, - { - "re": 4.2, - "im": 0 - }, - { - "re": 21.2, - "im": 3 - }, - { - "re": 11, - "im": -5 - }, - { - "re": 33, - "im": -14.67 - }, - { - "re": -42, - "im": 9.3 - }, - { - "re": -3, - "im": 3 - }, - { - "re": 73, - "im": 31 - }, - { - "re": -2.45, - "im": 1.23 - }, - { - "re": 2.45, - "im": -1.23 - }, - { - "re": 1.77, - "im": -3.14 - }, - { - "re": -7.5, - "im": 8.2 - }, - { - "re": 5.5, - "im": -12.3 - }, - { - "re": -15.8, - "im": 0.4 - }, - { - "re": 0.99, - "im": -0.99 - } + -3.7, + 0.25, + 12.9, + -0.81, + 5.4, + -19.2, + 2.3, + -7.1, + 0, + 33.8, + -14.6, + 8.05, + -0.003, + 1.7, + -2.8, + 49.9, + -26.3, + 6.6, + -11.4, + 0.93 ] } ], + "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "result", + "desc": "hyperbolic cosine", "type": { - "javascript": "Complex128", - "jsdoc": "Complex128", - "c": "stdlib_complex128_t", - "dtype": "complex128" + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" } }, "keywords": [ - "ceil", - "cceil", - "round", - "complex", - "ceiling" + "cosine", + "cos", + "hyperbolic" ], "extra_keywords": [ - "math.ceil" + "math.cosh" ] }, - "@stdlib/math/base/special/ceil10": { + "@stdlib/math/base/special/cosm1f": { "$schema": "math/base@v1.0", - "base_alias": "ceil10", - "alias": "ceil10", - "pkg_desc": "round a number to the nearest power of 10 toward positive infinity", - "desc": "rounds a number to the nearest power of 10 toward positive infinity", - "short_desc": "", + "base_alias": "cosm1", + "alias": "cosm1f", + "pkg_desc": "compute the cosine minus one", + "desc": "computes the cosine minus one", + "short_desc": "cosine minus one", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { @@ -4719,64 +5722,63 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -100, - 100 + -10, + 10 ] }, "example_values": [ - 64.78, - 27.5, + 64, + 27, 0, 0.1, - -91.1, - 18.2, - -13.5, + -9, + 8, + -1, 125, -10.2, 11.3, -12.4, - 3.567, - -100.67, + 3.5, + -1.6, 15.7, - -162, - 172.49, - -188.98, + -16, + 17.9, + -188, 19.11, - -200.23, - 21.151 + -200, + 21.15 ] } ], - "output_policy": "real_and_generic", + "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "rounded value", + "desc": "cosine minus one", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "ceil", - "ceil10", - "round", - "power", - "ten", - "nearest", - "value" + "math.cos", + "cos", + "cosm1", + "cosm1f", + "cosine", + "trig", + "trigonometry", + "radians" ], - "extra_keywords": [ - "math.ceil" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/ceil2": { + "@stdlib/math/base/special/cosm1": { "$schema": "math/base@v1.0", - "base_alias": "ceil2", - "alias": "ceil2", - "pkg_desc": "round a double-precision floating-point number to the nearest power of two toward positive infinity", - "desc": "rounds a double-precision floating-point number to the nearest power of two toward positive infinity", - "short_desc": "", + "base_alias": "cosm1", + "alias": "cosm1", + "pkg_desc": "compute `cos(x) - 1` where `cos` is the cosine of a number (in radians)", + "desc": "computes `cos(x) - 1` where `cos` is the cosine of a number (in radians)", + "short_desc": "cos(x) - 1", "parameters": [ { "name": "x", @@ -4796,37 +5798,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -100, - 100 + -50, + 50 ] }, "example_values": [ - 47.95, - -311.8, - 0.07, - 123.4, - -0.02, - 2.49, - 2049.9, - -73.45, - 6.88, - 1.17, - 79.6, - -5.06, - 511.2, + -2.9, + 0.41, + 7.6, + -0.37, + 3.2, + -11.8, + 1.2, + -6.4, 0, - 21.3, - -0.83, - 4.63, - 9.01, - 0.28, - 13.57 + 9.7, + -4.5, + 5.3, + -0.02, + 1.9, + -2.2, + 18.1, + -13.6, + 2.8, + -7.9, + 0.77 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "rounded value", + "desc": "result", "type": { "javascript": "number", "jsdoc": "number", @@ -4835,24 +5837,20 @@ } }, "keywords": [ - "ceil", - "ceil2", - "round", - "nextpow2", - "prevpow2", - "nearest", - "number" + "cos", + "cosm1", + "cosine" ], "extra_keywords": [ - "math.ceil" + "math.cos" ] }, - "@stdlib/math/base/special/cosf": { + "@stdlib/math/base/special/cospif": { "$schema": "math/base@v1.0", - "base_alias": "cos", - "alias": "cosf", - "pkg_desc": "compute the cosine of a single-precision floating-point number (in radians)", - "desc": "computes the cosine of a single-precision floating-point number (in radians)", + "base_alias": "cospi", + "alias": "cospif", + "pkg_desc": "compute `cos(πx)` in single-precision floating-point format", + "desc": "computes `cos(πx)` in single-precision floating-point format", "short_desc": "cosine", "parameters": [ { @@ -4903,7 +5901,7 @@ ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosine", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -4913,8 +5911,9 @@ }, "keywords": [ "cos", - "cosf", + "cospif", "cosine", + "pi", "trig", "trigonometry", "radians" @@ -4923,17 +5922,17 @@ "math.cos" ] }, - "@stdlib/math/base/special/cos": { + "@stdlib/math/base/special/cospi": { "$schema": "math/base@v1.0", - "base_alias": "cos", - "alias": "cos", - "pkg_desc": "compute the cosine", - "desc": "computes the cosine", - "short_desc": "cosine", + "base_alias": "cospi", + "alias": "cospi", + "pkg_desc": "compute the cosine of a double-precision floating-point number times π", + "desc": "computes the cosine of a double-precision floating-point number times π", + "short_desc": "cosine of a number times π", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -4949,138 +5948,224 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + -50, + 50 ] }, "example_values": [ - 64, - 27, + -3.25, + 0.125, + 1.6, + -0.45, + 2.75, + -7.3, + 4.2, + -5.8, 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, + 9.1, + -2.2, + 3.33, + -0.01, + 0.5, + -1.75, + 6.7, + -4.9, + 8.8, + -10.4, + 12.6 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "result", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cos", + "cosine", + "pi" + ], + "extra_keywords": [ + "math.cos" + ] + }, + "@stdlib/math/base/special/cotf": { + "$schema": "math/base@v1.0", + "base_alias": "cot", + "alias": "cotf", + "pkg_desc": "evaluate the cotangent of a single-precision floating-point number (in radians)", + "desc": "evaluates the cotangent of a single-precision floating-point number (in radians)", + "short_desc": "cotangent", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": -1.4e-45 + }, + { + "min": 1.4e-45, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 50 + ] + }, + "example_values": [ + 4.2, + -13.8, + 0.13, + -21.3, + 14.6, + -7.2, + 29.4, + -33.7, + 2.6, + -9.6, + 0.91, + -1.47, + -26.5, + 7.9, + -18.7, + -11.6, + -16.4, + -5.3, -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + -8.1 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosine", + "desc": "cotangent", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ + "cotf", + "cotangent", + "tan", + "tangent", + "sin", + "sine", "cos", - "cosine", - "trig", - "trigonometry", - "radians" + "cosine" ], "extra_keywords": [ - "math.cos" + "math.tan" ] }, - "@stdlib/math/base/special/cosdf": { + "@stdlib/math/base/special/cot": { "$schema": "math/base@v1.0", - "base_alias": "cosd", - "alias": "cosdf", - "pkg_desc": "compute the cosine", - "desc": "computes the cosine", - "short_desc": "cosine", + "base_alias": "cot", + "alias": "cot", + "pkg_desc": "evaluate the cotangent of a double-precision floating-point number (in radians)", + "desc": "evaluates the cotangent of a double-precision floating-point number (in radians)", + "short_desc": "cotangent", "parameters": [ { "name": "x", - "desc": "input value (in degrees)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -360, - 360 + 0.5, + 50 ] }, "example_values": [ - 0, - 30, - 45, - 60, - 90, - 120, - 180, - -30, - -45, - -60, - -90, - -120, - -180, - 270, - -270, - 360, - -360, - 220, - -80, - -40 + 11.37, + -29.07, + 5.47, + -41.83, + 2.73, + 24.13, + -6.74, + 39.72, + -0.64, + 1.19, + -14.62, + 13.64, + -9.51, + 6.88, + -18.46, + 0.53, + -4.38, + 4.11, + -2.27, + 19.82 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosine", + "desc": "cotangent", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ + "cot", + "cotangent", + "tan", + "tangent", + "sin", + "sine", "cos", - "cosdf", - "cosine", - "trig", - "trigonometry", - "degrees" + "cosine" ], "extra_keywords": [ - "math.cos" + "math.tan" ] }, - "@stdlib/math/base/special/cosd": { + "@stdlib/math/base/special/cotd": { "$schema": "math/base@v1.0", - "base_alias": "cos", - "alias": "cosd", - "pkg_desc": "compute the cosine", - "desc": "computes the cosine", - "short_desc": "cosine", + "base_alias": "cotd", + "alias": "cotd", + "pkg_desc": "evaluate the cotangent of a double-precision floating-point number (in degrees)", + "desc": "evaluates the cotangent of a double-precision floating-point number (in degrees)", + "short_desc": "cotangent", "parameters": [ { "name": "x", @@ -5094,43 +6179,47 @@ "domain": [ { "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -360, - 360 + 0.5, + 180 ] }, "example_values": [ - 0, - 30, - 45, - 60, - 90, - 120, - 180, - -30, - -45, - -60, - -90, - -120, - -180, - 270, - -270, - 360, - -360, - 220, - -80, - -40 + 34.7, + -112.7, + 146.2, + -22.8, + 73.8, + -176.4, + 0.3, + -101.5, + 59.4, + -171.8, + 16.9, + -44.1, + -139.9, + -7.5, + -67.3, + 112.6, + -150.6, + -81.2, + -163.3, + -126.4 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosine", + "desc": "cotangent", "type": { "javascript": "number", "jsdoc": "number", @@ -5139,24 +6228,27 @@ } }, "keywords": [ + "cot", + "cotd", + "cotangent", + "tan", + "tangent", + "sin", + "sine", "cos", - "cosd", - "cosine", - "trig", - "trigonometry", - "degrees" + "cosine" ], "extra_keywords": [ - "math.cos" + "math.tan" ] }, - "@stdlib/math/base/special/cosh": { + "@stdlib/math/base/special/coth": { "$schema": "math/base@v1.0", - "base_alias": "cosh", - "alias": "cosh", - "pkg_desc": "compute the hyperbolic cosine of a double-precision floating-point number", - "desc": "computes the hyperbolic cosine of a double-precision floating-point number", - "short_desc": "hyperbolic cosine", + "base_alias": "coth", + "alias": "coth", + "pkg_desc": "compute the hyperbolic cotangent of a double-precision floating-point number", + "desc": "computes the hyperbolic cotangent of a double-precision floating-point number", + "short_desc": "hyperbolic cotangent", "parameters": [ { "name": "x", @@ -5170,43 +6262,47 @@ "domain": [ { "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -50, + 0.5, 50 ] }, "example_values": [ - -3.7, - 0.25, - 12.9, - -0.81, - 5.4, - -19.2, - 2.3, - -7.1, - 0, - 33.8, - -14.6, - 8.05, - -0.003, - 1.7, - -2.8, - 49.9, - -26.3, - 6.6, - -11.4, - 0.93 + -23.8, + 17.1, + -0.73, + 0.61, + -12.4, + 3.9, + -7.6, + 26.3, + -1.3, + 2.4, + -15.4, + 10.5, + -4.9, + 7.8, + -9.2, + 18.2, + -21.9, + 12.8, + -2.6, + 0.92 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic cosine", + "desc": "hyperbolic cotangent", "type": { "javascript": "number", "jsdoc": "number", @@ -5215,21 +6311,25 @@ } }, "keywords": [ - "cosine", - "cos", + "cotangent", + "cot", + "coth", + "tangent", + "tan", + "tanh", "hyperbolic" ], "extra_keywords": [ - "math.cosh" + "math.tanh" ] }, - "@stdlib/math/base/special/cosm1f": { + "@stdlib/math/base/special/covercosf": { "$schema": "math/base@v1.0", - "base_alias": "cosm1", - "alias": "cosm1f", - "pkg_desc": "compute the cosine minus one", - "desc": "computes the cosine minus one", - "short_desc": "cosine minus one", + "base_alias": "covercos", + "alias": "covercosf", + "pkg_desc": "compute the coversed cosine of a single-precision floating-point number (in radians)", + "desc": "computes the coversed cosine of a single-precision floating-point number (in radians)", + "short_desc": "coversed cosine", "parameters": [ { "name": "x", @@ -5279,7 +6379,7 @@ ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosine minus one", + "desc": "coversed cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -5288,28 +6388,36 @@ } }, "keywords": [ - "math.cos", - "cos", - "cosm1", - "cosm1f", + "covercos", + "covercosf", + "covercosin", + "covercosine", + "coversed", + "covercosinus", + "cvc", + "versed", "cosine", + "cos", + "sine", + "sin", "trig", "trigonometry", - "radians" + "radians", + "angle" ], "extra_keywords": [] }, - "@stdlib/math/base/special/cosm1": { + "@stdlib/math/base/special/covercos": { "$schema": "math/base@v1.0", - "base_alias": "cosm1", - "alias": "cosm1", - "pkg_desc": "compute `cos(x) - 1` where `cos` is the cosine of a number (in radians)", - "desc": "computes `cos(x) - 1` where `cos` is the cosine of a number (in radians)", - "short_desc": "cos(x) - 1", + "base_alias": "covercos", + "alias": "covercos", + "pkg_desc": "compute the coversed cosine (in radians) of a double-precision floating-point number", + "desc": "computes the coversed cosine (in radians) of a double-precision floating-point number", + "short_desc": "coversed cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -5330,32 +6438,32 @@ ] }, "example_values": [ - -2.9, - 0.41, - 7.6, - -0.37, - 3.2, - -11.8, - 1.2, - -6.4, + -6.1, + -3.4, + -1.2, + -0.49, + -0.08, 0, - 9.7, - -4.5, - 5.3, - -0.02, - 1.9, - -2.2, - 18.1, - -13.6, - 2.8, - -7.9, - 0.77 + 0.27, + 0.95, + 1.7, + 2.3, + 3.6, + -2.9, + 4.8, + -5.7, + 6.9, + -7.8, + 8.4, + -9.6, + 10.3, + -11.1 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "result", + "desc": "coversed cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -5364,21 +6472,31 @@ } }, "keywords": [ + "covercos", + "covercosin", + "covercosine", + "versed cosine", + "coversed", + "cosinus versus", + "covercosinus", + "cvc", + "versed", + "cosine", "cos", - "cosm1", - "cosine" + "sine", + "sin" ], "extra_keywords": [ - "math.cos" + "math.sin" ] }, - "@stdlib/math/base/special/cospif": { + "@stdlib/math/base/special/coversinf": { "$schema": "math/base@v1.0", - "base_alias": "cospi", - "alias": "cospif", - "pkg_desc": "compute `cos(πx)` in single-precision floating-point format", - "desc": "computes `cos(πx)` in single-precision floating-point format", - "short_desc": "cosine", + "base_alias": "coversin", + "alias": "coversinf", + "pkg_desc": "compute the coversed sine of a single-precision floating-point number (in radians)", + "desc": "computes the coversed sine of a single-precision floating-point number (in radians)", + "short_desc": "coversed sine", "parameters": [ { "name": "x", @@ -5428,7 +6546,7 @@ ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "coversed sine", "type": { "javascript": "number", "jsdoc": "number", @@ -5437,29 +6555,35 @@ } }, "keywords": [ - "cos", - "cospif", - "cosine", - "pi", + "coversin", + "coversinf", + "coversine", + "coversed", + "coversinus", + "covers", + "cosiv", + "cvs", + "versed", + "sine", + "sin", "trig", "trigonometry", - "radians" + "radians", + "angle" ], - "extra_keywords": [ - "math.cos" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/cospi": { + "@stdlib/math/base/special/coversin": { "$schema": "math/base@v1.0", - "base_alias": "cospi", - "alias": "cospi", - "pkg_desc": "compute the cosine of a double-precision floating-point number times π", - "desc": "computes the cosine of a double-precision floating-point number times π", - "short_desc": "cosine of a number times π", + "base_alias": "coversin", + "alias": "coversin", + "pkg_desc": "compute the coversed sine (in radians) of a double-precision floating-point number", + "desc": "computes the coversed sine (in radians) of a double-precision floating-point number", + "short_desc": "coversed sine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -5480,32 +6604,32 @@ ] }, "example_values": [ - -3.25, - 0.125, - 1.6, - -0.45, - 2.75, -7.3, - 4.2, - -5.8, - 0, - 9.1, + -5.4, -2.2, - 3.33, - -0.01, - 0.5, - -1.75, - 6.7, - -4.9, - 8.8, - -10.4, - 12.6 + -0.9, + -0.12, + 0, + 0.19, + 0.68, + 1.4, + 2.1, + 3.2, + -1.7, + 4.9, + -3.8, + 6.1, + -4.5, + 8.7, + -9.9, + 10.8, + -11.6 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "result", + "desc": "coversed sine", "type": { "javascript": "number", "jsdoc": "number", @@ -5514,21 +6638,30 @@ } }, "keywords": [ - "cos", - "cosine", - "pi" + "coversin", + "coversine", + "versed sine", + "coversed", + "cosinus versus", + "coversinus", + "covers", + "cosiv", + "cvs", + "versed", + "sine", + "sin" ], "extra_keywords": [ - "math.cos" + "math.sin" ] }, - "@stdlib/math/base/special/cotf": { + "@stdlib/math/base/special/cscf": { "$schema": "math/base@v1.0", - "base_alias": "cot", - "alias": "cotf", - "pkg_desc": "evaluate the cotangent of a single-precision floating-point number (in radians)", - "desc": "evaluates the cotangent of a single-precision floating-point number (in radians)", - "short_desc": "cotangent", + "base_alias": "csc", + "alias": "cscf", + "pkg_desc": "evaluate the cosecant of a single-precision floating-point number (in radians)", + "desc": "evaluates the cosecant of a single-precision floating-point number (in radians)", + "short_desc": "cosecant", "parameters": [ { "name": "x", @@ -5547,42 +6680,42 @@ { "min": 1.4e-45, "max": "infinity" - } - ], - "rand": { - "prng": "random/base/uniform", - "parameters": [ - 0.5, - 50 - ] - }, - "example_values": [ - 4.2, - -13.8, - 0.13, - -21.3, - 14.6, - -7.2, - 29.4, - -33.7, - 2.6, - -9.6, - 0.91, - -1.47, - -26.5, - 7.9, - -18.7, - -11.6, - -16.4, - -5.3, - -12.4, - -8.1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 50 + ] + }, + "example_values": [ + -29.73, + 8.41, + -0.66, + 0.88, + -17.95, + 3.47, + -5.12, + 21.36, + -1.23, + 2.04, + -12.58, + 9.71, + -3.02, + 6.33, + -8.64, + 16.22, + -19.87, + 11.58, + -2.11, + 27.95 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cotangent", + "desc": "cosecant", "type": { "javascript": "number", "jsdoc": "number", @@ -5591,30 +6724,26 @@ } }, "keywords": [ - "cotf", - "cotangent", - "tan", - "tangent", "sin", "sine", - "cos", - "cosine" + "cosec", + "csc" ], "extra_keywords": [ - "math.tan" + "math.sin" ] }, - "@stdlib/math/base/special/cot": { + "@stdlib/math/base/special/csc": { "$schema": "math/base@v1.0", - "base_alias": "cot", - "alias": "cot", - "pkg_desc": "evaluate the cotangent of a double-precision floating-point number (in radians)", - "desc": "evaluates the cotangent of a double-precision floating-point number (in radians)", - "short_desc": "cotangent", + "base_alias": "csc", + "alias": "csc", + "pkg_desc": "evaluate the cosecant of a double-precision floating-point number (in radians)", + "desc": "evaluates the cosecant of a double-precision floating-point number (in radians)", + "short_desc": "cosecant", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -5639,32 +6768,32 @@ ] }, "example_values": [ - 11.37, - -29.07, - 5.47, - -41.83, - 2.73, - 24.13, - -6.74, - 39.72, - -0.64, - 1.19, - -14.62, - 13.64, - -9.51, - 6.88, - -18.46, - 0.53, - -4.38, - 4.11, - -2.27, - 19.82 + -37.41, + 12.86, + -0.77, + 0.69, + -19.23, + 4.03, + -6.58, + 28.17, + -1.42, + 2.61, + -15.37, + 10.92, + -3.84, + 7.46, + -9.73, + 18.65, + -22.09, + 13.74, + -2.53, + 41.28 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cotangent", + "desc": "cosecant", "type": { "javascript": "number", "jsdoc": "number", @@ -5673,26 +6802,22 @@ } }, "keywords": [ - "cot", - "cotangent", - "tan", - "tangent", "sin", "sine", - "cos", - "cosine" + "cosec", + "csc" ], "extra_keywords": [ - "math.tan" + "math.sin" ] }, - "@stdlib/math/base/special/cotd": { + "@stdlib/math/base/special/cscd": { "$schema": "math/base@v1.0", - "base_alias": "cotd", - "alias": "cotd", - "pkg_desc": "evaluate the cotangent of a double-precision floating-point number (in degrees)", - "desc": "evaluates the cotangent of a double-precision floating-point number (in degrees)", - "short_desc": "cotangent", + "base_alias": "cscd", + "alias": "cscd", + "pkg_desc": "compute the cosecant of a double-precision floating-point number (in degrees)", + "desc": "computes the cosecant of a double-precision floating-point number (in degrees)", + "short_desc": "cosecant", "parameters": [ { "name": "x", @@ -5721,32 +6846,32 @@ ] }, "example_values": [ - 34.7, - -112.7, - 146.2, - -22.8, - 73.8, - -176.4, - 0.3, - -101.5, - 59.4, - -171.8, - 16.9, - -44.1, - -139.9, - -7.5, - -67.3, - 112.6, - -150.6, - -81.2, - -163.3, - -126.4 + -171.7, + 13.6, + -0.8, + 0.9, + -122.4, + 7.3, + -35.2, + 146.8, + -11.4, + 22.1, + -78.5, + 96.3, + -43.2, + 68.7, + -159.9, + 51.4, + -117.6, + 33.2, + -26.9, + 173.5 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cotangent", + "desc": "cosecant", "type": { "javascript": "number", "jsdoc": "number", @@ -5755,27 +6880,22 @@ } }, "keywords": [ - "cot", - "cotd", - "cotangent", - "tan", - "tangent", - "sin", - "sine", - "cos", - "cosine" + "acsc", + "cosecant", + "degree", + "sine" ], "extra_keywords": [ - "math.tan" + "math.sin" ] }, - "@stdlib/math/base/special/coth": { + "@stdlib/math/base/special/csch": { "$schema": "math/base@v1.0", - "base_alias": "coth", - "alias": "coth", - "pkg_desc": "compute the hyperbolic cotangent of a double-precision floating-point number", - "desc": "computes the hyperbolic cotangent of a double-precision floating-point number", - "short_desc": "hyperbolic cotangent", + "base_alias": "csch", + "alias": "csch", + "pkg_desc": "compute the hyperbolic cosecant of a double-precision floating-point number", + "desc": "computes the hyperbolic cosecant of a double-precision floating-point number", + "short_desc": "hyperbolic cosecant", "parameters": [ { "name": "x", @@ -5804,32 +6924,32 @@ ] }, "example_values": [ - -23.8, - 17.1, - -0.73, - 0.61, - -12.4, - 3.9, - -7.6, - 26.3, - -1.3, - 2.4, - -15.4, - 10.5, - -4.9, - 7.8, - -9.2, - 18.2, - -21.9, - 12.8, - -2.6, - 0.92 + -23.5, + 17.9, + -0.62, + 0.77, + -12.8, + 3.1, + -5.7, + 26.4, + -1.05, + 2.37, + -9.46, + 8.92, + -2.84, + 6.25, + -7.91, + 14.8, + -18.3, + 11.2, + -2.06, + 29.7 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic cotangent", + "desc": "hyperbolic cosecant", "type": { "javascript": "number", "jsdoc": "number", @@ -5838,29 +6958,27 @@ } }, "keywords": [ - "cotangent", - "cot", - "coth", - "tangent", - "tan", - "tanh", + "csc", + "cosecant", + "sin", + "sine", "hyperbolic" ], "extra_keywords": [ - "math.tanh" + "math.sinh" ] }, - "@stdlib/math/base/special/covercosf": { + "@stdlib/math/base/special/deg2radf": { "$schema": "math/base@v1.0", - "base_alias": "covercos", - "alias": "covercosf", - "pkg_desc": "compute the coversed cosine of a single-precision floating-point number (in radians)", - "desc": "computes the coversed cosine of a single-precision floating-point number (in radians)", - "short_desc": "coversed cosine", + "base_alias": "deg2radf", + "alias": "deg2radf", + "pkg_desc": "convert an angle from degrees to radians", + "desc": "converts an angle from degrees to radians", + "short_desc": "", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "angle in degrees", "type": { "javascript": "number", "jsdoc": "number", @@ -5876,37 +6994,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + -360, + 360 ] }, "example_values": [ - 64, - 27, + -257, 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 131, + -74, + 312, + -289, + 84, + -163, + 27, + -338, + 115, + -49, + 269, + -208, + 58, + -15, + 142, + -319, + 201, + -97 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "coversed cosine", + "desc": "angle in radians", "type": { "javascript": "number", "jsdoc": "number", @@ -5915,36 +7033,25 @@ } }, "keywords": [ - "covercos", - "covercosf", - "covercosin", - "covercosine", - "coversed", - "covercosinus", - "cvc", - "versed", - "cosine", - "cos", - "sine", - "sin", - "trig", - "trigonometry", + "geometry", "radians", - "angle" + "degrees", + "angle", + "convert" ], "extra_keywords": [] }, - "@stdlib/math/base/special/covercos": { + "@stdlib/math/base/special/deg2rad": { "$schema": "math/base@v1.0", - "base_alias": "covercos", - "alias": "covercos", - "pkg_desc": "compute the coversed cosine (in radians) of a double-precision floating-point number", - "desc": "computes the coversed cosine (in radians) of a double-precision floating-point number", - "short_desc": "coversed cosine", + "base_alias": "deg2rad", + "alias": "deg2rad", + "pkg_desc": "convert an angle from degrees to radians", + "desc": "converts an angle from degrees to radians", + "short_desc": "", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "angle in degrees", "type": { "javascript": "number", "jsdoc": "number", @@ -5960,37 +7067,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -50, - 50 + -360, + 360 ] }, "example_values": [ - -6.1, - -3.4, - -1.2, - -0.49, - -0.08, + -213, 0, - 0.27, - 0.95, - 1.7, - 2.3, - 3.6, - -2.9, - 4.8, - -5.7, - 6.9, - -7.8, - 8.4, - -9.6, - 10.3, - -11.1 + 147, + -58, + 339, + -301, + 72, + -149, + 19, + -276, + 95, + -33, + 281, + -194, + 46, + -9, + 128, + -327, + 219, + -85 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "coversed cosine", + "desc": "angle in radians", "type": { "javascript": "number", "jsdoc": "number", @@ -5999,40 +7106,30 @@ } }, "keywords": [ - "covercos", - "covercosin", - "covercosine", - "versed cosine", - "coversed", - "cosinus versus", - "covercosinus", - "cvc", - "versed", - "cosine", - "cos", - "sine", - "sin" + "geometry", + "radians", + "degrees", + "angle", + "convert" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/coversinf": { + "@stdlib/math/base/special/digamma": { "$schema": "math/base@v1.0", - "base_alias": "coversin", - "alias": "coversinf", - "pkg_desc": "compute the coversed sine of a single-precision floating-point number (in radians)", - "desc": "computes the coversed sine of a single-precision floating-point number (in radians)", - "short_desc": "coversed sine", + "base_alias": "digamma", + "alias": "digamma", + "pkg_desc": "evaluate the digamma function for a double-precision floating-point number", + "desc": "evaluates the digamma function for a double-precision floating-point number", + "short_desc": "digamma", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { @@ -6043,169 +7140,158 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + 0.5, + 20 ] }, "example_values": [ - 64, - 27, - 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 0.51, + 1.37, + 2.93, + 4.18, + 7.64, + -2.47, + -1.23, + -3.79, + -0.61, + 5.42, + 9.08, + 12.57, + 15.33, + -4.62, + -6.14, + 18.91, + 10.26, + -5.37, + 3.41, + 0.89 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "coversed sine", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "coversin", - "coversinf", - "coversine", - "coversed", - "coversinus", - "covers", - "cosiv", - "cvs", - "versed", - "sine", - "sin", - "trig", - "trigonometry", - "radians", - "angle" + "derivative", + "gamma", + "digamma", + "scalar", + "number", + "psi" ], "extra_keywords": [] }, - "@stdlib/math/base/special/coversin": { + "@stdlib/math/base/special/dirac-deltaf": { "$schema": "math/base@v1.0", - "base_alias": "coversin", - "alias": "coversin", - "pkg_desc": "compute the coversed sine (in radians) of a double-precision floating-point number", - "desc": "computes the coversed sine (in radians) of a double-precision floating-point number", - "short_desc": "coversed sine", + "base_alias": "diracDeltaf", + "alias": "diracDeltaf", + "pkg_desc": "evaluate the Dirac delta function for a single-precision floating-point number", + "desc": "evaluates the Dirac delta function for a single-precision floating-point number", + "short_desc": "Dirac delta", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { "min": "-infinity", + "max": -1.4e-45 + }, + { + "min": 1.4e-45, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -50, + 0.5, 50 ] }, "example_values": [ - -7.3, - -5.4, - -2.2, - -0.9, - -0.12, - 0, - 0.19, - 0.68, - 1.4, - 2.1, - 3.2, - -1.7, - 4.9, - -3.8, - 6.1, - -4.5, - 8.7, - -9.9, - 10.8, - -11.6 + -28.7, + -10.5, + -0.73, + -1.92, + -7.81, + 0.64, + 1.31, + 3.85, + 9.76, + 18.4, + -4.27, + 6.12, + -16.4, + 24.9, + -21.3, + 13.6, + -1.78, + 35.2, + -11.6, + 7.44 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "coversed sine", + "desc": "result", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "coversin", - "coversine", - "versed sine", - "coversed", - "cosinus versus", - "coversinus", - "covers", - "cosiv", - "cvs", - "versed", - "sine", - "sin" + "dirac", + "delta", + "distribution", + "dist", + "continuous", + "kronecker", + "spike", + "impulse" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/cscf": { + "@stdlib/math/base/special/dirac-delta": { "$schema": "math/base@v1.0", - "base_alias": "csc", - "alias": "cscf", - "pkg_desc": "evaluate the cosecant of a single-precision floating-point number (in radians)", - "desc": "evaluates the cosecant of a single-precision floating-point number (in radians)", - "short_desc": "cosecant", + "base_alias": "diracDelta", + "alias": "diracDelta", + "pkg_desc": "evaluate the Dirac delta function for a double-precision floating-point number", + "desc": "evaluates the Dirac delta function for a double-precision floating-point number", + "short_desc": "Dirac delta", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { "min": "-infinity", - "max": -1.4e-45 + "max": -5e-324 }, { - "min": 1.4e-45, + "min": 5e-324, "max": "infinity" } ], @@ -6217,60 +7303,62 @@ ] }, "example_values": [ - -29.73, - 8.41, - -0.66, - 0.88, - -17.95, - 3.47, - -5.12, - 21.36, - -1.23, - 2.04, - -12.58, - 9.71, - -3.02, - 6.33, - -8.64, - 16.22, - -19.87, - 11.58, - -2.11, - 27.95 + -37.2, + -14.6, + -0.81, + -2.37, + -9.94, + 0.73, + 1.58, + 4.91, + 12.4, + 23.7, + -5.13, + 7.68, + -19.8, + 33.2, + -28.5, + 16.1, + -2.25, + 41.9, + -13.7, + 9.03 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosecant", + "desc": "result", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "sin", - "sine", - "cosec", - "csc" + "dirac", + "delta", + "distribution", + "dist", + "continuous", + "kronecker", + "spike", + "impulse" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/csc": { + "@stdlib/math/base/special/dirichlet-eta": { "$schema": "math/base@v1.0", - "base_alias": "csc", - "alias": "csc", - "pkg_desc": "evaluate the cosecant of a double-precision floating-point number (in radians)", - "desc": "evaluates the cosecant of a double-precision floating-point number (in radians)", - "short_desc": "cosecant", + "base_alias": "eta", + "alias": "eta", + "pkg_desc": "evaluate the Dirichlet eta function for a double-precision floating-point number", + "desc": "evaluates the Dirichlet eta function for a double-precision floating-point number", + "short_desc": "Dirichlet eta", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -6280,47 +7368,43 @@ "domain": [ { "min": "-infinity", - "max": -5e-324 - }, - { - "min": 5e-324, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.5, - 50 + -5, + 5 ] }, "example_values": [ - -37.41, - 12.86, + -4.73, + 3.91, + -2.58, + 1.67, + -0.42, + 0.35, + -1.84, + 4.26, + -3.17, + 2.09, -0.77, - 0.69, - -19.23, - 4.03, - -6.58, - 28.17, - -1.42, - 2.61, - -15.37, - 10.92, - -3.84, - 7.46, - -9.73, - 18.65, - -22.09, - 13.74, - -2.53, - 41.28 + 1.23, + -4.05, + 0.68, + -2.91, + 3.44, + -1.12, + 4.88, + -0.19, + 2.71 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosecant", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -6329,26 +7413,27 @@ } }, "keywords": [ - "sin", - "sine", - "cosec", - "csc" + "eta", + "zeta", + "dirichlet", + "series", + "alternating", + "number", + "number theory" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/cscd": { + "@stdlib/math/base/special/ellipe": { "$schema": "math/base@v1.0", - "base_alias": "cscd", - "alias": "cscd", - "pkg_desc": "compute the cosecant of a double-precision floating-point number (in degrees)", - "desc": "computes the cosecant of a double-precision floating-point number (in degrees)", - "short_desc": "cosecant", + "base_alias": "ellipe", + "alias": "ellipe", + "pkg_desc": "compute the complete elliptic integral of the second kind for a double-precision floating-point number", + "desc": "computes the complete elliptic integral of the second kind for a double-precision floating-point number", + "short_desc": "complete elliptic integral of the second kind", "parameters": [ { - "name": "x", - "desc": "input value (in degrees)", + "name": "m", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -6358,47 +7443,43 @@ "domain": [ { "min": "-infinity", - "max": -5e-324 - }, - { - "min": 5e-324, - "max": "infinity" + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.5, - 180 + -50, + 0.5 ] }, "example_values": [ - -171.7, - 13.6, - -0.8, - 0.9, - -122.4, - 7.3, - -35.2, - 146.8, - -11.4, - 22.1, - -78.5, - 96.3, - -43.2, - 68.7, - -159.9, - 51.4, - -117.6, - 33.2, - -26.9, - 173.5 + -23.74, + 0.42, + -0.81, + -17.56, + -3.29, + -45.91, + -12.67, + 0.07, + -31.58, + -0.13, + -6.94, + -0.47, + -22.11, + -0.26, + -9.83, + -0.05, + -39.62, + -4.37, + -0.68, + -28.45 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "cosecant", + "desc": "evaluated elliptic integral", "type": { "javascript": "number", "jsdoc": "number", @@ -6407,25 +7488,20 @@ } }, "keywords": [ - "acsc", - "cosecant", - "degree", - "sine" + "elliptic" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/csch": { + "@stdlib/math/base/special/ellipk": { "$schema": "math/base@v1.0", - "base_alias": "csch", - "alias": "csch", - "pkg_desc": "compute the hyperbolic cosecant of a double-precision floating-point number", - "desc": "computes the hyperbolic cosecant of a double-precision floating-point number", - "short_desc": "hyperbolic cosecant", + "base_alias": "ellipk", + "alias": "ellipk", + "pkg_desc": "compute the complete elliptic integral of the first kind for a double-precision floating-point number", + "desc": "computes the complete elliptic integral of the first kind for a double-precision floating-point number", + "short_desc": "complete elliptic integral of the first kind", "parameters": [ { - "name": "x", + "name": "m", "desc": "input value", "type": { "javascript": "number", @@ -6436,47 +7512,43 @@ "domain": [ { "min": "-infinity", - "max": -5e-324 - }, - { - "min": 5e-324, - "max": "infinity" + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.5, - 50 + -50, + 0.5 ] }, "example_values": [ - -23.5, - 17.9, - -0.62, - 0.77, - -12.8, - 3.1, - -5.7, - 26.4, - -1.05, - 2.37, - -9.46, - 8.92, - -2.84, - 6.25, - -7.91, - 14.8, - -18.3, - 11.2, - -2.06, - 29.7 + -23.74, + 0.42, + -0.81, + -17.56, + -3.29, + -45.91, + -12.67, + 0.07, + -31.58, + -0.13, + -6.94, + -0.47, + -22.11, + -0.26, + -9.83, + -0.05, + -39.62, + -4.37, + -0.68, + -28.45 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "hyperbolic cosecant", + "desc": "evaluated elliptic integral", "type": { "javascript": "number", "jsdoc": "number", @@ -6485,32 +7557,28 @@ } }, "keywords": [ - "csc", - "cosecant", - "sin", - "sine", - "hyperbolic" + "special", + "elliptic", + "number" ], - "extra_keywords": [ - "math.sinh" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/deg2radf": { + "@stdlib/math/base/special/erf": { "$schema": "math/base@v1.0", - "base_alias": "deg2radf", - "alias": "deg2radf", - "pkg_desc": "convert an angle from degrees to radians", - "desc": "converts an angle from degrees to radians", - "short_desc": "", + "base_alias": "erf", + "alias": "erf", + "pkg_desc": "evaluate the error function for a double-precision floating-point number", + "desc": "evaluates the error function for a double-precision floating-point number", + "short_desc": "error function", "parameters": [ { "name": "x", - "desc": "angle in degrees", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { @@ -6521,64 +7589,62 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -360, - 360 + -5, + 5 ] }, "example_values": [ - -257, - 0, - 131, - -74, - 312, - -289, - 84, - -163, - 27, - -338, - 115, - -49, - 269, - -208, - 58, - -15, - 142, - -319, - 201, - -97 + -3.71, + 2.48, + -1.96, + 0.83, + -0.27, + 1.15, + -4.29, + 3.06, + -2.53, + 4.77, + -0.94, + 0.36, + -1.42, + 2.91, + -3.18, + 1.67, + -4.86, + 0.59, + -2.07, + 4.12 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "angle in radians", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "geometry", - "radians", - "degrees", - "angle", - "convert" + "erf", + "error", + "function" ], "extra_keywords": [] }, - "@stdlib/math/base/special/deg2rad": { + "@stdlib/math/base/special/erfc": { "$schema": "math/base@v1.0", - "base_alias": "deg2rad", - "alias": "deg2rad", - "pkg_desc": "convert an angle from degrees to radians", - "desc": "converts an angle from degrees to radians", - "short_desc": "", + "base_alias": "erfc", + "alias": "erfc", + "pkg_desc": "evaluate the complementary error function for a double-precision floating-point number", + "desc": "evaluates the complementary error function for a double-precision floating-point number", + "short_desc": "complementary error function", "parameters": [ { "name": "x", - "desc": "angle in degrees", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -6594,37 +7660,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -360, - 360 + -5, + 5 ] }, "example_values": [ - -213, - 0, - 147, - -58, - 339, - -301, - 72, - -149, - 19, - -276, - 95, - -33, - 281, - -194, - 46, - -9, - 128, - -327, - 219, - -85 + -3.42, + 2.17, + -1.88, + 0.74, + -0.39, + 1.09, + -4.51, + 3.22, + -2.64, + 4.35, + -0.81, + 0.28, + -1.57, + 2.63, + -3.06, + 1.53, + -4.93, + 0.61, + -2.12, + 4.02 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "angle in radians", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -6633,21 +7699,21 @@ } }, "keywords": [ - "geometry", - "radians", - "degrees", - "angle", - "convert" + "erf", + "erfc", + "complementary", + "error", + "function" ], "extra_keywords": [] }, - "@stdlib/math/base/special/digamma": { + "@stdlib/math/base/special/erfcinv": { "$schema": "math/base@v1.0", - "base_alias": "digamma", - "alias": "digamma", - "pkg_desc": "evaluate the digamma function for a double-precision floating-point number", - "desc": "evaluates the digamma function for a double-precision floating-point number", - "short_desc": "digamma", + "base_alias": "erfcinv", + "alias": "erfcinv", + "pkg_desc": "evaluate the inverse complementary error function for a double-precision floating-point number", + "desc": "evaluates the inverse complementary error function for a double-precision floating-point number", + "short_desc": "inverse complementary error function", "parameters": [ { "name": "x", @@ -6660,38 +7726,38 @@ }, "domain": [ { - "min": "-infinity", - "max": "infinity" + "min": 0, + "max": 2 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.5, - 20 + 0.1, + 1.8 ] }, "example_values": [ - 0.51, - 1.37, - 2.93, - 4.18, - 7.64, - -2.47, - -1.23, - -3.79, - -0.61, - 5.42, - 9.08, - 12.57, - 15.33, - -4.62, - -6.14, - 18.91, - 10.26, - -5.37, - 3.41, - 0.89 + 0.041, + 1.372, + 0.885, + 1.743, + 0.219, + 1.948, + 0.637, + 1.156, + 0.302, + 1.821, + 0.517, + 1.064, + 0.771, + 0.126, + 1.593, + 0.948, + 1.287, + 0.359, + 1.912, + 0.684 ] } ], @@ -6706,22 +7772,24 @@ } }, "keywords": [ - "derivative", - "gamma", - "digamma", - "scalar", - "number", - "psi" + "erf", + "erfc", + "erfinv", + "erfcinv", + "inverse", + "complementary", + "error", + "function" ], "extra_keywords": [] }, - "@stdlib/math/base/special/dirac-deltaf": { + "@stdlib/math/base/special/erfcx": { "$schema": "math/base@v1.0", - "base_alias": "diracDeltaf", - "alias": "diracDeltaf", - "pkg_desc": "evaluate the Dirac delta function for a single-precision floating-point number", - "desc": "evaluates the Dirac delta function for a single-precision floating-point number", - "short_desc": "Dirac delta", + "base_alias": "erfcx", + "alias": "erfcx", + "pkg_desc": "evaluate the scaled complementary error function for a double-precision floating-point number", + "desc": "evaluates the scaled complementary error function for a double-precision floating-point number", + "short_desc": "scaled complementary error function", "parameters": [ { "name": "x", @@ -6729,79 +7797,73 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { "min": "-infinity", - "max": -1.4e-45 - }, - { - "min": 1.4e-45, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.5, - 50 + -5, + 5 ] }, "example_values": [ - -28.7, - -10.5, - -0.73, - -1.92, - -7.81, - 0.64, - 1.31, - 3.85, - 9.76, - 18.4, - -4.27, - 6.12, - -16.4, - 24.9, - -21.3, - 13.6, - -1.78, - 35.2, - -11.6, - 7.44 + -3.28, + 2.06, + -1.73, + 0.91, + -0.48, + 1.23, + -4.17, + 3.51, + -2.36, + 4.62, + -0.69, + 0.17, + -1.29, + 2.78, + -3.41, + 1.62, + -4.84, + 0.57, + -2.24, + 3.98 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "result", + "desc": "evaluated scaled complementary error function", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "dirac", - "delta", - "distribution", - "dist", - "continuous", - "kronecker", - "spike", - "impulse" + "erfc", + "erfcx", + "complementary", + "error", + "function", + "scaled" ], "extra_keywords": [] }, - "@stdlib/math/base/special/dirac-delta": { + "@stdlib/math/base/special/erfinv": { "$schema": "math/base@v1.0", - "base_alias": "diracDelta", - "alias": "diracDelta", - "pkg_desc": "evaluate the Dirac delta function for a double-precision floating-point number", - "desc": "evaluates the Dirac delta function for a double-precision floating-point number", - "short_desc": "Dirac delta", + "base_alias": "erfinv", + "alias": "erfinv", + "pkg_desc": "evaluate the inverse error function for a double-precision floating-point number", + "desc": "evaluates the inverse error function for a double-precision floating-point number", + "short_desc": "inverse error function", "parameters": [ { "name": "x", @@ -6814,74 +7876,66 @@ }, "domain": [ { - "min": "-infinity", - "max": -5e-324 - }, - { - "min": 5e-324, - "max": "infinity" + "min": -1, + "max": 1 } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0.5, - 50 + -0.9, + 0.75 ] }, "example_values": [ - -37.2, - -14.6, - -0.81, - -2.37, - -9.94, - 0.73, - 1.58, - 4.91, - 12.4, - 23.7, - -5.13, - 7.68, - -19.8, - 33.2, - -28.5, - 16.1, - -2.25, - 41.9, - -13.7, - 9.03 + -0.841, + 0.736, + -0.512, + 0.183, + -0.927, + 0.264, + -0.376, + 0.918, + -0.152, + 0.587, + -0.698, + 0.311, + -0.045, + 0.829, + -0.619, + 0.472, + -0.298, + 0.105, + -0.771, + 0.946 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "result", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", "c": "double", "dtype": "float64" - } - }, - "keywords": [ - "dirac", - "delta", - "distribution", - "dist", - "continuous", - "kronecker", - "spike", - "impulse" + } + }, + "keywords": [ + "erf", + "erfinv", + "inverse", + "error" ], "extra_keywords": [] }, - "@stdlib/math/base/special/dirichlet-eta": { + "@stdlib/math/base/special/exp": { "$schema": "math/base@v1.0", - "base_alias": "eta", - "alias": "eta", - "pkg_desc": "evaluate the Dirichlet eta function for a double-precision floating-point number", - "desc": "evaluates the Dirichlet eta function for a double-precision floating-point number", - "short_desc": "Dirichlet eta", + "base_alias": "exp", + "alias": "exp", + "pkg_desc": "evaluate the natural exponential function", + "desc": "evaluates the natural exponential function", + "short_desc": "natural exponential function", "parameters": [ { "name": "x", @@ -6901,35 +7955,34 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -5, - 5 + -10, + 10 ] }, "example_values": [ - -4.73, - 3.91, - -2.58, - 1.67, - -0.42, - 0.35, - -1.84, - 4.26, - -3.17, - 2.09, - -0.77, - 1.23, - -4.05, - 0.68, - -2.91, - 3.44, - -1.12, - 4.88, - -0.19, - 2.71 + -1.2, + 2, + -3.1, + -4.7, + 5.5, + 6.7, + 8.9, + -10.2, + 11.3, + -12.4, + 13.5, + 14.6, + -15.7, + 16.8, + -17.9, + 18.1, + -19.11, + 20.12, + -21.15, + 23.78 ] } ], - "output_policy": "real_floating_point_and_generic", "returns": { "desc": "function value", "type": { @@ -6940,26 +7993,26 @@ } }, "keywords": [ - "eta", - "zeta", - "dirichlet", - "series", - "alternating", - "number", - "number theory" + "natural", + "exponential", + "exp", + "power" ], - "extra_keywords": [] + "extra_keywords": [ + "math.exp" + ] }, - "@stdlib/math/base/special/ellipe": { + "@stdlib/math/base/special/cexp": {}, + "@stdlib/math/base/special/exp10": { "$schema": "math/base@v1.0", - "base_alias": "ellipe", - "alias": "ellipe", - "pkg_desc": "compute the complete elliptic integral of the second kind for a double-precision floating-point number", - "desc": "computes the complete elliptic integral of the second kind for a double-precision floating-point number", - "short_desc": "complete elliptic integral of the second kind", + "base_alias": "exp10", + "alias": "exp10", + "pkg_desc": "evaluate the base 10 exponential function for a double-precision floating-point number", + "desc": "evaluates the base 10 exponential function for a double-precision floating-point number", + "short_desc": "base 10 exponential function", "parameters": [ { - "name": "m", + "name": "x", "desc": "input value", "type": { "javascript": "number", @@ -6970,43 +8023,43 @@ "domain": [ { "min": "-infinity", - "max": 1 + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -50, - 0.5 + -3, + 3 ] }, "example_values": [ - -23.74, - 0.42, - -0.81, - -17.56, - -3.29, - -45.91, - -12.67, + -2.87, + 1.94, + -1.23, + 0.58, + -0.41, + 2.31, + -2.19, 0.07, - -31.58, - -0.13, - -6.94, - -0.47, - -22.11, - -0.26, - -9.83, - -0.05, - -39.62, - -4.37, - -0.68, - -28.45 + 1.46, + -0.85, + 2.79, + -1.61, + 0.92, + -2.53, + 1.17, + -0.12, + 2.04, + -2.98, + 0.36, + 2.68 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "evaluated elliptic integral", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -7015,20 +8068,27 @@ } }, "keywords": [ - "elliptic" + "exp", + "exp10", + "base 10", + "exponential", + "euler", + "power" ], - "extra_keywords": [] + "extra_keywords": [ + "math.exp" + ] }, - "@stdlib/math/base/special/ellipk": { + "@stdlib/math/base/special/exp2": { "$schema": "math/base@v1.0", - "base_alias": "ellipk", - "alias": "ellipk", - "pkg_desc": "compute the complete elliptic integral of the first kind for a double-precision floating-point number", - "desc": "computes the complete elliptic integral of the first kind for a double-precision floating-point number", - "short_desc": "complete elliptic integral of the first kind", + "base_alias": "exp2", + "alias": "exp2", + "pkg_desc": "evaluate the base 2 exponential function for a double-precision floating-point number", + "desc": "evaluates the base 2 exponential function for a double-precision floating-point number", + "short_desc": "base 2 exponential function", "parameters": [ { - "name": "m", + "name": "x", "desc": "input value", "type": { "javascript": "number", @@ -7039,43 +8099,43 @@ "domain": [ { "min": "-infinity", - "max": 1 + "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -50, - 0.5 + -5, + 5 ] }, "example_values": [ - -23.74, - 0.42, - -0.81, - -17.56, - -3.29, - -45.91, - -12.67, - 0.07, - -31.58, - -0.13, - -6.94, - -0.47, - -22.11, - -0.26, - -9.83, - -0.05, - -39.62, + -4.62, + 3.17, + -2.41, + 1.28, + -0.73, + 2.56, + -3.09, + 0.41, + 4.12, + -1.85, + 2.93, -4.37, - -0.68, - -28.45 + 1.67, + -0.28, + 3.74, + -2.96, + 0.83, + -1.12, + 4.89, + -3.51 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "evaluated elliptic integral", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -7084,19 +8144,25 @@ } }, "keywords": [ - "special", - "elliptic", - "number" + "exp", + "exp2", + "base 2", + "natural", + "exponential", + "euler", + "power" ], - "extra_keywords": [] + "extra_keywords": [ + "math.exp" + ] }, - "@stdlib/math/base/special/erf": { + "@stdlib/math/base/special/expit": { "$schema": "math/base@v1.0", - "base_alias": "erf", - "alias": "erf", - "pkg_desc": "evaluate the error function for a double-precision floating-point number", - "desc": "evaluates the error function for a double-precision floating-point number", - "short_desc": "error function", + "base_alias": "expit", + "alias": "expit", + "pkg_desc": "evaluate the standard logistic function for a double-precision floating-point number", + "desc": "evaluates the standard logistic function for a double-precision floating-point number", + "short_desc": "standard logistic function", "parameters": [ { "name": "x", @@ -7117,30 +8183,30 @@ "prng": "random/base/uniform", "parameters": [ -5, - 5 - ] - }, - "example_values": [ - -3.71, - 2.48, - -1.96, - 0.83, - -0.27, - 1.15, - -4.29, - 3.06, - -2.53, - 4.77, - -0.94, - 0.36, - -1.42, - 2.91, - -3.18, + 5 + ] + }, + "example_values": [ + -4.62, + 3.17, + -2.41, + 1.28, + -0.73, + 2.56, + -3.09, + 0.41, + 4.12, + -1.85, + 2.93, + -4.37, 1.67, - -4.86, - 0.59, - -2.07, - 4.12 + -0.28, + 3.74, + -2.96, + 0.83, + -1.12, + 4.89, + -3.51 ] } ], @@ -7155,19 +8221,27 @@ } }, "keywords": [ - "erf", - "error", - "function" + "logit", + "inverse", + "expit", + "logistic", + "proportion", + "log-odds", + "sigmoid" ], - "extra_keywords": [] + "extra_keywords": [ + "math.exp" + ] }, - "@stdlib/math/base/special/erfc": { + "@stdlib/math/base/special/expm1": {}, + "@stdlib/math/base/special/expm1rel": {}, + "@stdlib/math/base/special/factorial": { "$schema": "math/base@v1.0", - "base_alias": "erfc", - "alias": "erfc", - "pkg_desc": "evaluate the complementary error function for a double-precision floating-point number", - "desc": "evaluates the complementary error function for a double-precision floating-point number", - "short_desc": "complementary error function", + "base_alias": "factorial", + "alias": "factorial", + "pkg_desc": "compute the factorial", + "desc": "computes the factorial", + "short_desc": "factorial", "parameters": [ { "name": "x", @@ -7180,44 +8254,44 @@ }, "domain": [ { - "min": "-infinity", + "min": 0, "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - -5, - 5 + 0, + 100 ] }, "example_values": [ - -3.42, - 2.17, - -1.88, - 0.74, - -0.39, - 1.09, - -4.51, - 3.22, - -2.64, - 4.35, - -0.81, - 0.28, - -1.57, - 2.63, - -3.06, - 1.53, - -4.93, - 0.61, - -2.12, - 4.02 + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 21, + 34, + 99 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "factorial", "type": { "javascript": "number", "jsdoc": "number", @@ -7226,21 +8300,18 @@ } }, "keywords": [ - "erf", - "erfc", - "complementary", - "error", - "function" + "factorial", + "fact" ], "extra_keywords": [] }, - "@stdlib/math/base/special/erfcinv": { + "@stdlib/math/base/special/factorial2f": { "$schema": "math/base@v1.0", - "base_alias": "erfcinv", - "alias": "erfcinv", - "pkg_desc": "evaluate the inverse complementary error function for a double-precision floating-point number", - "desc": "evaluates the inverse complementary error function for a double-precision floating-point number", - "short_desc": "inverse complementary error function", + "base_alias": "factorial2", + "alias": "factorial2f", + "pkg_desc": "compute the double factorial", + "desc": "computes the double factorial", + "short_desc": "double factorial", "parameters": [ { "name": "x", @@ -7248,75 +8319,71 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { "min": 0, - "max": 2 + "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - 0.1, - 1.8 + 0, + 100 ] }, "example_values": [ - 0.041, - 1.372, - 0.885, - 1.743, - 0.219, - 1.948, - 0.637, - 1.156, - 0.302, - 1.821, - 0.517, - 1.064, - 0.771, - 0.126, - 1.593, - 0.948, - 1.287, - 0.359, - 1.912, - 0.684 + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "double factorial", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "erf", - "erfc", - "erfinv", - "erfcinv", - "inverse", - "complementary", - "error", - "function" + "factorial2f", + "dfact", + "factorial", + "combinatorics" ], "extra_keywords": [] }, - "@stdlib/math/base/special/erfcx": { + "@stdlib/math/base/special/factorial2": { "$schema": "math/base@v1.0", - "base_alias": "erfcx", - "alias": "erfcx", - "pkg_desc": "evaluate the scaled complementary error function for a double-precision floating-point number", - "desc": "evaluates the scaled complementary error function for a double-precision floating-point number", - "short_desc": "scaled complementary error function", + "base_alias": "factorial2", + "alias": "factorial2", + "pkg_desc": "compute the double factorial", + "desc": "computes the double factorial", + "short_desc": "double factorial", "parameters": [ { "name": "x", @@ -7329,44 +8396,44 @@ }, "domain": [ { - "min": "-infinity", + "min": 0, "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - -5, - 5 + 0, + 100 ] }, "example_values": [ - -3.28, - 2.06, - -1.73, - 0.91, - -0.48, - 1.23, - -4.17, - 3.51, - -2.36, - 4.62, - -0.69, - 0.17, - -1.29, - 2.78, - -3.41, - 1.62, - -4.84, - 0.57, - -2.24, - 3.98 + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "evaluated scaled complementary error function", + "desc": "double factorial", "type": { "javascript": "number", "jsdoc": "number", @@ -7375,22 +8442,21 @@ } }, "keywords": [ - "erfc", - "erfcx", - "complementary", - "error", - "function", - "scaled" + "factorial2", + "dfact", + "factorial", + "combinatorics" ], "extra_keywords": [] }, - "@stdlib/math/base/special/erfinv": { + "@stdlib/math/base/special/factoriallnf": {}, + "@stdlib/math/base/special/factorialln": { "$schema": "math/base@v1.0", - "base_alias": "erfinv", - "alias": "erfinv", - "pkg_desc": "evaluate the inverse error function for a double-precision floating-point number", - "desc": "evaluates the inverse error function for a double-precision floating-point number", - "short_desc": "inverse error function", + "base_alias": "factorialln", + "alias": "factorialln", + "pkg_desc": "compute the natural logarithm of the factorial function", + "desc": "computes the natural logarithm of the factorial function", + "short_desc": "natural logarithm of the factorial function", "parameters": [ { "name": "x", @@ -7403,44 +8469,44 @@ }, "domain": [ { - "min": -1, - "max": 1 + "min": 0, + "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - -0.9, - 0.75 + 0, + 100 ] }, "example_values": [ - -0.841, - 0.736, - -0.512, - 0.183, - -0.927, - 0.264, - -0.376, - 0.918, - -0.152, - 0.587, - -0.698, - 0.311, - -0.045, - 0.829, - -0.619, - 0.472, - -0.298, - 0.105, - -0.771, - 0.946 + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 93, + 95, + 96, + 97, + 98, + 99 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "result", "type": { "javascript": "number", "jsdoc": "number", @@ -7449,20 +8515,23 @@ } }, "keywords": [ - "erf", - "erfinv", - "inverse", - "error" + "factorialln", + "lfact", + "fact", + "factorial", + "gamma", + "combinatorics" ], "extra_keywords": [] }, - "@stdlib/math/base/special/exp": { + "@stdlib/math/base/special/fibonaccif": {}, + "@stdlib/math/base/special/fibonacci": { "$schema": "math/base@v1.0", - "base_alias": "exp", - "alias": "exp", - "pkg_desc": "evaluate the natural exponential function", - "desc": "evaluates the natural exponential function", - "short_desc": "natural exponential function", + "base_alias": "fibonacci", + "alias": "fibonacci", + "pkg_desc": "compute the nth Fibonacci number", + "desc": "computes the nth Fibonacci number", + "short_desc": "fibonacci number", "parameters": [ { "name": "x", @@ -7475,43 +8544,45 @@ }, "domain": [ { - "min": "-infinity", + "min": 0, "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - -10, - 10 + 0, + 100 ] }, "example_values": [ - -1.2, + 1, 2, - -3.1, - -4.7, - 5.5, - 6.7, - 8.9, - -10.2, - 11.3, - -12.4, - 13.5, - 14.6, - -15.7, - 16.8, - -17.9, - 18.1, - -19.11, - 20.12, - -21.15, - 23.78 + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 21, + 34, + 41, + 55 ] } ], + "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "fibonacci number", "type": { "javascript": "number", "jsdoc": "number", @@ -7520,32 +8591,45 @@ } }, "keywords": [ - "natural", - "exponential", - "exp", - "power" + "fibonacci", + "fib" ], - "extra_keywords": [ - "math.exp" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/cexp": {}, - "@stdlib/math/base/special/exp10": { + "@stdlib/math/base/special/fibonacci-indexf": {}, + "@stdlib/math/base/special/fibonacci-index": {}, + "@stdlib/math/base/special/floorf": {}, + "@stdlib/math/base/special/floor": {}, + "@stdlib/math/base/special/cfloorf": {}, + "@stdlib/math/base/special/cfloor": {}, + "@stdlib/math/base/special/floor10": {}, + "@stdlib/math/base/special/floor2": {}, + "@stdlib/math/base/special/fresnel": {}, + "@stdlib/math/base/special/fresnelc": {}, + "@stdlib/math/base/special/fresnels": {}, + "@stdlib/math/base/special/gamma": {}, + "@stdlib/math/base/special/gamma-lanczos-sum": {}, + "@stdlib/math/base/special/gamma-lanczos-sum-expg-scaledf": {}, + "@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled": {}, + "@stdlib/math/base/special/gamma1pm1": {}, + "@stdlib/math/base/special/gammasgnf": {}, + "@stdlib/math/base/special/gammasgn": {}, + "@stdlib/math/base/special/hacovercosf": { "$schema": "math/base@v1.0", - "base_alias": "exp10", - "alias": "exp10", - "pkg_desc": "evaluate the base 10 exponential function for a double-precision floating-point number", - "desc": "evaluates the base 10 exponential function for a double-precision floating-point number", - "short_desc": "base 10 exponential function", + "base_alias": "hacovercos", + "alias": "hacovercosf", + "pkg_desc": "compute the half-value coversed cosine", + "desc": "computes the half-value coversed cosine", + "short_desc": "half-value coversed cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { @@ -7556,72 +8640,84 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -3, - 3 + -10, + 10 ] }, "example_values": [ - -2.87, - 1.94, - -1.23, - 0.58, - -0.41, - 2.31, - -2.19, - 0.07, - 1.46, - -0.85, - 2.79, - -1.61, - 0.92, - -2.53, - 1.17, - -0.12, - 2.04, - -2.98, - 0.36, - 2.68 + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "half-value coversed cosine", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "exp", - "exp10", - "base 10", - "exponential", - "euler", - "power" + "hacovercos", + "hacovercosf", + "hacovercosin", + "hacovercosine", + "versed cosine", + "half-value", + "coversed", + "cosinus versus", + "hacovercosinus", + "hcc", + "versed", + "cosine", + "cos", + "sine", + "sin", + "trig", + "trigonometry", + "radians", + "angle" ], - "extra_keywords": [ - "math.exp" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/exp2": { + "@stdlib/math/base/special/hacovercos": {}, + "@stdlib/math/base/special/hacoversinf": { "$schema": "math/base@v1.0", - "base_alias": "exp2", - "alias": "exp2", - "pkg_desc": "evaluate the base 2 exponential function for a double-precision floating-point number", - "desc": "evaluates the base 2 exponential function for a double-precision floating-point number", - "short_desc": "base 2 exponential function", + "base_alias": "hacoversin", + "alias": "hacoversinf", + "pkg_desc": "compute the half-value coversed sine", + "desc": "computes the half-value coversed sine", + "short_desc": "half-value coversed sine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { @@ -7632,73 +8728,84 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -5, - 5 + -10, + 10 ] }, "example_values": [ - -4.62, - 3.17, - -2.41, - 1.28, - -0.73, - 2.56, - -3.09, - 0.41, - 4.12, - -1.85, - 2.93, - -4.37, - 1.67, - -0.28, - 3.74, - -2.96, - 0.83, - -1.12, - 4.89, - -3.51 + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "half-value coversed sine", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "exp", - "exp2", - "base 2", - "natural", - "exponential", - "euler", - "power" + "hacoversin", + "hacoversinf", + "hacoversine", + "versed sine", + "half-value", + "coversed", + "sinus versus", + "hacoversinus", + "hcv", + "hacov", + "semicoversin", + "cohaversine", + "versed", + "sine", + "sin", + "trig", + "trigonometry", + "radians", + "angle" ], - "extra_keywords": [ - "math.exp" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/expit": { + "@stdlib/math/base/special/hacoversin": {}, + "@stdlib/math/base/special/havercosf": { "$schema": "math/base@v1.0", - "base_alias": "expit", - "alias": "expit", - "pkg_desc": "evaluate the standard logistic function for a double-precision floating-point number", - "desc": "evaluates the standard logistic function for a double-precision floating-point number", - "short_desc": "standard logistic function", + "base_alias": "havercos", + "alias": "havercosf", + "pkg_desc": "compute the half-value versed cosine", + "desc": "computes the half-value versed cosine", + "short_desc": "half-value versed cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { @@ -7709,70 +8816,73 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -5, - 5 + -10, + 10 ] }, "example_values": [ - -4.62, - 3.17, - -2.41, - 1.28, - -0.73, - 2.56, - -3.09, - 0.41, - 4.12, - -1.85, - 2.93, - -4.37, - 1.67, - -0.28, - 3.74, - -2.96, - 0.83, - -1.12, - 4.89, - -3.51 + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "half-value versed cosine", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "logit", - "inverse", - "expit", - "logistic", - "proportion", - "log-odds", - "sigmoid" + "havercos", + "havercosf", + "havercosin", + "havercosine", + "versed", + "haversed", + "hac", + "hvc", + "cosine", + "cos", + "trig", + "trigonometry", + "radians", + "angle" ], - "extra_keywords": [ - "math.exp" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/expm1": {}, - "@stdlib/math/base/special/expm1rel": {}, - "@stdlib/math/base/special/factorial": { + "@stdlib/math/base/special/havercos": { "$schema": "math/base@v1.0", - "base_alias": "factorial", - "alias": "factorial", - "pkg_desc": "compute the factorial", - "desc": "computes the factorial", - "short_desc": "factorial", + "base_alias": "havercos", + "alias": "havercos", + "pkg_desc": "compute the half-value versed cosine", + "desc": "computes the half-value versed cosine", + "short_desc": "half-value versed cosine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -7781,44 +8891,44 @@ }, "domain": [ { - "min": 0, + "min": "-infinity", "max": "infinity" } ], "rand": { - "prng": "random/base/discrete-uniform", + "prng": "random/base/uniform", "parameters": [ - 0, - 100 + -10, + 10 ] }, - "example_values": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 21, - 34, - 99 + "example_values": [ + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "factorial", + "desc": "half-value versed cosine", "type": { "javascript": "number", "jsdoc": "number", @@ -7827,22 +8937,32 @@ } }, "keywords": [ - "factorial", - "fact" + "havercos", + "havercosin", + "havercosine", + "haversed", + "hac", + "hvc", + "cosine", + "cos", + "trig", + "trigonometry", + "radians", + "angle" ], "extra_keywords": [] }, - "@stdlib/math/base/special/factorial2f": { + "@stdlib/math/base/special/haversinf": { "$schema": "math/base@v1.0", - "base_alias": "factorial2", - "alias": "factorial2f", - "pkg_desc": "compute the double factorial", - "desc": "computes the double factorial", - "short_desc": "double factorial", + "base_alias": "haversin", + "alias": "haversinf", + "pkg_desc": "compute the half-value versed sine", + "desc": "computes the half-value versed sine", + "short_desc": "half-value versed sine", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -7851,44 +8971,44 @@ }, "domain": [ { - "min": 0, + "min": "-infinity", "max": "infinity" } ], "rand": { - "prng": "random/base/discrete-uniform", + "prng": "random/base/uniform", "parameters": [ - 0, - 100 + -10, + 10 ] }, "example_values": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, + 64, + 27, + 0, + 0.1, + -9, 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 18, - 19, - 20 + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "double factorial", + "desc": "half-value versed sine", "type": { "javascript": "number", "jsdoc": "number", @@ -7897,20 +9017,47 @@ } }, "keywords": [ - "factorial2f", - "dfact", - "factorial", - "combinatorics" + "haversin", + "haversinf", + "haversine", + "haversed", + "hv", + "hvs", + "sem", + "havers", + "semiversinus", + "semiversin", + "semiversus", + "cosine", + "sine", + "cos", + "sin", + "trig", + "trigonometry", + "radians", + "angle" ], "extra_keywords": [] }, - "@stdlib/math/base/special/factorial2": { + "@stdlib/math/base/special/haversin": {}, + "@stdlib/math/base/special/invf": {}, + "@stdlib/math/base/special/inv": {}, + "@stdlib/math/base/special/cinvf": {}, + "@stdlib/math/base/special/cinv": {}, + "@stdlib/math/base/special/lnf": {}, + "@stdlib/math/base/special/ln": {}, + "@stdlib/math/base/special/log10": {}, + "@stdlib/math/base/special/log1mexp": {}, + "@stdlib/math/base/special/log1p": {}, + "@stdlib/math/base/special/log1pexp": {}, + "@stdlib/math/base/special/log1pmx": {}, + "@stdlib/math/base/special/log2": { "$schema": "math/base@v1.0", - "base_alias": "factorial2", - "alias": "factorial2", - "pkg_desc": "compute the double factorial", - "desc": "computes the double factorial", - "short_desc": "double factorial", + "base_alias": "log2", + "alias": "log2", + "pkg_desc": "compute the binary logarithm", + "desc": "computes the binary logarithm", + "short_desc": "binary logarithm", "parameters": [ { "name": "x", @@ -7928,39 +9075,39 @@ } ], "rand": { - "prng": "random/base/discrete-uniform", + "prng": "random/base/uniform", "parameters": [ 0, 100 ] }, "example_values": [ + 0, + 0.01, + 0.25, + 0.5, 1, 2, 3, 4, - 5, - 6, - 7, - 8, 9, - 10, - 11, - 12, - 13, - 14, - 15, 16, - 17, - 18, - 19, - 20 + 25, + 36, + 49, + 64, + 81, + 100, + 0.1, + 10, + 50, + 99.99 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "double factorial", + "desc": "binary logarithm", "type": { "javascript": "number", "jsdoc": "number", @@ -7969,21 +9116,44 @@ } }, "keywords": [ - "factorial2", - "dfact", - "factorial", - "combinatorics" + "logarithm", + "log2", + "binary", + "base 2", + "log" ], - "extra_keywords": [] + "extra_keywords": [ + "math.log2" + ] }, - "@stdlib/math/base/special/factoriallnf": {}, - "@stdlib/math/base/special/factorialln": { + "@stdlib/math/base/special/logitf": {}, + "@stdlib/math/base/special/logit": {}, + "@stdlib/math/base/special/lucasf": {}, + "@stdlib/math/base/special/lucas": {}, + "@stdlib/math/base/special/negafibonaccif": {}, + "@stdlib/math/base/special/negafibonacci": {}, + "@stdlib/math/base/special/negalucasf": {}, + "@stdlib/math/base/special/negalucas": {}, + "@stdlib/math/base/special/nonfibonaccif": {}, + "@stdlib/math/base/special/nonfibonacci": {}, + "@stdlib/math/base/special/rad2degf": {}, + "@stdlib/math/base/special/rad2deg": {}, + "@stdlib/math/base/special/rampf": {}, + "@stdlib/math/base/special/ramp": {}, + "@stdlib/math/base/special/rcbrtf": {}, + "@stdlib/math/base/special/rcbrt": {}, + "@stdlib/math/base/special/riemann-zeta": {}, + "@stdlib/math/base/special/roundf": {}, + "@stdlib/math/base/special/round": {}, + "@stdlib/math/base/special/croundf": {}, + "@stdlib/math/base/special/cround": {}, + "@stdlib/math/base/special/round-nearest-even": { "$schema": "math/base@v1.0", - "base_alias": "factorialln", - "alias": "factorialln", - "pkg_desc": "compute the natural logarithm of the factorial function", - "desc": "computes the natural logarithm of the factorial function", - "short_desc": "natural logarithm of the factorial function", + "base_alias": "roundNearestEven", + "alias": "roundNearestEven", + "pkg_desc": "round to the nearest integer with ties rounding to the nearest even integer", + "desc": "rounds to the nearest integer with ties rounding to the nearest even integer", + "short_desc": "rounds to nearest integer", "parameters": [ { "name": "x", @@ -7996,44 +9166,44 @@ }, "domain": [ { - "min": 0, + "min": "-infinity", "max": "infinity" } ], "rand": { - "prng": "random/base/discrete-uniform", + "prng": "random/base/uniform", "parameters": [ - 0, - 100 + -10, + 10 ] }, "example_values": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 93, - 95, - 96, - 97, - 98, - 99 + 64, + 27, + 0, + 0.1, + -9, + 8, + -1, + 125, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], - "output_policy": "real_floating_point_and_generic", + "output_policy": "same", "returns": { - "desc": "result", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -8042,27 +9212,33 @@ } }, "keywords": [ - "factorialln", - "lfact", - "fact", - "factorial", - "gamma", - "combinatorics" + "round", + "round-nearest-even", + "round-nearest", + "integer", + "nearest", + "number" ], - "extra_keywords": [] + "extra_keywords": [ + "math.round" + ] }, - "@stdlib/math/base/special/fibonaccif": {}, - "@stdlib/math/base/special/fibonacci": { + "@stdlib/math/base/special/round10": {}, + "@stdlib/math/base/special/round2": {}, + "@stdlib/math/base/special/rsqrtf": {}, + "@stdlib/math/base/special/rsqrt": {}, + "@stdlib/math/base/special/secf": {}, + "@stdlib/math/base/special/sec": { "$schema": "math/base@v1.0", - "base_alias": "fibonacci", - "alias": "fibonacci", - "pkg_desc": "compute the nth Fibonacci number", - "desc": "computes the nth Fibonacci number", - "short_desc": "fibonacci number", + "base_alias": "sec", + "alias": "sec", + "pkg_desc": "compute the secant", + "desc": "computes the secant", + "short_desc": "secant", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in radians)", "type": { "javascript": "number", "jsdoc": "number", @@ -8071,45 +9247,44 @@ }, "domain": [ { - "min": 0, + "min": "-infinity", "max": "infinity" } ], "rand": { - "prng": "random/base/discrete-uniform", + "prng": "random/base/uniform", "parameters": [ - 0, - 100 + -10, + 10 ] }, "example_values": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 21, - 34, - 41, - 55 + 0, + 0.5236, + 0.7854, + 1.5708, + 1.0472, + 2.3562, + 3.1416, + 4.7124, + 6.2832, + -0.5236, + -0.7854, + -1.0472, + -1.5708, + -2.3562, + -3.1416, + 7.854, + -7.854, + 0.1, + -0.1, + 3.5 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "fibonacci number", + "desc": "secant", "type": { "javascript": "number", "jsdoc": "number", @@ -8118,36 +9293,31 @@ } }, "keywords": [ - "fibonacci", - "fib" + "sec", + "secant", + "trig", + "trigonometry", + "cos", + "cosine" ], - "extra_keywords": [] + "extra_keywords": [ + "math.sec", + "math.cos" + ] }, - "@stdlib/math/base/special/fibonacci-indexf": {}, - "@stdlib/math/base/special/fibonacci-index": {}, - "@stdlib/math/base/special/floorf": {}, - "@stdlib/math/base/special/floor": {}, - "@stdlib/math/base/special/cfloorf": {}, - "@stdlib/math/base/special/cfloor": {}, - "@stdlib/math/base/special/floor10": {}, - "@stdlib/math/base/special/floor2": {}, - "@stdlib/math/base/special/fresnel": {}, - "@stdlib/math/base/special/fresnelc": {}, - "@stdlib/math/base/special/fresnels": {}, - "@stdlib/math/base/special/gamma": {}, - "@stdlib/math/base/special/gamma-lanczos-sum": {}, - "@stdlib/math/base/special/gamma-lanczos-sum-expg-scaledf": {}, - "@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled": {}, - "@stdlib/math/base/special/gamma1pm1": {}, - "@stdlib/math/base/special/gammasgnf": {}, - "@stdlib/math/base/special/gammasgn": {}, - "@stdlib/math/base/special/hacovercosf": { + "@stdlib/math/base/special/secd": {}, + "@stdlib/math/base/special/sech": {}, + "@stdlib/math/base/special/signumf": {}, + "@stdlib/math/base/special/signum": {}, + "@stdlib/math/base/special/csignumf": {}, + "@stdlib/math/base/special/csignum": {}, + "@stdlib/math/base/special/sinf": { "$schema": "math/base@v1.0", - "base_alias": "hacovercos", - "alias": "hacovercosf", - "pkg_desc": "compute the half-value coversed cosine", - "desc": "computes the half-value coversed cosine", - "short_desc": "half-value coversed cosine", + "base_alias": "sin", + "alias": "sinf", + "pkg_desc": "compute the sine of a single-precision floating-point number (in radians)", + "desc": "computes the sine of a single-precision floating-point number (in radians)", + "short_desc": "sine", "parameters": [ { "name": "x", @@ -8197,7 +9367,7 @@ ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "half-value coversed cosine", + "desc": "sine", "type": { "javascript": "number", "jsdoc": "number", @@ -8206,36 +9376,25 @@ } }, "keywords": [ - "hacovercos", - "hacovercosf", - "hacovercosin", - "hacovercosine", - "versed cosine", - "half-value", - "coversed", - "cosinus versus", - "hacovercosinus", - "hcc", - "versed", - "cosine", - "cos", - "sine", "sin", + "sinf", + "sine", "trig", "trigonometry", "radians", "angle" ], - "extra_keywords": [] + "extra_keywords": [ + "math.sin" + ] }, - "@stdlib/math/base/special/hacovercos": {}, - "@stdlib/math/base/special/hacoversinf": { + "@stdlib/math/base/special/sin": { "$schema": "math/base@v1.0", - "base_alias": "hacoversin", - "alias": "hacoversinf", - "pkg_desc": "compute the half-value coversed sine", - "desc": "computes the half-value coversed sine", - "short_desc": "half-value coversed sine", + "base_alias": "sin", + "alias": "sin", + "pkg_desc": "compute the sine", + "desc": "computes the sine", + "short_desc": "sine", "parameters": [ { "name": "x", @@ -8243,8 +9402,8 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { @@ -8260,70 +9419,62 @@ ] }, "example_values": [ - 64, - 27, 0, + 0.5236, + 0.7854, + 1.5708, + 1.0472, + 2.3562, + 3.1416, + 4.7124, + 6.2832, + -0.5236, + -0.7854, + -1.0472, + -1.5708, + -2.3562, + -3.1416, + 7.854, + -7.854, 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + -0.1, + 3.5 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "half-value coversed sine", + "desc": "sine", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "hacoversin", - "hacoversinf", - "hacoversine", - "versed sine", - "half-value", - "coversed", - "sinus versus", - "hacoversinus", - "hcv", - "hacov", - "semicoversin", - "cohaversine", - "versed", - "sine", "sin", + "sine", "trig", "trigonometry", - "radians", - "angle" + "radians" ], - "extra_keywords": [] + "extra_keywords": [ + "math.sin" + ] }, - "@stdlib/math/base/special/hacoversin": {}, - "@stdlib/math/base/special/havercosf": { + "@stdlib/math/base/special/sincf": {}, + "@stdlib/math/base/special/sinc": {}, + "@stdlib/math/base/special/sindf": {}, + "@stdlib/math/base/special/sind": {}, + "@stdlib/math/base/special/sinh": {}, + "@stdlib/math/base/special/sinpif": { "$schema": "math/base@v1.0", - "base_alias": "havercos", - "alias": "havercosf", - "pkg_desc": "compute the half-value versed cosine", - "desc": "computes the half-value versed cosine", - "short_desc": "half-value versed cosine", + "base_alias": "sinpi", + "alias": "sinpif", + "pkg_desc": "compute `sin(πx)` in single-precision floating-point format", + "desc": "computes `sin(πx)` in single-precision floating-point format", + "short_desc": "sine", "parameters": [ { "name": "x", @@ -8373,7 +9524,7 @@ ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "half-value versed cosine", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -8382,34 +9533,34 @@ } }, "keywords": [ - "havercos", - "havercosf", - "havercosin", - "havercosine", - "versed", - "haversed", - "hac", - "hvc", - "cosine", - "cos", + "sin", + "sine", + "sinpif", + "pi", "trig", "trigonometry", "radians", "angle" ], - "extra_keywords": [] + "extra_keywords": [ + "math.sin" + ] }, - "@stdlib/math/base/special/havercos": { + "@stdlib/math/base/special/sinpi": {}, + "@stdlib/math/base/special/spencef": {}, + "@stdlib/math/base/special/spence": {}, + "@stdlib/math/base/special/sqrtf": {}, + "@stdlib/math/base/special/sqrt": { "$schema": "math/base@v1.0", - "base_alias": "havercos", - "alias": "havercos", - "pkg_desc": "compute the half-value versed cosine", - "desc": "computes the half-value versed cosine", - "short_desc": "half-value versed cosine", + "base_alias": "sqrt", + "alias": "sqrt", + "pkg_desc": "compute the principal square root", + "desc": "computes the principal square root", + "short_desc": "principal square root", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -8418,44 +9569,44 @@ }, "domain": [ { - "min": "-infinity", + "min": 0, "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + 0, + 100 ] }, "example_values": [ - 64, - 27, 0, + 0.01, + 0.25, + 0.5, + 1, + 2, + 3, + 4, + 9, + 16, + 25, + 36, + 49, + 64, + 81, + 100, 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 10, + 50, + 99.99 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "half-value versed cosine", + "desc": "square root", "type": { "javascript": "number", "jsdoc": "number", @@ -8464,28 +9615,25 @@ } }, "keywords": [ - "havercos", - "havercosin", - "havercosine", - "haversed", - "hac", - "hvc", - "cosine", - "cos", - "trig", - "trigonometry", - "radians", - "angle" + "sqrt", + "square", + "root", + "principal" ], - "extra_keywords": [] + "extra_keywords": [ + "math.sqrt" + ] }, - "@stdlib/math/base/special/haversinf": { + "@stdlib/math/base/special/sqrt1pm1": {}, + "@stdlib/math/base/special/sqrtpif": {}, + "@stdlib/math/base/special/sqrtpi": {}, + "@stdlib/math/base/special/tanf": { "$schema": "math/base@v1.0", - "base_alias": "haversin", - "alias": "haversinf", - "pkg_desc": "compute the half-value versed sine", - "desc": "computes the half-value versed sine", - "short_desc": "half-value versed sine", + "base_alias": "tan", + "alias": "tanf", + "pkg_desc": "compute the tangent of a single-precision floating-point number (in radians).", + "desc": "computes the tangent of a single-precision floating-point number", + "short_desc": "tangent", "parameters": [ { "name": "x", @@ -8502,6 +9650,81 @@ "max": "infinity" } ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -1.5708, + 1.5708 + ] + }, + "example_values": [ + 0, + 0.1745, + 0.3491, + 0.5236, + 0.6981, + 0.8727, + 1.0472, + 1.2217, + 1.3963, + 1.5708, + -0.1745, + -0.3491, + -0.5236, + -0.6981, + -0.8727, + -1.0472, + -1.2217, + -1.3963, + -1.5, + -1.5708 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "tangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "tan", + "tanf", + "tangent", + "trig", + "trigonometry" + ], + "extra_keywords": [ + "math.tan" + ] + }, + "@stdlib/math/base/special/tan": { + "$schema": "math/base@v1.0", + "base_alias": "tan", + "alias": "tan", + "pkg_desc": "compute the tangent", + "desc": "computes the tangent", + "short_desc": "tangent", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], "rand": { "prng": "random/base/uniform", "parameters": [ @@ -8510,181 +9733,137 @@ ] }, "example_values": [ - 64, - 27, 0, + 0.5236, + 0.7854, + 1.0472, + 1.5708, + 3.1416, + 4.7124, + 6.2832, + -0.7854, + -1.5708, + -3.1416, + 5, + -2, 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + -0.1, + 2.3562, + -2.3562, + 7.85398, + -7.85398, + 10 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "half-value versed sine", + "desc": "tangent", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "haversin", - "haversinf", - "haversine", - "haversed", - "hv", - "hvs", - "sem", - "havers", - "semiversinus", - "semiversin", - "semiversus", - "cosine", - "sine", - "cos", - "sin", + "tan", + "tangent", "trig", "trigonometry", - "radians", - "angle" + "radians" ], - "extra_keywords": [] + "extra_keywords": [ + "math.tan" + ] }, - "@stdlib/math/base/special/haversin": {}, - "@stdlib/math/base/special/invf": {}, - "@stdlib/math/base/special/inv": {}, - "@stdlib/math/base/special/cinvf": {}, - "@stdlib/math/base/special/cinv": {}, - "@stdlib/math/base/special/lnf": {}, - "@stdlib/math/base/special/ln": {}, - "@stdlib/math/base/special/log10": {}, - "@stdlib/math/base/special/log1mexp": {}, - "@stdlib/math/base/special/log1p": {}, - "@stdlib/math/base/special/log1pexp": {}, - "@stdlib/math/base/special/log1pmx": {}, - "@stdlib/math/base/special/log2": { + "@stdlib/math/base/special/tandf": { "$schema": "math/base@v1.0", - "base_alias": "log2", - "alias": "log2", - "pkg_desc": "compute the binary logarithm", - "desc": "computes the binary logarithm", - "short_desc": "binary logarithm", + "base_alias": "tand", + "alias": "tandf", + "pkg_desc": "compute the tangent of a single-precision floating-point number (in degrees)", + "desc": "computes the tangent of a single-precision floating-point number (in degrees)", + "short_desc": "tangent", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in degrees)", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { - "min": 0, + "min": "-infinity", "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, - 100 + -180, + 180 ] }, "example_values": [ 0, - 0.01, - 0.25, - 0.5, - 1, - 2, - 3, - 4, - 9, - 16, - 25, - 36, - 49, - 64, - 81, - 100, - 0.1, + 15, + 30, + 45, + 60, + 75, + 90, + -15, + -30, + -45, + -60, + -75, + -90, 10, - 50, - 99.99 + -10, + 20, + -20, + 35, + -35, + 80 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "binary logarithm", + "desc": "tangent", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "logarithm", - "log2", - "binary", - "base 2", - "log" + "tan", + "tand", + "tangent", + "trig", + "trigonometry", + "degrees" ], "extra_keywords": [ - "math.log2" + "math.tan" ] }, - "@stdlib/math/base/special/logitf": {}, - "@stdlib/math/base/special/logit": {}, - "@stdlib/math/base/special/lucasf": {}, - "@stdlib/math/base/special/lucas": {}, - "@stdlib/math/base/special/negafibonaccif": {}, - "@stdlib/math/base/special/negafibonacci": {}, - "@stdlib/math/base/special/negalucasf": {}, - "@stdlib/math/base/special/negalucas": {}, - "@stdlib/math/base/special/nonfibonaccif": {}, - "@stdlib/math/base/special/nonfibonacci": {}, - "@stdlib/math/base/special/rad2degf": {}, - "@stdlib/math/base/special/rad2deg": {}, - "@stdlib/math/base/special/rampf": {}, - "@stdlib/math/base/special/ramp": {}, - "@stdlib/math/base/special/rcbrtf": {}, - "@stdlib/math/base/special/rcbrt": {}, - "@stdlib/math/base/special/riemann-zeta": {}, - "@stdlib/math/base/special/roundf": {}, - "@stdlib/math/base/special/round": {}, - "@stdlib/math/base/special/croundf": {}, - "@stdlib/math/base/special/cround": {}, - "@stdlib/math/base/special/round-nearest-even": { + "@stdlib/math/base/special/tand": { "$schema": "math/base@v1.0", - "base_alias": "roundNearestEven", - "alias": "roundNearestEven", - "pkg_desc": "round to the nearest integer with ties rounding to the nearest even integer", - "desc": "rounds to the nearest integer with ties rounding to the nearest even integer", - "short_desc": "rounds to nearest integer", + "base_alias": "tand", + "alias": "tand", + "pkg_desc": "compute the tangent of an angle measured in degrees", + "desc": "compute the tangent of an angle measured in degrees", + "short_desc": "tangent", "parameters": [ { "name": "x", - "desc": "input value", + "desc": "input value (in degrees)", "type": { "javascript": "number", "jsdoc": "number", @@ -8700,37 +9879,34 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + -180, + 180 ] }, "example_values": [ - 64, - 27, 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 30, + 45, + 60, + 90, + 120, + 135, + 150, + 180, + -30, + -45, + -60, + -90, + -120, + -135, + -150, + -180 ] } ], - "output_policy": "same", + "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "function value", + "desc": "tangent", "type": { "javascript": "number", "jsdoc": "number", @@ -8739,29 +9915,21 @@ } }, "keywords": [ - "round", - "round-nearest-even", - "round-nearest", - "integer", - "nearest", - "number" + "degree", + "tan", + "tangent", + "trig", + "trigonometry" ], - "extra_keywords": [ - "math.round" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/round10": {}, - "@stdlib/math/base/special/round2": {}, - "@stdlib/math/base/special/rsqrtf": {}, - "@stdlib/math/base/special/rsqrt": {}, - "@stdlib/math/base/special/secf": {}, - "@stdlib/math/base/special/sec": { + "@stdlib/math/base/special/tanh": { "$schema": "math/base@v1.0", - "base_alias": "sec", - "alias": "sec", - "pkg_desc": "compute the secant", - "desc": "computes the secant", - "short_desc": "secant", + "base_alias": "tanh", + "alias": "tanh", + "pkg_desc": "compute the hyperbolic tangent of a double-precision floating-point number", + "desc": "computes the hyperbolic tangent of a double-precision floating-point number", + "short_desc": "hyperbolic tangent", "parameters": [ { "name": "x", @@ -8789,29 +9957,29 @@ 0, 0.5236, 0.7854, - 1.5708, 1.0472, - 2.3562, + 1.5708, 3.1416, 4.7124, 6.2832, - -0.5236, -0.7854, - -1.0472, -1.5708, - -2.3562, -3.1416, - 7.854, - -7.854, + 5, + -2, 0.1, -0.1, - 3.5 + 2.3562, + -2.3562, + 7.85398, + -7.85398, + 10 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "secant", + "desc": "hyperbolic tangent", "type": { "javascript": "number", "jsdoc": "number", @@ -8820,35 +9988,30 @@ } }, "keywords": [ - "sec", - "secant", + "tangent", + "tan", + "tanh", + "hyperbolic", "trig", "trigonometry", - "cos", - "cosine" + "radians", + "angle" ], "extra_keywords": [ - "math.sec", - "math.cos" + "math.tanh" ] }, - "@stdlib/math/base/special/secd": {}, - "@stdlib/math/base/special/sech": {}, - "@stdlib/math/base/special/signumf": {}, - "@stdlib/math/base/special/signum": {}, - "@stdlib/math/base/special/csignumf": {}, - "@stdlib/math/base/special/csignum": {}, - "@stdlib/math/base/special/sinf": { + "@stdlib/math/base/special/tribonaccif": { "$schema": "math/base@v1.0", - "base_alias": "sin", - "alias": "sinf", - "pkg_desc": "compute the sine of a single-precision floating-point number (in radians)", - "desc": "computes the sine of a single-precision floating-point number (in radians)", - "short_desc": "sine", + "base_alias": "tribonacci", + "alias": "tribonaccif", + "pkg_desc": "compute the nth Tribonacci number as a single-precision floating-point number", + "desc": "computes the nth Tribonacci number as a single-precision floating-point number", + "short_desc": "Tribonacci number", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -8857,44 +10020,45 @@ }, "domain": [ { - "min": "-infinity", + "min": 0, "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - -10, - 10 + 0, + 100 ] }, "example_values": [ - 64, - 27, - 0, - 0.1, - -9, + 1, + 2, + 3, + 4, + 5, + 6, + 7, 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 21, + 34, + 41, + 55 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "sine", + "desc": "tribonacci number", "type": { "javascript": "number", "jsdoc": "number", @@ -8903,29 +10067,22 @@ } }, "keywords": [ - "sin", - "sinf", - "sine", - "trig", - "trigonometry", - "radians", - "angle" + "fibonacci", + "tribonacci" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/sin": { + "@stdlib/math/base/special/tribonacci": { "$schema": "math/base@v1.0", - "base_alias": "sin", - "alias": "sin", - "pkg_desc": "compute the sine", - "desc": "computes the sine", - "short_desc": "sine", + "base_alias": "tribonacci", + "alias": "tribonacci", + "pkg_desc": "compute the nth Tribonacci number", + "desc": "computes the nth Tribonacci number", + "short_desc": "tribonacci number", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -8934,44 +10091,45 @@ }, "domain": [ { - "min": "-infinity", + "min": 0, "max": "infinity" } ], "rand": { - "prng": "random/base/uniform", + "prng": "random/base/discrete-uniform", "parameters": [ - -10, - 10 + 0, + 100 ] }, "example_values": [ - 0, - 0.5236, - 0.7854, - 1.5708, - 1.0472, - 2.3562, - 3.1416, - 4.7124, - 6.2832, - -0.5236, - -0.7854, - -1.0472, - -1.5708, - -2.3562, - -3.1416, - 7.854, - -7.854, - 0.1, - -0.1, - 3.5 + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 21, + 34, + 41, + 55 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "sine", + "desc": "tribonacci number", "type": { "javascript": "number", "jsdoc": "number", @@ -8980,32 +10138,22 @@ } }, "keywords": [ - "sin", - "sine", - "trig", - "trigonometry", - "radians" + "fibonacci", + "tribonacci" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/sincf": {}, - "@stdlib/math/base/special/sinc": {}, - "@stdlib/math/base/special/sindf": {}, - "@stdlib/math/base/special/sind": {}, - "@stdlib/math/base/special/sinh": {}, - "@stdlib/math/base/special/sinpif": { + "@stdlib/math/base/special/trigammaf": { "$schema": "math/base@v1.0", - "base_alias": "sinpi", - "alias": "sinpif", - "pkg_desc": "compute `sin(πx)` in single-precision floating-point format", - "desc": "computes `sin(πx)` in single-precision floating-point format", - "short_desc": "sine", + "base_alias": "trigamma", + "alias": "trigammaf", + "pkg_desc": "evaluate the trigamma function for a single-precision floating-point number", + "desc": "evaluates the trigamma function for a single-precision floating-point number", + "short_desc": "trigamma", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -9021,31 +10169,31 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + 0.5, + 20 ] }, "example_values": [ - 64, - 27, - 0, - 0.1, - -9, - 8, - -1, - 125, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 0.51, + 1.37, + 2.93, + 4.18, + 7.64, + -2.47, + -1.23, + -3.79, + -0.61, + 5.42, + 9.08, + 12.57, + 15.33, + -4.62, + -6.14, + 18.91, + 10.26, + -5.37, + 3.41, + 0.89 ] } ], @@ -9060,30 +10208,20 @@ } }, "keywords": [ - "sin", - "sine", - "sinpif", - "pi", - "trig", - "trigonometry", - "radians", - "angle" + "derivative", + "trigamma", + "gamma", + "psi" ], - "extra_keywords": [ - "math.sin" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/sinpi": {}, - "@stdlib/math/base/special/spencef": {}, - "@stdlib/math/base/special/spence": {}, - "@stdlib/math/base/special/sqrtf": {}, - "@stdlib/math/base/special/sqrt": { + "@stdlib/math/base/special/trigamma": { "$schema": "math/base@v1.0", - "base_alias": "sqrt", - "alias": "sqrt", - "pkg_desc": "compute the principal square root", - "desc": "computes the principal square root", - "short_desc": "principal square root", + "base_alias": "trigamma", + "alias": "trigamma", + "pkg_desc": "evaluate the trigamma function for a double-precision floating-point number", + "desc": "evaluates the trigamma function for a double-precision floating-point number", + "short_desc": "trigamma", "parameters": [ { "name": "x", @@ -9096,44 +10234,44 @@ }, "domain": [ { - "min": 0, + "min": "-infinity", "max": "infinity" } ], "rand": { "prng": "random/base/uniform", "parameters": [ - 0, - 100 + 0.5, + 20 ] }, "example_values": [ - 0, - 0.01, - 0.25, - 0.5, - 1, - 2, - 3, - 4, - 9, - 16, - 25, - 36, - 49, - 64, - 81, - 100, - 0.1, - 10, - 50, - 99.99 + 0.51, + 1.37, + 2.93, + 4.18, + 7.64, + -2.47, + -1.23, + -3.79, + -0.61, + 5.42, + 9.08, + 12.57, + 15.33, + -4.62, + -6.14, + 18.91, + 10.26, + -5.37, + 3.41, + 0.89 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "square root", + "desc": "function value", "type": { "javascript": "number", "jsdoc": "number", @@ -9142,35 +10280,31 @@ } }, "keywords": [ - "sqrt", - "square", - "root", - "principal" + "derivative", + "gamma", + "trigamma", + "scalar", + "number", + "psi" ], - "extra_keywords": [ - "math.sqrt" - ] + "extra_keywords": [] }, - "@stdlib/math/base/special/sqrt1pm1": {}, - "@stdlib/math/base/special/sqrtpif": {}, - "@stdlib/math/base/special/sqrtpi": {}, - "@stdlib/math/base/special/tanf": {}, - "@stdlib/math/base/special/tan": { + "@stdlib/math/base/special/truncf": { "$schema": "math/base@v1.0", - "base_alias": "tan", - "alias": "tan", - "pkg_desc": "compute the tangent", - "desc": "computes the tangent", - "short_desc": "tangent", + "base_alias": "trunc", + "alias": "truncf", + "pkg_desc": "round a single-precision floating-point number toward zero", + "desc": "rounds a single-precision floating-point number toward zero", + "short_desc": "", "parameters": [ { "name": "x", - "desc": "input value (in radians)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" }, "domain": [ { @@ -9186,66 +10320,66 @@ ] }, "example_values": [ - 0, - 0.5236, - 0.7854, - 1.0472, - 1.5708, - 3.1416, - 4.7124, - 6.2832, - -0.7854, - -1.5708, - -3.1416, - 5, - -2, + 64.5, + 27.6, + 0.9, 0.1, - -0.1, - 2.3562, - -2.3562, - 7.85398, - -7.85398, - 10 + -9.2, + 8.3, + -1.4, + 125.01, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "tangent", + "desc": "rounded value", "type": { "javascript": "number", "jsdoc": "number", - "c": "double", - "dtype": "float64" + "c": "float", + "dtype": "float32" } }, "keywords": [ - "tan", - "tangent", - "trig", - "trigonometry", - "radians" + "trunc", + "truncate", + "round", + "integer", + "number" ], "extra_keywords": [ - "math.tan" + "math.trunc" ] }, - "@stdlib/math/base/special/tandf": { + "@stdlib/math/base/special/trunc": { "$schema": "math/base@v1.0", - "base_alias": "tand", - "alias": "tandf", - "pkg_desc": "compute the tangent of a single-precision floating-point number (in degrees)", - "desc": "computes the tangent of a single-precision floating-point number (in degrees)", - "short_desc": "tangent", + "base_alias": "trunc", + "alias": "trunc", + "pkg_desc": "round a double-precision floating-point number toward zero", + "desc": "rounds a double-precision floating-point number toward zero", + "short_desc": "", "parameters": [ { "name": "x", - "desc": "input value (in degrees)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { @@ -9256,67 +10390,65 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -180, - 180 + -10, + 10 ] }, "example_values": [ - 0, - 15, - 30, - 45, - 60, - 75, - 90, - -15, - -30, - -45, - -60, - -75, - -90, - 10, - -10, - 20, - -20, - 35, - -35, - 80 + 64.5, + 27.6, + 0.9, + 0.1, + -9.2, + 8.3, + -1.4, + 125.01, + -10.2, + 11.3, + -12.4, + 3.5, + -1.6, + 15.7, + -16, + 17.9, + -188, + 19.11, + -200, + 21.15 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "tangent", + "desc": "rounded value", "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "tan", - "tand", - "tangent", - "trig", - "trigonometry", - "degrees" + "trunc", + "truncate", + "round", + "nearest" ], "extra_keywords": [ - "math.tan" + "math.trunc" ] }, - "@stdlib/math/base/special/tand": { + "@stdlib/math/base/special/trunc10": { "$schema": "math/base@v1.0", - "base_alias": "tand", - "alias": "tand", - "pkg_desc": "compute the tangent of an angle measured in degrees", - "desc": "compute the tangent of an angle measured in degrees", - "short_desc": "tangent", + "base_alias": "trunc10", + "alias": "trunc10", + "pkg_desc": "round a numeric value to the nearest power of 10 toward zero", + "desc": "rounds a numeric value to the nearest power of 10 toward zero", + "short_desc": "", "parameters": [ { "name": "x", - "desc": "input value (in degrees)", + "desc": "input value", "type": { "javascript": "number", "jsdoc": "number", @@ -9332,34 +10464,37 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -180, - 180 + -1000, + 1000 ] }, "example_values": [ - 0, - 30, - 45, - 60, - 90, + 5.6, + 49, + 0.7, + -0.9, + -42, + 88, + -3.2, 120, - 135, - 150, - 180, - -30, - -45, - -60, - -90, - -120, - -135, - -150, - -180 + -15, + 230, + -375, + 0, + 9, + -99, + 100, + -1000, + 1500, + -2500, + 7, + -8 ] } ], "output_policy": "real_floating_point_and_generic", "returns": { - "desc": "tangent", + "desc": "rounded value", "type": { "javascript": "number", "jsdoc": "number", @@ -9368,25 +10503,24 @@ } }, "keywords": [ - "degree", - "tan", - "tangent", - "trig", - "trigonometry" + "truncate", + "trunc", + "trunc10", + "round", + "floor", + "ceil", + "nearest" ], - "extra_keywords": [] + "extra_keywords": [ + "math.trunc" + ] }, - "@stdlib/math/base/special/tanh": {}, - "@stdlib/math/base/special/tribonaccif": {}, - "@stdlib/math/base/special/tribonacci": {}, - "@stdlib/math/base/special/trigammaf": {}, - "@stdlib/math/base/special/trigamma": {}, - "@stdlib/math/base/special/truncf": { + "@stdlib/math/base/special/trunc2": { "$schema": "math/base@v1.0", - "base_alias": "trunc", - "alias": "truncf", - "pkg_desc": "round a single-precision floating-point number toward zero", - "desc": "rounds a single-precision floating-point number toward zero", + "base_alias": "trunc2", + "alias": "trunc2", + "pkg_desc": "round a numeric value to the nearest power of two toward zero", + "desc": "rounds a numeric value to the nearest power of two toward zero", "short_desc": "", "parameters": [ { @@ -9395,8 +10529,8 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" }, "domain": [ { @@ -9407,31 +10541,31 @@ "rand": { "prng": "random/base/uniform", "parameters": [ - -10, - 10 + -1000, + 1000 ] }, "example_values": [ - 64.5, - 27.6, - 0.9, - 0.1, - -9.2, - 8.3, - -1.4, - 125.01, - -10.2, - 11.3, - -12.4, - 3.5, - -1.6, - 15.7, - -16, - 17.9, - -188, - 19.11, - -200, - 21.15 + 5.6, + 49, + 0.7, + -0.9, + -42, + 88, + -3.2, + 120, + -15, + 230, + -375, + 0, + 9, + -99, + 100, + -1000, + 1500, + -2500, + 7, + -8 ] } ], @@ -9441,24 +10575,25 @@ "type": { "javascript": "number", "jsdoc": "number", - "c": "float", - "dtype": "float32" + "c": "double", + "dtype": "float64" } }, "keywords": [ - "trunc", "truncate", + "trunc", + "trunc2", "round", - "integer", - "number" + "floor", + "ceil", + "nextpow2", + "prevpow2", + "nearest" ], "extra_keywords": [ "math.trunc" ] }, - "@stdlib/math/base/special/trunc": {}, - "@stdlib/math/base/special/trunc10": {}, - "@stdlib/math/base/special/trunc2": {}, "@stdlib/math/base/special/vercosf": { "$schema": "math/base@v1.0", "base_alias": "vercos",