From 9be06b8159abdf02cdaa93ae95e194d5e673b5b5 Mon Sep 17 00:00:00 2001 From: GUNJ JOSHI Date: Tue, 16 Sep 2025 11:26:24 +0530 Subject: [PATCH 1/6] feat: add generation script and json database --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/math/special/data/unary.json | 9190 +++++++++++++++++ .../scripts/generate_unary_database.js | 132 + 2 files changed, 9322 insertions(+) create mode 100644 lib/node_modules/@stdlib/math/special/data/unary.json create mode 100644 lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js diff --git a/lib/node_modules/@stdlib/math/special/data/unary.json b/lib/node_modules/@stdlib/math/special/data/unary.json new file mode 100644 index 000000000000..cc416373318f --- /dev/null +++ b/lib/node_modules/@stdlib/math/special/data/unary.json @@ -0,0 +1,9190 @@ +{ + "@stdlib/math/base/special/labs": {}, + "@stdlib/number/uint8/base/identity": {}, + "@stdlib/number/uint16/base/identity": {}, + "@stdlib/number/uint32/base/identity": {}, + "@stdlib/math/base/special/absf": { + "$schema": "math/base@v1.0", + "base_alias": "abs", + "alias": "absf", + "pkg_desc": "compute the absolute value of a single-precision floating-point number", + "desc": "computes the absolute value of a single-precision floating-point number", + "short_desc": "absolute value", + "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": "same", + "returns": { + "desc": "absolute value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "abs", + "absf", + "fabsf", + "absolute", + "magnitude", + "value" + ], + "extra_keywords": [ + "math.abs" + ] + }, + "@stdlib/math/base/special/abs": { + "$schema": "math/base@v1.0", + "base_alias": "abs", + "alias": "abs", + "pkg_desc": "compute the absolute value", + "desc": "computes the absolute value", + "short_desc": "absolute value", + "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": "same", + "returns": { + "desc": "absolute value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "abs", + "absolute", + "magnitude" + ], + "extra_keywords": [ + "math.abs" + ] + }, + "@stdlib/math/base/special/cabsf": {}, + "@stdlib/math/base/special/cabs": {}, + "@stdlib/math/base/special/abs2f": { + "$schema": "math/base@v1.0", + "base_alias": "abs2", + "alias": "abs2f", + "pkg_desc": "compute the squared absolute value of a single-precision floating-point number", + "desc": "computes the squared absolute value of a single-precision floating-point number", + "short_desc": "squared absolute value", + "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": "same", + "returns": { + "desc": "squared absolute value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "abs", + "abs2f", + "squared", + "square", + "absolute", + "magnitude" + ], + "extra_keywords": [ + "math.abs" + ] + }, + "@stdlib/math/base/special/abs2": { + "$schema": "math/base@v1.0", + "base_alias": "abs2", + "alias": "abs2", + "pkg_desc": "compute the squared absolute value", + "desc": "computes the squared absolute value", + "short_desc": "squared absolute value", + "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": "same", + "returns": { + "desc": "squared absolute value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "abs", + "abs2", + "squared", + "square", + "absolute", + "magnitude" + ], + "extra_keywords": [ + "math.abs" + ] + }, + "@stdlib/math/base/special/cabs2f": {}, + "@stdlib/math/base/special/cabs2": {}, + "@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/absgammaln": {}, + "@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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "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", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "inverse", + "cotangent", + "acot", + "cot", + "arc", + "arccotangent", + "trig", + "trigonometry", + "degrees", + "angle" + ], + "extra_keywords": [ + "math.acot" + ] + }, + "@stdlib/math/base/special/acotd": { + "$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", + "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 degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "inverse", + "cotangent", + "acot", + "cot", + "arc", + "arccotangent", + "trig", + "trigonometry", + "degrees", + "angle" + ], + "extra_keywords": [ + "math.acot" + ] + }, + "@stdlib/math/base/special/acoth": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 10 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse hyperbolic cotangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "inverse", + "cotangent", + "acot", + "cot", + "coth", + "arc", + "arccotangent", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [ + "math.atanh" + ] + }, + "@stdlib/math/base/special/acovercosf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": 0, + "max": 2 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 2 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse coversed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "acovercos", + "acovercosin", + "acovercosine", + "arccovercos", + "arccovercosin", + "versed cosine", + "acovercosinus", + "acvc", + "arc", + "versed", + "coversed", + "cosine", + "cos", + "asin", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acovercos": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": 2 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 2 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse coversed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acovercos", + "acovercosin", + "acovercosine", + "arccovercos", + "arccovercosin", + "versed cosine", + "acovercosinus", + "acvc", + "arc", + "versed", + "coversed", + "cosine", + "cos", + "asin", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acoversinf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": 0, + "max": 2 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 2 + ] + }, + "example_values": [ + 0, + 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 coversed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "acoversin", + "acoversine", + "arccoversin", + "arccoversine", + "coversed sine", + "versed sine", + "acoversinus", + "arcvers", + "covers", + "cover", + "acvs", + "arc", + "versed", + "coversed", + "sine", + "sin", + "asin" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acoversin": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": 2 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 2 + ] + }, + "example_values": [ + 0, + 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 coversed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acoversin", + "acoversine", + "arccoversin", + "arccoversine", + "coversed sine", + "versed sine", + "acoversinus", + "arcvers", + "covers", + "cover", + "acvs", + "arc", + "versed", + "coversed", + "sine", + "sin", + "asin" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acscf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 5.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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arccosecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "acscf", + "acsc", + "arccosecant", + "cosecant", + "inverse", + "angle" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acsc": { + "$schema": "math/base@v1.0", + "base_alias": "acsc", + "alias": "acsc", + "pkg_desc": "compute the arccosecant", + "desc": "computes the arccosecant", + "short_desc": "arccosecant", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 10 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arccosecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "inverse", + "cosecant", + "acsc", + "arc", + "arccosecant", + "angle", + "sin" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acscdf": { + "$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)", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 5.1 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arccosecant (degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "acsc", + "degree", + "arccosecant", + "cosecant", + "inverse" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acscd": { + "$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)", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 10 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arccosecant (degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "asin", + "degree", + "arccosecant", + "sine", + "inverse" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/acsch": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": 0 + }, + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 5 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic arccosecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acsch", + "hyperbolic", + "inverse", + "cosecant", + "csc", + "arc", + "arccosecant", + "angle", + "asinh" + ], + "extra_keywords": [ + "math.asinh" + ] + }, + "@stdlib/math/base/special/ahavercosf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": 0, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 1 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse half-value versed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "ahavercos", + "ahavercosin", + "ahavercosine", + "arcvercos", + "arcvercosin", + "arcvercosine", + "versed cosine", + "ahavercosinus", + "ahvc", + "arc", + "versed", + "half-value", + "cosine", + "cos", + "acos" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/ahavercos": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 1 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse half-value versed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "ahavercos", + "ahavercosin", + "ahavercosine", + "arcvercos", + "arcvercosin", + "arcvercosine", + "versed cosine", + "ahavercosinus", + "ahvc", + "arc", + "versed", + "half-value", + "cosine", + "cos", + "acos" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/ahaversinf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": 0, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 1 + ] + }, + "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 + ] + } + ], + "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", + "sine", + "sin", + "asin" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/ahaversin": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 1 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse half-value versed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "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/asecf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 5.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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arcsecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "asecf", + "inverse", + "cosine", + "cos", + "arc", + "arccosine", + "secant", + "arcsecant" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/asec": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 10 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse (arc) secant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "asec", + "inverse", + "cosine", + "cos", + "arc", + "arccosine", + "secant", + "arcsecant" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/asecdf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 5.1 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arcsecant (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "asec", + "degree", + "arcsecant", + "secant", + "inverse" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/asecd": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -1 + }, + { + "min": 1, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 1.1, + 10 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arcsecant (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acos", + "degree", + "arcsecant", + "cosine", + "inverse" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/asech": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.05, + 1 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic arcsecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "asech", + "hyperbolic", + "inverse", + "cosine", + "cos", + "arc", + "arccosine", + "secant", + "arcsecant" + ], + "extra_keywords": [ + "math.acosh" + ] + }, + "@stdlib/math/base/special/asinf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": -1, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -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.11, + 0.25, + 0.33, + 0.5, + 0.66, + 0.75, + 0.85, + 0.9, + 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", + "inverse", + "angle" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/asin": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": -1, + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -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.11, + 0.25, + 0.33, + 0.5, + 0.66, + 0.75, + 0.85, + 0.9, + 0.95, + 1 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arcsine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "asin", + "arcsine", + "sine", + "inverse", + "angle", + "polyfill", + "ponyfill" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/asindf": { + "$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", + "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.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": "arcsine (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "asin", + "degree", + "arcsine", + "sine", + "inverse" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/asind": { + "$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", + "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.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": "arcsine (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "asin", + "degree", + "arcsine", + "sine", + "inverse" + ], + "extra_keywords": [ + "math.asin" + ] + }, + "@stdlib/math/base/special/asinh": { + "$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", + "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": [ + -5, + 5 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic arcsine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "asinh", + "hyperbolic", + "inverse", + "arcsine", + "sine" + ], + "extra_keywords": [ + "math.asinh" + ] + }, + "@stdlib/math/base/special/atanf": { + "$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", + "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": [ + -50, + 50 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arctangent (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "atanf", + "arctangent", + "tangent", + "inverse" + ], + "extra_keywords": [ + "math.atan" + ] + }, + "@stdlib/math/base/special/atan": { + "$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", + "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": [ + -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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arctangent (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "atan", + "arctangent", + "tangent", + "tan", + "arc", + "inverse" + ], + "extra_keywords": [ + "math.atan" + ] + }, + "@stdlib/math/base/special/atandf": { + "$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", + "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": [ + -50, + 50 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "arctangent (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "degree", + "arctangent", + "tangent", + "inverse" + ], + "extra_keywords": [ + "math.atan" + ] + }, + "@stdlib/math/base/special/atand": { + "$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", + "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": [ + -100, + 100 + ] + }, + "example_values": [ + 180.2, + -3.7, + 0.42, + -98.5, + 5.4, + -0.06, + 73.1, + -41.3, + 9.9, + -12.2, + 0, + 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": "arctangent (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "degree", + "arctangent", + "tangent", + "inverse" + ], + "extra_keywords": [ + "math.atan" + ] + }, + "@stdlib/math/base/special/atanh": { + "$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", + "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": [ + -0.95, + 0.95 + ] + }, + "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, + 0.41, + -0.66, + 0.18, + -0.91 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic arctangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "atanh", + "hyperbolic", + "inverse", + "tangent", + "tan" + ], + "extra_keywords": [ + "math.atanh" + ] + }, + "@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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": -2, + "max": 0 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -2, + 0 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse versed cosine (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "avercos", + "avercosin", + "avercosine", + "arcvercos", + "arcvercosin", + "versed cosine", + "avercosinus", + "avcs", + "arc", + "versed", + "cosine", + "cos", + "acos" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/avercos": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": -2, + "max": 0 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -2, + 0 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "inverse versed cosine (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "avercos", + "avercosin", + "avercosine", + "arcvercos", + "arcvercosin", + "versed cosine", + "avercosinus", + "avcs", + "arc", + "versed", + "cosine", + "cos", + "acos" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/aversinf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": 0, + "max": 2 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 2 + ] + }, + "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 + ] + } + ], + "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" + ] + }, + "@stdlib/math/base/special/aversin": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "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": "inverse versed sine (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "aversin", + "aversine", + "arcversin", + "arcversine", + "versed sine", + "aversinus", + "arcvers", + "avers", + "aver", + "arc", + "versed", + "sine", + "sin", + "acos" + ], + "extra_keywords": [ + "math.acos" + ] + }, + "@stdlib/math/base/special/bernoullif": {}, + "@stdlib/math/base/special/bernoulli": {}, + "@stdlib/math/base/special/besselj0": { + "$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", + "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": [ + -100, + 100 + ] + }, + "example_values": [ + -250.3, + 0.12, + 3.7, + -5.9, + 10.4, + -1.01, + 42, + -77.6, + 0, + 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": "evaluated Bessel function", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "bessel", + "j0" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/besselj1": { + "$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", + "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": [ + -100, + 100 + ] + }, + "example_values": [ + 0.2, + -0.87, + 4.1, + -6.3, + 12.7, + -2.25, + 50.9, + -99.4, + 8.2, + -3.6, + 0, + 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": "evaluated Bessel function", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "bessel", + "j1" + ], + "extra_keywords": [] + }, + "@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", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.01, + 100 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "evaluated Bessel function", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "bessel", + "y0" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/bessely1": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "evaluated Bessel function", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "bessel", + "y1" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/binet": { + "$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", + "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": [ + -50, + 50 + ] + }, + "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, + 0, + 47.8, + -15.4, + 102.6, + -10.3 + ] + } + ], + "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/cbrtf": { + "$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", + "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, + -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 + ] + } + ], + "returns": { + "desc": "cube root", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "cube", + "root", + "cbrt", + "cubic", + "power" + ], + "extra_keywords": [ + "math.cbrt" + ] + }, + "@stdlib/math/base/special/cbrt": { + "$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", + "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.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 + ] + } + ], + "returns": { + "desc": "cube root", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cube", + "root", + "cbrt", + "cubic", + "power" + ], + "extra_keywords": [ + "math.cbrt" + ] + }, + "@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": "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", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -50, + 50 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "rounded value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "ceil", + "round", + "integer", + "nearest", + "ceiling", + "floor" + ], + "extra_keywords": [ + "math.ceil" + ] + }, + "@stdlib/math/base/special/ceil": { + "$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", + "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.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_and_generic", + "returns": { + "desc": "rounded value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "ceil", + "round", + "integer", + "nearest", + "value" + ], + "extra_keywords": [ + "math.ceil" + ] + }, + "@stdlib/math/base/special/cceilf": {}, + "@stdlib/math/base/special/cceil": { + "$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": "", + "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", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "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_and_generic", + "returns": { + "desc": "rounded value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "ceil", + "ceil10", + "round", + "power", + "ten", + "nearest", + "value" + ], + "extra_keywords": [ + "math.ceil" + ] + }, + "@stdlib/math/base/special/ceil2": { + "$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": "", + "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": [ + -100, + 100 + ] + }, + "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, + 0, + 21.3, + -0.83, + 4.63, + 9.01, + 0.28, + 13.57 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "rounded value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "ceil", + "ceil2", + "round", + "nextpow2", + "prevpow2", + "nearest", + "number" + ], + "extra_keywords": [ + "math.ceil" + ] + }, + "@stdlib/math/base/special/cosf": { + "$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)", + "short_desc": "cosine", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "cos", + "cosf", + "cosine", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [ + "math.cos" + ] + }, + "@stdlib/math/base/special/cos": { + "$schema": "math/base@v1.0", + "base_alias": "cos", + "alias": "cos", + "pkg_desc": "compute the cosine", + "desc": "computes the cosine", + "short_desc": "cosine", + "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": [ + -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": "cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cos", + "cosine", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [ + "math.cos" + ] + }, + "@stdlib/math/base/special/cosdf": { + "$schema": "math/base@v1.0", + "base_alias": "cosd", + "alias": "cosdf", + "pkg_desc": "compute the cosine", + "desc": "computes the cosine", + "short_desc": "cosine", + "parameters": [ + { + "name": "x", + "desc": "input value (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -360, + 360 + ] + }, + "example_values": [ + 0, + 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": "cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "cos", + "cosdf", + "cosine", + "trig", + "trigonometry", + "degrees" + ], + "extra_keywords": [ + "math.cos" + ] + }, + "@stdlib/math/base/special/cosd": { + "$schema": "math/base@v1.0", + "base_alias": "cos", + "alias": "cosd", + "pkg_desc": "compute the cosine", + "desc": "computes the cosine", + "short_desc": "cosine", + "parameters": [ + { + "name": "x", + "desc": "input value (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -360, + 360 + ] + }, + "example_values": [ + 0, + 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": "cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cos", + "cosd", + "cosine", + "trig", + "trigonometry", + "degrees" + ], + "extra_keywords": [ + "math.cos" + ] + }, + "@stdlib/math/base/special/cosh": { + "$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", + "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": [ + -50, + 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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cosine", + "cos", + "hyperbolic" + ], + "extra_keywords": [ + "math.cosh" + ] + }, + "@stdlib/math/base/special/cosm1f": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "cosine minus one", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "math.cos", + "cos", + "cosm1", + "cosm1f", + "cosine", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/cosm1": { + "$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", + "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": [ + -50, + 50 + ] + }, + "example_values": [ + -2.9, + 0.41, + 7.6, + -0.37, + 3.2, + -11.8, + 1.2, + -6.4, + 0, + 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": "result", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cos", + "cosm1", + "cosine" + ], + "extra_keywords": [ + "math.cos" + ] + }, + "@stdlib/math/base/special/cospif": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "cos", + "cospif", + "cosine", + "pi", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [ + "math.cos" + ] + }, + "@stdlib/math/base/special/cospi": { + "$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 π", + "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": [ + -50, + 50 + ] + }, + "example_values": [ + -3.25, + 0.125, + 1.6, + -0.45, + 2.75, + -7.3, + 4.2, + -5.8, + 0, + 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, + -8.1 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "cotangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "cotf", + "cotangent", + "tan", + "tangent", + "sin", + "sine", + "cos", + "cosine" + ], + "extra_keywords": [ + "math.tan" + ] + }, + "@stdlib/math/base/special/cot": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 50 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "cotangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cot", + "cotangent", + "tan", + "tangent", + "sin", + "sine", + "cos", + "cosine" + ], + "extra_keywords": [ + "math.tan" + ] + }, + "@stdlib/math/base/special/cotd": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 180 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "cotangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cot", + "cotd", + "cotangent", + "tan", + "tangent", + "sin", + "sine", + "cos", + "cosine" + ], + "extra_keywords": [ + "math.tan" + ] + }, + "@stdlib/math/base/special/coth": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 50 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic cotangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "cotangent", + "cot", + "coth", + "tangent", + "tan", + "tanh", + "hyperbolic" + ], + "extra_keywords": [ + "math.tanh" + ] + }, + "@stdlib/math/base/special/covercosf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "coversed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "covercos", + "covercosf", + "covercosin", + "covercosine", + "coversed", + "covercosinus", + "cvc", + "versed", + "cosine", + "cos", + "sine", + "sin", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/covercos": { + "$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", + "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": [ + -50, + 50 + ] + }, + "example_values": [ + -6.1, + -3.4, + -1.2, + -0.49, + -0.08, + 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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "coversed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "covercos", + "covercosin", + "covercosine", + "versed cosine", + "coversed", + "cosinus versus", + "covercosinus", + "cvc", + "versed", + "cosine", + "cos", + "sine", + "sin" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@stdlib/math/base/special/coversinf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "coversed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "coversin", + "coversinf", + "coversine", + "coversed", + "coversinus", + "covers", + "cosiv", + "cvs", + "versed", + "sine", + "sin", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/coversin": { + "$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", + "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": [ + -50, + 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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "coversed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "coversin", + "coversine", + "versed sine", + "coversed", + "cosinus versus", + "coversinus", + "covers", + "cosiv", + "cvs", + "versed", + "sine", + "sin" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@stdlib/math/base/special/cscf": { + "$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", + "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": [ + -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": "cosecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "sin", + "sine", + "cosec", + "csc" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@stdlib/math/base/special/csc": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 50 + ] + }, + "example_values": [ + -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": "cosecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "sin", + "sine", + "cosec", + "csc" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@stdlib/math/base/special/cscd": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in degrees)", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 180 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "cosecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "acsc", + "cosecant", + "degree", + "sine" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@stdlib/math/base/special/csch": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 50 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "hyperbolic cosecant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "csc", + "cosecant", + "sin", + "sine", + "hyperbolic" + ], + "extra_keywords": [ + "math.sinh" + ] + }, + "@stdlib/math/base/special/deg2radf": { + "$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": "", + "parameters": [ + { + "name": "x", + "desc": "angle in degrees", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -360, + 360 + ] + }, + "example_values": [ + -257, + 0, + 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": "angle in radians", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "geometry", + "radians", + "degrees", + "angle", + "convert" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/deg2rad": { + "$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": "", + "parameters": [ + { + "name": "x", + "desc": "angle in degrees", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -360, + 360 + ] + }, + "example_values": [ + -213, + 0, + 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": "angle in radians", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "geometry", + "radians", + "degrees", + "angle", + "convert" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/digamma": { + "$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", + "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": [ + 0.5, + 20 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "derivative", + "gamma", + "digamma", + "scalar", + "number", + "psi" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/dirac-deltaf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "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": [ + -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": "result", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "dirac", + "delta", + "distribution", + "dist", + "continuous", + "kronecker", + "spike", + "impulse" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/dirac-delta": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": -5e-324 + }, + { + "min": 5e-324, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.5, + 50 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "result", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "dirac", + "delta", + "distribution", + "dist", + "continuous", + "kronecker", + "spike", + "impulse" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/dirichlet-eta": { + "$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", + "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": [ + -5, + 5 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "eta", + "zeta", + "dirichlet", + "series", + "alternating", + "number", + "number theory" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/ellipe": { + "$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", + "parameters": [ + { + "name": "m", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -50, + 0.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.37, + -0.68, + -28.45 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "evaluated elliptic integral", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "elliptic" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/ellipk": { + "$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", + "parameters": [ + { + "name": "m", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": "-infinity", + "max": 1 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + -50, + 0.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.37, + -0.68, + -28.45 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "evaluated elliptic integral", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "special", + "elliptic", + "number" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/erf": { + "$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", + "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": [ + -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, + 1.67, + -4.86, + 0.59, + -2.07, + 4.12 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "erf", + "error", + "function" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/erfc": { + "$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", + "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": [ + -5, + 5 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "erf", + "erfc", + "complementary", + "error", + "function" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/erfcinv": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": 2 + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0.1, + 1.8 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "erf", + "erfc", + "erfinv", + "erfcinv", + "inverse", + "complementary", + "error", + "function" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/erfcx": { + "$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", + "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": [ + -5, + 5 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "evaluated scaled complementary error function", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "erfc", + "erfcx", + "complementary", + "error", + "function", + "scaled" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/erfinv": { + "$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", + "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": [ + -0.9, + 0.75 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "erf", + "erfinv", + "inverse", + "error" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/exp": { + "$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", + "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": [ + -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 + ] + } + ], + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "natural", + "exponential", + "exp", + "power" + ], + "extra_keywords": [ + "math.exp" + ] + }, + "@stdlib/math/base/special/cexp": {}, + "@stdlib/math/base/special/exp10": { + "$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", + "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": [ + -3, + 3 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "exp", + "exp10", + "base 10", + "exponential", + "euler", + "power" + ], + "extra_keywords": [ + "math.exp" + ] + }, + "@stdlib/math/base/special/exp2": { + "$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", + "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": [ + -5, + 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, + -0.28, + 3.74, + -2.96, + 0.83, + -1.12, + 4.89, + -3.51 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "exp", + "exp2", + "base 2", + "natural", + "exponential", + "euler", + "power" + ], + "extra_keywords": [ + "math.exp" + ] + }, + "@stdlib/math/base/special/expit": {}, + "@stdlib/math/base/special/expm1": {}, + "@stdlib/math/base/special/expm1rel": {}, + "@stdlib/math/base/special/factorial": { + "$schema": "math/base@v1.0", + "base_alias": "factorial", + "alias": "factorial", + "pkg_desc": "compute the factorial", + "desc": "computes the factorial", + "short_desc": "factorial", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/discrete-uniform", + "parameters": [ + 0, + 100 + ] + }, + "example_values": [ + 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": "factorial", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "factorial", + "fact" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/factorial2f": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/discrete-uniform", + "parameters": [ + 0, + 100 + ] + }, + "example_values": [ + 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": "double factorial", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "factorial2f", + "dfact", + "factorial", + "combinatorics" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/factorial2": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/discrete-uniform", + "parameters": [ + 0, + 100 + ] + }, + "example_values": [ + 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": "double factorial", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "factorial2", + "dfact", + "factorial", + "combinatorics" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/factoriallnf": {}, + "@stdlib/math/base/special/factorialln": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/discrete-uniform", + "parameters": [ + 0, + 100 + ] + }, + "example_values": [ + 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": "result", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "factorialln", + "lfact", + "fact", + "factorial", + "gamma", + "combinatorics" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/fibonaccif": {}, + "@stdlib/math/base/special/fibonacci": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/discrete-uniform", + "parameters": [ + 0, + 100 + ] + }, + "example_values": [ + 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": "fibonacci number", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "fibonacci", + "fib" + ], + "extra_keywords": [] + }, + "@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": "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 (in radians)", + "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": "half-value coversed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "hacovercos", + "hacovercosf", + "hacovercosin", + "hacovercosine", + "versed cosine", + "half-value", + "coversed", + "cosinus versus", + "hacovercosinus", + "hcc", + "versed", + "cosine", + "cos", + "sine", + "sin", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/hacovercos": {}, + "@stdlib/math/base/special/hacoversinf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "half-value coversed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "hacoversin", + "hacoversinf", + "hacoversine", + "versed sine", + "half-value", + "coversed", + "sinus versus", + "hacoversinus", + "hcv", + "hacov", + "semicoversin", + "cohaversine", + "versed", + "sine", + "sin", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/hacoversin": {}, + "@stdlib/math/base/special/havercosf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "half-value versed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "havercos", + "havercosf", + "havercosin", + "havercosine", + "versed", + "haversed", + "hac", + "hvc", + "cosine", + "cos", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/havercos": { + "$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", + "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": [ + -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": "half-value versed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "havercos", + "havercosin", + "havercosine", + "haversed", + "hac", + "hvc", + "cosine", + "cos", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/haversinf": { + "$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", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "half-value versed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "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/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": "log2", + "alias": "log2", + "pkg_desc": "compute the binary logarithm", + "desc": "computes the binary logarithm", + "short_desc": "binary logarithm", + "parameters": [ + { + "name": "x", + "desc": "input value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 100 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "binary logarithm", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "logarithm", + "log2", + "binary", + "base 2", + "log" + ], + "extra_keywords": [ + "math.log2" + ] + }, + "@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": "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", + "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": "same", + "returns": { + "desc": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "round", + "round-nearest-even", + "round-nearest", + "integer", + "nearest", + "number" + ], + "extra_keywords": [ + "math.round" + ] + }, + "@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": "sec", + "alias": "sec", + "pkg_desc": "compute the secant", + "desc": "computes the secant", + "short_desc": "secant", + "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": [ + -10, + 10 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "secant", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "sec", + "secant", + "trig", + "trigonometry", + "cos", + "cosine" + ], + "extra_keywords": [ + "math.sec", + "math.cos" + ] + }, + "@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": "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", + "desc": "input value (in radians)", + "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": "sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "sin", + "sinf", + "sine", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@stdlib/math/base/special/sin": { + "$schema": "math/base@v1.0", + "base_alias": "sin", + "alias": "sin", + "pkg_desc": "compute the sine", + "desc": "computes the sine", + "short_desc": "sine", + "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": [ + -10, + 10 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "sin", + "sine", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@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": "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", + "desc": "input value (in radians)", + "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": "function value", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "sin", + "sine", + "sinpif", + "pi", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [ + "math.sin" + ] + }, + "@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": "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", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + }, + "domain": [ + { + "min": 0, + "max": "infinity" + } + ], + "rand": { + "prng": "random/base/uniform", + "parameters": [ + 0, + 100 + ] + }, + "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 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "square root", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "sqrt", + "square", + "root", + "principal" + ], + "extra_keywords": [ + "math.sqrt" + ] + }, + "@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": { + "$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": [ + -10, + 10 + ] + }, + "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, + 0.1, + -0.1, + 2.3562, + -2.3562, + 7.85398, + -7.85398, + 10 + ] + } + ], + "output_policy": "real_floating_point_and_generic", + "returns": { + "desc": "tangent", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "double", + "dtype": "float64" + } + }, + "keywords": [ + "tan", + "tangent", + "trig", + "trigonometry", + "radians" + ], + "extra_keywords": [ + "math.tan" + ] + }, + "@stdlib/math/base/special/tandf": {}, + "@stdlib/math/base/special/tand": {}, + "@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/trunc": {}, + "@stdlib/math/base/special/trunc10": {}, + "@stdlib/math/base/special/trunc2": {}, + "@stdlib/math/base/special/vercosf": { + "$schema": "math/base@v1.0", + "base_alias": "vercos", + "alias": "vercosf", + "pkg_desc": "compute the versed cosine", + "desc": "computes the versed cosine", + "short_desc": "versed cosine", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "versed cosine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "vercos", + "vercosf", + "vercosin", + "vercosine", + "versed cosine", + "vcs", + "cosine", + "cos", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/vercos": {}, + "@stdlib/math/base/special/versinf": { + "$schema": "math/base@v1.0", + "base_alias": "vercos", + "alias": "vercosf", + "pkg_desc": "compute the versed sine", + "desc": "computes the versed sine", + "short_desc": "versed sine", + "parameters": [ + { + "name": "x", + "desc": "input value (in radians)", + "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": "versed sine", + "type": { + "javascript": "number", + "jsdoc": "number", + "c": "float", + "dtype": "float32" + } + }, + "keywords": [ + "versin", + "versinf", + "versine", + "versed sine", + "cosine", + "cos", + "trig", + "trigonometry", + "radians", + "angle" + ], + "extra_keywords": [] + }, + "@stdlib/math/base/special/versin": {} +} diff --git a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js new file mode 100644 index 000000000000..72475667f276 --- /dev/null +++ b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js @@ -0,0 +1,132 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var join = require( 'path' ).join; +var readFile = require( '@stdlib/fs/read-file' ).sync; +var writeFile = require( '@stdlib/fs/write-file' ).sync; +var exists = require( '@stdlib/fs/exists' ).sync; +var objectKeys = require( '@stdlib/utils/keys' ); +var hasOwnProp = require( '@stdlib/assert/has-own-property' ); +var functionDatabase = require( './../data/unary_function_database.json' ); + + +// FUNCTIONS // + +/** +* Extracts scaffold metadata from a package's package.json file. +* +* @private +* @param {string} pkgPath - package path +* @returns {Object} scaffold object +* +* @example +* var scaffold = extractScaffold( '@stdlib/math/base/special/sqrt' ); +* // returns { 'parameters': [...], 'returns': {...} } +*/ +function extractScaffold( pkgPath ) { + var packageJsonPath; + var content; + var path; + var pkg; + + // Convert @stdlib/math/base/special/sqrt to lib/node_modules/@stdlib/math/base/special/sqrt: + path = pkgPath.replace( '@stdlib/', '' ); + packageJsonPath = join( resolve( __dirname, '../../..' ), path, 'package.json' ); + + if ( !exists( packageJsonPath ) ) { + return {}; + } + + content = readFile( packageJsonPath, 'utf8' ); + if ( content instanceof Error ) { + return {}; + } + + pkg = JSON.parse( content ); + + // Return the complete scaffold object: + if ( pkg[ '__stdlib__' ] && pkg[ '__stdlib__' ].scaffold ) { + return pkg[ '__stdlib__' ].scaffold; + } + + return {}; +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var scalarKernelNames; + var scaffoldDatabase; + var scalarKernels; + var jsonContent; + var outputPath; + var functions; + var scaffold; + var pkgPath; + var func; + var pkg; + var i; + var j; + + scaffoldDatabase = {}; + + // Get all function names: + functions = objectKeys( functionDatabase ); + + for ( i = 0; i < functions.length; i++ ) { + func = functions[ i ]; + scalarKernels = functionDatabase[ func ].scalar_kernels; + + // Process each scalar kernel: + scalarKernelNames = objectKeys( scalarKernels ); + for ( j = 0; j < scalarKernelNames.length; j++ ) { + pkg = scalarKernelNames[ j ]; + pkgPath = scalarKernels[ pkg ]; + + // Skip if we already processed this package: + if ( hasOwnProp( scaffoldDatabase, pkgPath ) ) { + continue; + } + + scaffold = extractScaffold( pkgPath ); + + if ( scaffold ) { + scaffoldDatabase[ pkgPath ] = scaffold; + } + } + } + + // Write the dtypes database to file: + outputPath = join( __dirname, '..', 'data', 'unary.json' ); + jsonContent = JSON.stringify( scaffoldDatabase, null, 2 ) + '\n'; + + writeFile( outputPath, jsonContent ); +} + +main(); From 835511067ac716ee259a80efdeb7f5c420050d1f Mon Sep 17 00:00:00 2001 From: GUNJ JOSHI Date: Tue, 16 Sep 2025 11:31:11 +0530 Subject: [PATCH 2/6] docs: add scripts directory in package.json --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: passed - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/math/special/package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/node_modules/@stdlib/math/special/package.json b/lib/node_modules/@stdlib/math/special/package.json index 2b25fe57aebe..60bd27fd713b 100644 --- a/lib/node_modules/@stdlib/math/special/package.json +++ b/lib/node_modules/@stdlib/math/special/package.json @@ -19,6 +19,7 @@ "doc": "./docs", "example": "./examples", "lib": "./lib", + "scripts": "./scripts", "test": "./test" }, "types": "./docs/types", From ca90dc0e88400dada487946ae0a43f6b63941772 Mon Sep 17 00:00:00 2001 From: GUNJ JOSHI Date: Tue, 16 Sep 2025 11:34:54 +0530 Subject: [PATCH 3/6] refactor: add shebang --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/math/special/scripts/generate_unary_database.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js index 72475667f276..bac4f8494dce 100644 --- a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js +++ b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js @@ -1,3 +1,5 @@ +#!/usr/bin/env node + /** * @license Apache-2.0 * From 3c347a2751e786b8175efd46bbf26e7262539513 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 01:45:42 -0700 Subject: [PATCH 4/6] docs: update return annotation Signed-off-by: Athan --- .../@stdlib/math/special/scripts/generate_unary_database.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js index bac4f8494dce..17ee08461b21 100644 --- a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js +++ b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js @@ -43,7 +43,7 @@ var functionDatabase = require( './../data/unary_function_database.json' ); * * @example * var scaffold = extractScaffold( '@stdlib/math/base/special/sqrt' ); -* // returns { 'parameters': [...], 'returns': {...} } +* // returns {...} */ function extractScaffold( pkgPath ) { var packageJsonPath; From b15eb17ec5e91accf742501d581bfe5b071f5449 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 02:13:38 -0700 Subject: [PATCH 5/6] build: simplify script logic Signed-off-by: Athan --- .../scripts/generate_unary_database.js | 96 +++++++------------ 1 file changed, 37 insertions(+), 59 deletions(-) diff --git a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js index 17ee08461b21..daac1263f4ed 100644 --- a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js +++ b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js @@ -22,16 +22,19 @@ // MODULES // -var resolve = require( 'path' ).resolve; var join = require( 'path' ).join; -var readFile = require( '@stdlib/fs/read-file' ).sync; +var hasOwnProp = require( '@stdlib/assert/has-own-property' ); +var tryRequire = require( '@stdlib/utils/try-require' ); var writeFile = require( '@stdlib/fs/write-file' ).sync; -var exists = require( '@stdlib/fs/exists' ).sync; var objectKeys = require( '@stdlib/utils/keys' ); -var hasOwnProp = require( '@stdlib/assert/has-own-property' ); var functionDatabase = require( './../data/unary_function_database.json' ); +// VARIABLES // + +var OUTPUT_PATH = join( __dirname, '..', 'data', 'unary.json' ); + + // FUNCTIONS // /** @@ -46,31 +49,17 @@ var functionDatabase = require( './../data/unary_function_database.json' ); * // returns {...} */ function extractScaffold( pkgPath ) { - var packageJsonPath; - var content; - var path; var pkg; - - // Convert @stdlib/math/base/special/sqrt to lib/node_modules/@stdlib/math/base/special/sqrt: - path = pkgPath.replace( '@stdlib/', '' ); - packageJsonPath = join( resolve( __dirname, '../../..' ), path, 'package.json' ); - - if ( !exists( packageJsonPath ) ) { - return {}; - } - - content = readFile( packageJsonPath, 'utf8' ); - if ( content instanceof Error ) { + var o; + + pkg = tryRequire( join( pkgPath, 'package.json' ) ); + if ( pkg instanceof Error ) { return {}; } - - pkg = JSON.parse( content ); - - // Return the complete scaffold object: - if ( pkg[ '__stdlib__' ] && pkg[ '__stdlib__' ].scaffold ) { - return pkg[ '__stdlib__' ].scaffold; + o = pkg[ '__stdlib__' ]; + if ( o && o.scaffold ) { + return o.scaffold; } - return {}; } @@ -83,52 +72,41 @@ function extractScaffold( pkgPath ) { * @private */ function main() { - var scalarKernelNames; - var scaffoldDatabase; - var scalarKernels; - var jsonContent; - var outputPath; - var functions; - var scaffold; + var kernels; var pkgPath; - var func; - var pkg; + var names; + var db; + var dt; var i; var j; - scaffoldDatabase = {}; + // Initialize an object for storing scaffold meta data: + db = {}; - // Get all function names: - functions = objectKeys( functionDatabase ); + // Resolve a list of function names: + names = objectKeys( functionDatabase ); - for ( i = 0; i < functions.length; i++ ) { - func = functions[ i ]; - scalarKernels = functionDatabase[ func ].scalar_kernels; + // For each function, resolve the scaffold meta data for all associated scalar kernels... + for ( i = 0; i < names.length; i++ ) { + // Resolve a table mapping dtypes to scalar kernels: + kernels = functionDatabase[ names[ i ] ].scalar_kernels; - // Process each scalar kernel: - scalarKernelNames = objectKeys( scalarKernels ); - for ( j = 0; j < scalarKernelNames.length; j++ ) { - pkg = scalarKernelNames[ j ]; - pkgPath = scalarKernels[ pkg ]; + // Resolve a list of dtypes: + dt = objectKeys( kernels ); - // Skip if we already processed this package: - if ( hasOwnProp( scaffoldDatabase, pkgPath ) ) { - continue; - } - - scaffold = extractScaffold( pkgPath ); + // For each scalar kernel associated with a dtype, resolve the scaffold meta data... + for ( j = 0; j < dt.length; j++ ) { + // Resolve the name of the scalar kernel package associated with the current dtype: + pkgPath = kernels[ dt[ j ] ]; - if ( scaffold ) { - scaffoldDatabase[ pkgPath ] = scaffold; + // Only attempt to resolve scaffold meta data if we haven't already processed this package... + if ( !hasOwnProp( db, pkgPath ) ) { + db[ pkgPath ] = extractScaffold( pkgPath ); } } } - - // Write the dtypes database to file: - outputPath = join( __dirname, '..', 'data', 'unary.json' ); - jsonContent = JSON.stringify( scaffoldDatabase, null, 2 ) + '\n'; - - writeFile( outputPath, jsonContent ); + // Write the database to a file: + writeFile( OUTPUT_PATH, JSON.stringify( db, null, 2 )+'\n' ); } main(); From aa3e4633e0bd4586520be13f3a00e1de0410bc6d Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 02:15:41 -0700 Subject: [PATCH 6/6] style: remove whitespace Signed-off-by: Athan --- .../@stdlib/math/special/scripts/generate_unary_database.js | 1 - 1 file changed, 1 deletion(-) diff --git a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js index daac1263f4ed..811e980fcf8d 100644 --- a/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js +++ b/lib/node_modules/@stdlib/math/special/scripts/generate_unary_database.js @@ -51,7 +51,6 @@ var OUTPUT_PATH = join( __dirname, '..', 'data', 'unary.json' ); function extractScaffold( pkgPath ) { var pkg; var o; - pkg = tryRequire( join( pkgPath, 'package.json' ) ); if ( pkg instanceof Error ) { return {};