@stdlib/math-base-special-sincosf 0.1.0

package/include/stdlib/math/base/special/sincosf.h

@@ -0,0 +1,38 @@
+/**
+* @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.
+*/
+
+#ifndef STDLIB_MATH_BASE_SPECIAL_SINCOSF_H
+#define STDLIB_MATH_BASE_SPECIAL_SINCOSF_H
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Simultaneously computes the sine and cosine of a single-precision floating-point number (in radians).
+*/
+void stdlib_base_sincosf( const float x, float *sine, float *cosine );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_SPECIAL_SINCOSF_H

package/lib/assign.js

@@ -0,0 +1,223 @@
+/**
+* @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.
+*
+*
+* ## Notice
+*
+* The following copyright and license were part of the original implementation available as part of FreeBSD [k_sin.c]{@link https://svnweb.freebsd.org/base/release/9.3.0/lib/msun/src/k_sin.c} and [k_cos.c]{@link https://svnweb.freebsd.org/base/release/9.3.0/lib/msun/src/k_cos.c}. The implementation follows the original sine and cosine kernels, but has been modified for JavaScript and combined into a single function.
+*
+* ```text
+* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+*
+* Developed at SunPro, a Sun Microsystems, Inc. business.
+* Permission to use, copy, modify, and distribute this
+* software is freely granted, provided that this notice
+* is preserved.
+* ```
+*/
+
+'use strict';
+
+// MODULES //
+
+var toWordf = require( '@stdlib/number-float32-base-to-word' );
+var rempio2f = require( '@stdlib/math-base-special-rempio2f' );
+var f32 = require( '@stdlib/number-float64-base-to-float32' );
+var FLOAT32_ABS_MASK = require( '@stdlib/constants-float32-abs-mask' );
+var FLOAT32_EXPONENT_MASK = require( '@stdlib/constants-float32-exponent-mask' );
+var FLOAT64_HALF_PI = require( '@stdlib/constants-float64-half-pi' );
+var kernelSincosf = require( '@stdlib/math-base-special-kernel-sincosf' ).assign;
+
+
+// VARIABLES //
+
+// PI/4 = 0.7853981256484985 => 0 01111110 10010010000111111011010 => 0x3f490fda = 1061752768
+var PIO4_WORD = 0x3f490fda|0; // asm type annotation
+
+// 3*PI/4 = 2.356194257736206 => 0 10000000 00101101100101111100011 => 0x4016cbe3 = 1075235811
+var THREE_PIO4_WORD = 0x4016cbe3|0; // asm type annotation
+
+// 5*PI/4 = 3.9269907474517822 => 0 10000000 11110110101001111010001 => 0x407b53d1 = 1081824209
+var FIVE_PIO4_WORD = 0x407b53d1|0; // asm type annotation
+
+// 7*PI/4 = 5.497786998748779 => 0 10000001 01011111110110111011111 => 0x40afeddf = 1085271519
+var SEVEN_PIO4_WORD = 0x40afeddf|0; // asm type annotation
+
+// 9*PI/4 = 7.068583011627197 => 0 10000001 11000100011000111010101 => 0x40e231d5 = 1088565717
+var NINE_PIO4_WORD = 0x40e231d5|0; // asm type annotation
+
+// 2^-12 = 0.000244140625 => 0 01110011 00000000000000000000000 => 0x39800000 = 964689920
+var SMALL_WORD = 0x39800000|0; // asm type annotation
+
+// Small multiples of PI/2 in double-precision floating-point format:
+var PIO2 = FLOAT64_HALF_PI;             // 0x3FF921FB, 0x54442D18
+var PI = 2.0 * FLOAT64_HALF_PI;         // 0x400921FB, 0x54442D18
+var THREE_PIO2 = 3.0 * FLOAT64_HALF_PI; // 0x4012D97C, 0x7F3321D2
+var TWO_PI = 4.0 * FLOAT64_HALF_PI;     // 0x401921FB, 0x54442D18
+
+// Array for storing the remainder element:
+var Y = [ 0.0 ];
+
+
+// MAIN //
+
+/**
+* Simultaneously computes the sine and cosine of a single-precision floating-point number (in radians) and assigns the results to a provided output array.
+*
+* ## Method
+*
+* -   Let \\(S\\), \\(C\\), and \\(T\\) denote the \\(\sin\\), \\(\cos\\) and \\(\tan\\), respectively, on \\(\[-\pi/4, +\pi/4\]\\).
+*
+* -   Reduce the argument \\(x\\) to \\(y = x-k\pi/2\\) in \\(\[-\pi/4, +\pi/4\]\\), and let \\(n = k \mod 4\\).
+*
+* -   We have
+*
+*     | n | sin(x) | cos(x) | tan(x) |
+*     | - | ------ | ------ | ------ |
+*     | 0 |    S   |    C   |   T    |
+*     | 1 |    C   |   -S   |  -1/T  |
+*     | 2 |   -S   |   -C   |   T    |
+*     | 3 |   -C   |    S   |  -1/T  |
+*
+* @private
+* @param {number} x - input value (in radians)
+* @param {Collection} out - output array
+* @param {integer} stride - output array stride
+* @param {NonNegativeInteger} offset - output array index offset
+* @returns {Collection} output array
+*
+* @example
+* var v = sincosf( 0.0, [ 0.0, 0.0 ], 1, 0 );
+* // returns [ ~0.0, ~1.0 ]
+*
+* @example
+* var v = sincosf( 3.141592653589793/2.0, [ 0.0, 0.0 ], 1, 0 );
+* // returns [ ~1.0, ~0.0 ]
+*
+* @example
+* var v = sincosf( -3.141592653589793/6.0, [ 0.0, 0.0 ], 1, 0 );
+* // returns [ ~-0.5, ~0.866 ]
+*
+* @example
+* var v = sincosf( NaN, [ 0.0, 0.0 ], 1, 0 );
+* // returns [ NaN, NaN ]
+*/
+function sincosf( x, out, stride, offset ) {
+	var tmp;
+	var hx;
+	var ix;
+	var n;
+
+	hx = toWordf( f32( x ) ) |0; // asm type annotation
+	ix = (hx & FLOAT32_ABS_MASK)|0; // asm type annotation
+
+	// Case: |x| ~<= π/4
+	if ( ix <= PIO4_WORD ) {
+		// Case: |x| < 2^-12
+		if ( ix < SMALL_WORD ) {
+			if ( (x|0) === 0 ) {
+				out[ offset ] = f32( x );
+				out[ offset+stride ] = f32( 1.0 );
+				return out;
+			}
+		}
+		return kernelSincosf( x, out, stride, offset );
+	}
+	// Case: |x| ~<= 5π/4
+	if ( ix <= FIVE_PIO4_WORD ) {
+		// Case: |x| ~<= 3π/4
+		if ( ix <= THREE_PIO4_WORD ) {
+			if ( hx > 0 ) {
+				kernelSincosf( x - PIO2, out, stride, offset );
+				tmp = f32( -out[ offset ] );
+				out[ offset ] = out[ offset+stride ];
+				out[ offset+stride ] = tmp;
+			} else {
+				kernelSincosf( x + PIO2, out, stride, offset );
+				tmp = f32( -out[ offset+stride ] );
+				out[ offset+stride ] = out[ offset ];
+				out[ offset ] = tmp;
+			}
+		} else {
+			if ( hx > 0 ) {
+				kernelSincosf( x - PI, out, stride, offset );
+			} else {
+				kernelSincosf( x + PI, out, stride, offset );
+			}
+			out[ offset ] = f32( -out[ offset ] );
+			out[ offset+stride ] = f32( -out[ offset+stride ] );
+		}
+		return out;
+	}
+	// Case: |x| ~<= 9π/4
+	if ( ix <= NINE_PIO4_WORD ) {
+		// Case: |x| ~<= 7π/4
+		if ( ix <= SEVEN_PIO4_WORD ) {
+			if ( hx > 0 ) {
+				kernelSincosf( x - THREE_PIO2, out, stride, offset );
+				tmp = f32( -out[ offset+stride ] );
+				out[ offset+stride ] = out[ offset ];
+				out[ offset ] = tmp;
+			} else {
+				kernelSincosf( x + THREE_PIO2, out, stride, offset );
+				tmp = f32( -out[ offset ] );
+				out[ offset ] = out[ offset+stride ];
+				out[ offset+stride ] = tmp;
+			}
+		} else if ( hx > 0 ) {
+			kernelSincosf( x - TWO_PI, out, stride, offset );
+		} else {
+			kernelSincosf( x + TWO_PI, out, stride, offset );
+		}
+		return out;
+	}
+	// Case: x is NaN or infinity
+	if ( ix >= FLOAT32_EXPONENT_MASK ) {
+		out[ offset ] = NaN;
+		out[ offset+stride ] = NaN;
+		return out;
+	}
+	// Argument reduction...
+	n = rempio2f( f32( x ), Y );
+
+	// Compute the sine and cosine together:
+	kernelSincosf( Y[ 0 ], out, stride, offset );
+
+	switch ( n & 3 ) {
+	case 0:
+		return out;
+	case 1:
+		tmp = out[ offset+stride ];
+		out[ offset+stride ] = f32( -out[ offset ] );
+		out[ offset ] = tmp;
+		return out;
+	case 2:
+		out[ offset ] = f32( -out[ offset ] );
+		out[ offset+stride ] = f32( -out[ offset+stride ] );
+		return out;
+	default:
+		tmp = f32( -out[ offset+stride ] );
+		out[ offset+stride ] = out[ offset ];
+		out[ offset ] = tmp;
+		return out;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = sincosf;

package/lib/index.js

@@ -0,0 +1,68 @@
+/**
+* @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';
+
+/**
+* Simultaneously compute the sine and cosine of a single-precision floating-point number (in radians).
+*
+* @module @stdlib/math-base-special-sincosf
+*
+* @example
+* var sincosf = require( '@stdlib/math-base-special-sincosf' );
+*
+* var v = sincosf( 0.0 );
+* // returns [ ~0.0, ~1.0 ]
+*
+* v = sincosf( 3.141592653589793/2.0 );
+* // returns [ ~1.0, ~0.0 ]
+*
+* v = sincosf( -3.141592653589793/6.0 );
+* // returns [ ~-0.5, ~0.866 ]
+*
+* v = sincosf( NaN );
+* // returns [ NaN, NaN ]
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var sincosf = require( '@stdlib/math-base-special-sincosf' );
+*
+* var out = new Float32Array( 2 );
+*
+* var v = sincosf.assign( 0.0, out, 1, 0 );
+* // returns <Float32Array>[ ~0.0, ~1.0 ]
+*
+* var bool = ( v === out );
+* // returns true
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var main = require( './main.js' );
+var assign = require( './assign.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'assign', assign );
+
+
+// EXPORTS //
+
+module.exports = main;

package/lib/main.js

@@ -0,0 +1,57 @@
+/**
+* @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 assign = require( './assign.js' );
+
+
+// MAIN //
+
+/**
+* Simultaneously computes the sine and cosine of a single-precision floating-point number (in radians).
+*
+* @param {number} x - input value (in radians)
+* @returns {Array<number>} sine and cosine
+*
+* @example
+* var v = sincosf( 0.0 );
+* // returns [ ~0.0, ~1.0 ]
+*
+* @example
+* var v = sincosf( 3.141592653589793/2.0 );
+* // returns [ ~1.0, ~0.0 ]
+*
+* @example
+* var v = sincosf( -3.141592653589793/6.0 );
+* // returns [ ~-0.5, ~0.866 ]
+*
+* @example
+* var v = sincosf( NaN );
+* // returns [ NaN, NaN ]
+*/
+function sincosf( x ) {
+	return assign( x, [ 0.0, 0.0 ], 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = sincosf;

package/lib/native.js

@@ -0,0 +1,61 @@
+/**
+* @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 Float32Array = require( '@stdlib/array-float32' );
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Simultaneously computes the sine and cosine of a single-precision floating-point number (in radians).
+*
+* @private
+* @param {number} x - input value (in radians)
+* @returns {Float32Array} sine and cosine
+*
+* @example
+* var v = sincosf( 0.0 );
+* // returns <Float32Array>[ ~0.0, ~1.0 ]
+*
+* @example
+* var v = sincosf( 3.141592653589793/2.0 );
+* // returns <Float32Array>[ ~1.0, ~0.0 ]
+*
+* @example
+* var v = sincosf( -3.141592653589793/6.0 );
+* // returns <Float32Array>[ ~-0.5, ~0.866 ]
+*
+* @example
+* var v = sincosf( NaN );
+* // returns <Float32Array>[ NaN, NaN ]
+*/
+function sincosf( x ) {
+	var out = new Float32Array( 2 );
+	addon( x, out );
+	return out;
+}
+
+
+// EXPORTS //
+
+module.exports = sincosf;

package/manifest.json

@@ -0,0 +1,90 @@
+{
+  "options": {
+    "task": "build"
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/napi-argv",
+        "@stdlib/napi-argv-float",
+        "@stdlib/napi-argv-float32array",
+        "@stdlib/napi-export",
+        "@stdlib/math-base-special-kernel-sincosf",
+        "@stdlib/math-base-special-rempio2f",
+        "@stdlib/number-float32-base-to-word",
+        "@stdlib/constants-float64-half-pi",
+        "@stdlib/constants-float32-exponent-mask",
+        "@stdlib/constants-float32-abs-mask"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math-base-special-kernel-sincosf",
+        "@stdlib/math-base-special-rempio2f",
+        "@stdlib/number-float32-base-to-word",
+        "@stdlib/constants-float64-half-pi",
+        "@stdlib/constants-float32-exponent-mask",
+        "@stdlib/constants-float32-abs-mask"
+      ]
+    },
+    {
+      "task": "examples",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math-base-special-kernel-sincosf",
+        "@stdlib/math-base-special-rempio2f",
+        "@stdlib/number-float32-base-to-word",
+        "@stdlib/constants-float64-half-pi",
+        "@stdlib/constants-float32-exponent-mask",
+        "@stdlib/constants-float32-abs-mask"
+      ]
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@stdlib/math-base-special-sincosf",
+  "version": "0.1.0",
+  "description": "Simultaneously compute the sine and cosine of a single-precision floating-point number (in radians).",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "gypfile": false,
+  "directories": {
+    "doc": "./docs",
+    "include": "./include",
+    "lib": "./lib",
+    "src": "./src",
+    "dist": "./dist"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://stdlib.io",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/math-base-special-sincosf.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {
+    "@stdlib/constants-float32-abs-mask": "^0.2.2",
+    "@stdlib/constants-float32-exponent-mask": "^0.2.2",
+    "@stdlib/constants-float64-half-pi": "^0.2.2",
+    "@stdlib/math-base-special-kernel-sincosf": "github:stdlib-js/math-base-special-kernel-sincosf#main",
+    "@stdlib/math-base-special-rempio2f": "github:stdlib-js/math-base-special-rempio2f#main",
+    "@stdlib/napi-argv": "^0.2.2",
+    "@stdlib/napi-argv-float": "^0.2.2",
+    "@stdlib/napi-argv-float32array": "^0.2.2",
+    "@stdlib/napi-export": "^0.3.0",
+    "@stdlib/number-float32-base-to-word": "^0.2.2",
+    "@stdlib/number-float64-base-to-float32": "^0.2.2",
+    "@stdlib/utils-define-nonenumerable-read-only-property": "^0.2.2",
+    "@stdlib/utils-library-manifest": "^0.2.3"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "mathematics",
+    "math",
+    "math.sin",
+    "math.cos",
+    "sin",
+    "cos",
+    "sincos",
+    "sincosf",
+    "sine",
+    "cosine",
+    "trig",
+    "trigonometry",
+    "radians"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/stdlib"
+  }
+}

package/src/addon.c

@@ -0,0 +1,41 @@
+/**
+* @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.
+*/
+
+#include "stdlib/math/base/special/sincosf.h"
+#include "stdlib/napi/argv.h"
+#include "stdlib/napi/argv_float.h"
+#include "stdlib/napi/argv_float32array.h"
+#include "stdlib/napi/export.h"
+#include <node_api.h>
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 2 );
+	STDLIB_NAPI_ARGV_FLOAT( env, x, argv, 0 );
+	STDLIB_NAPI_ARGV_FLOAT32ARRAY( env, y, ylen, argv, 1 );
+	stdlib_base_sincosf( x, &y[ 0 ], &y[ 1 ] );
+	return NULL;
+}
+
+STDLIB_NAPI_MODULE_EXPORT_FCN( addon )