From 67c0083b95cbcbc0d3933fec3f175f1cbb97f509 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Thu, 5 Dec 2024 00:05:29 +0530 Subject: [PATCH 01/18] feat: basic files added --- .../math/base/special/lucasf/README.md | 256 ++++++++++++++++++ .../math/base/special/lucasf/binding.gyp | 170 ++++++++++++ .../math/base/special/lucasf/include.gypi | 53 ++++ .../math/base/special/lucasf/manifest.json | 67 +++++ .../math/base/special/lucasf/package.json | 69 +++++ 5 files changed, 615 insertions(+) create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/README.md create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/binding.gyp create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/include.gypi create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/manifest.json create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/package.json diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md new file mode 100644 index 000000000000..b9bbe3dd3009 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md @@ -0,0 +1,256 @@ + + +# Lucas + +> Compute the nth [Lucas number][lucas-number] in single-precision floating-point format. + +
+ +The [Lucas numbers][lucas-number] are the integer sequence + + + +```math +2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, \ldots +``` + + + + + +The sequence is defined by the recurrence relation + + + +```math +L_n = \begin{cases}2 & \textrm{if}\ n = 0\\1 & \textrm{if}\ n = 1\\L_{n-1} + L_{n-2} & \textrm{if}\ n > 1\end{cases} +``` + + + + + +
+ + + +
+ +## Usage + +```javascript +var lucasf = require( '@stdlib/math/base/special/lucasf' ); +``` + +#### lucasf( n ) + +Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. + +```javascript +var v = lucasf( 0 ); +// returns 2 + +v = lucasf( 1 ); +// returns 1 + +v = lucasf( 2 ); +// returns 3 + +v = lucasf( 3 ); +// returns 4 + +v = lucasf( 34 ); +// returns 12752043 +``` + +If `n > 34`, the function returns `NaN`, as larger [Lucas numbers][lucas-number] cannot be safely represented in [single-precision floating-point format][ieee754]. + +```javascript +var v = lucasf( 35 ); +// returns NaN +``` + +If not provided a nonnegative integer value, the function returns `NaN`. + +```javascript +var v = lucasf( 3.14 ); +// returns NaN + +v = lucasf( -1 ); +// returns NaN +``` + +If provided `NaN`, the function returns `NaN`. + +```javascript +var v = lucasf( NaN ); +// returns NaN +``` + +
+ + + +
+ +
+ + + +
+ +## Examples + + + +```javascript +var lucasf = require( '@stdlib/math/base/special/lucasf' ); + +var v; +var i; + +for ( i = 0; i < 35; i++ ) { + v = lucasf( i ); + console.log( v ); +} +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/math/base/special/lucasf.h" +``` + +#### stdlib_base_lucasf( n ) + +Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. + +```c +float out = stdlib_base_lucasf( 0.0f ); +// returns 2.0f + +out = stdlib_base_lucasf( 1.0f ); +// returns 1.0f +``` + +The function accepts the following arguments: + +- **n**: `[in] int32_t` input value. + +```c +float stdlib_base_lucasf( const int32_t n ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/math/base/special/lucasf.h" +#include +#include + +int main( void ) { + int32_t i; + float v; + + for ( i = 0; i < 35; i++ ) { + v = stdlib_base_lucasf( i ); + printf( "lucasf(%d) = %f\n", i, v ); + } +} +``` + +
+ + + +
+ + + + + +
+ +
+ + + + + +
+ +[lucas-number]: https://en.wikipedia.org/wiki/Lucas_number + +[ieee754]: https://en.wikipedia.org/wiki/IEEE_754-1985 + + + + + +
+ + diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/binding.gyp b/lib/node_modules/@stdlib/math/base/special/lucasf/binding.gyp new file mode 100644 index 000000000000..ec3992233442 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/binding.gyp @@ -0,0 +1,170 @@ +# @license Apache-2.0 +# +# Copyright (c) 2024 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. + +# A `.gyp` file for building a Node.js native add-on. +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # List of files to include in this file: + 'includes': [ + './include.gypi', + ], + + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Target name should match the add-on export name: + 'addon_target_name%': 'addon', + + # Set variables based on the host OS: + 'conditions': [ + [ + 'OS=="win"', + { + # Define the object file suffix: + 'obj': 'obj', + }, + { + # Define the object file suffix: + 'obj': 'o', + } + ], # end condition (OS=="win") + ], # end conditions + }, # end variables + + # Define compile targets: + 'targets': [ + + # Target to generate an add-on: + { + # The target name should match the add-on export name: + 'target_name': '<(addon_target_name)', + + # Define dependencies: + 'dependencies': [], + + # Define directories which contain relevant include headers: + 'include_dirs': [ + # Local include directory: + '<@(include_dirs)', + ], + + # List of source files: + 'sources': [ + '<@(src_files)', + ], + + # Settings which should be applied when a target's object files are used as linker input: + 'link_settings': { + # Define libraries: + 'libraries': [ + '<@(libraries)', + ], + + # Define library directories: + 'library_dirs': [ + '<@(library_dirs)', + ], + }, + + # C/C++ compiler flags: + 'cflags': [ + # Enable commonly used warning options: + '-Wall', + + # Aggressive optimization: + '-O3', + ], + + # C specific compiler flags: + 'cflags_c': [ + # Specify the C standard to which a program is expected to conform: + '-std=c99', + ], + + # C++ specific compiler flags: + 'cflags_cpp': [ + # Specify the C++ standard to which a program is expected to conform: + '-std=c++11', + ], + + # Linker flags: + 'ldflags': [], + + # Apply conditions based on the host OS: + 'conditions': [ + [ + 'OS=="mac"', + { + # Linker flags: + 'ldflags': [ + '-undefined dynamic_lookup', + '-Wl,-no-pie', + '-Wl,-search_paths_first', + ], + }, + ], # end condition (OS=="mac") + [ + 'OS!="win"', + { + # C/C++ flags: + 'cflags': [ + # Generate platform-independent code: + '-fPIC', + ], + }, + ], # end condition (OS!="win") + ], # end conditions + }, # end target <(addon_target_name) + + # Target to copy a generated add-on to a standard location: + { + 'target_name': 'copy_addon', + + # Declare that the output of this target is not linked: + 'type': 'none', + + # Define dependencies: + 'dependencies': [ + # Require that the add-on be generated before building this target: + '<(addon_target_name)', + ], + + # Define a list of actions: + 'actions': [ + { + 'action_name': 'copy_addon', + 'message': 'Copying addon...', + + # Explicitly list the inputs in the command-line invocation below: + 'inputs': [], + + # Declare the expected outputs: + 'outputs': [ + '<(addon_output_dir)/<(addon_target_name).node', + ], + + # Define the command-line invocation: + 'action': [ + 'cp', + '<(PRODUCT_DIR)/<(addon_target_name).node', + '<(addon_output_dir)/<(addon_target_name).node', + ], + }, + ], # end actions + }, # end target copy_addon + ], # end targets +} diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/include.gypi b/lib/node_modules/@stdlib/math/base/special/lucasf/include.gypi new file mode 100644 index 000000000000..575cb043c0bf --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/include.gypi @@ -0,0 +1,53 @@ +# @license Apache-2.0 +# +# Copyright (c) 2024 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. + +# A GYP include file for building a Node.js native add-on. +# +# Main documentation: +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Source directory: + 'src_dir': './src', + + # Include directories: + 'include_dirs': [ + '=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "mathematics", + "math", + "special functions", + "special", + "function", + "fibonacci", + "lucas", + "fib", + "number", + "integer", + "sequences" + ] +} From 8d1b547ecfff2236e496805edf50004500348fe7 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Thu, 5 Dec 2024 16:10:12 +0530 Subject: [PATCH 02/18] feat: basic files added --- .../math/base/special/lucasf/README.md | 4 +- .../include/stdlib/math/base/special/lucasf.h | 40 ++++++++++ .../math/base/special/lucasf/src/Makefile | 70 ++++++++++++++++ .../math/base/special/lucasf/src/addon.c | 22 +++++ .../math/base/special/lucasf/src/main.c | 80 +++++++++++++++++++ 5 files changed, 214 insertions(+), 2 deletions(-) create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md index b9bbe3dd3009..d9c982df2907 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md @@ -174,10 +174,10 @@ for ( i = 0; i < 35; i++ ) { Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. ```c -float out = stdlib_base_lucasf( 0.0f ); +float out = stdlib_base_lucasf( 0 ); // returns 2.0f -out = stdlib_base_lucasf( 1.0f ); +out = stdlib_base_lucasf( 1 ); // returns 1.0f ``` diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h new file mode 100644 index 000000000000..efdb1e90e4b4 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h @@ -0,0 +1,40 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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_LUCASF_H +#define STDLIB_MATH_BASE_SPECIAL_LUCASF_H + +#include + +/* +* 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 + +/** +* Computes the nth Lucas number in single-precision floating-point format. +*/ +float stdlib_base_lucas( const int32_t n ); + +#ifdef __cplusplus +} +#endif + +#endif // !STDLIB_MATH_BASE_SPECIAL_LUCASF_H diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile b/lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile new file mode 100644 index 000000000000..904c7dc4bd7a --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile @@ -0,0 +1,70 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2023 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. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + + +# RULES # + +#/ +# Removes generated files for building an add-on. +# +# @example +# make clean-addon +#/ +clean-addon: + $(QUIET) -rm -f *.o *.node + +.PHONY: clean-addon + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: clean-addon + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c new file mode 100644 index 000000000000..4b5da1249404 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c @@ -0,0 +1,22 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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/lucasf.h" +#include "stdlib/math/base/napi/unary.h" + +STDLIB_MATH_BASE_NAPI_MODULE_I_F( stdlib_base_lucasf ) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c new file mode 100644 index 000000000000..922f5fcb2a9a --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c @@ -0,0 +1,80 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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/lucasf.h" + +static const int32_t STDLIB_CONSTANT_FLOAT32_MAX_SAFE_NTH_LUCAS = 34; + +static const int32_t lucas_value[ 35 ] = { + 2, + 1, + 3, + 4, + 7, + 11, + 18, + 29, + 47, + 76, + 123, + 199, + 322, + 521, + 843, + 1364, + 2207, + 3571, + 5778, + 9349, + 15127, + 24476, + 39603, + 64079, + 103682, + 167761, + 271443, + 439204, + 710647, + 1149851, + 1860498, + 3010349, + 4870847, + 7881196, + 12752043 +}; + +/** +* Computes the nth Lucas number in single-precision floating-point format. +* +* @param n input value +* @return output value +* +* @example +* float out = stdlib_base_lucasf( 1 ); +* // returns 1.0f +* +* @example +* float out = stdlib_base_lucasf( -1 ); +* // returns NaN +*/ +float stdlib_base_lucasf( const int32_t n ) { + if ( n < 0 || n > STDLIB_CONSTANT_FLOAT32_MAX_SAFE_NTH_LUCAS ) { + return 0.0f / 0.0f; // NaN + } + return lucas_value[ n ]; +} From 26c72a12af57a767f5b6e6520f06281ec62f9be2 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Thu, 5 Dec 2024 16:36:29 +0530 Subject: [PATCH 03/18] feat: tests added --- .../include/stdlib/math/base/special/lucasf.h | 2 +- .../math/base/special/lucasf/lib/index.js | 58 ++++++++++++ .../math/base/special/lucasf/lib/lucas.json | 1 + .../math/base/special/lucasf/lib/main.js | 92 +++++++++++++++++++ .../math/base/special/lucasf/lib/native.js | 74 +++++++++++++++ .../math/base/special/lucasf/src/Makefile | 2 +- .../math/base/special/lucasf/src/addon.c | 1 + .../math/base/special/lucasf/test/test.js | 92 +++++++++++++++++++ .../base/special/lucasf/test/test.native.js | 79 ++++++++++++++++ 9 files changed, 399 insertions(+), 2 deletions(-) create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/lib/lucas.json create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h index efdb1e90e4b4..13b00041d64d 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h @@ -31,7 +31,7 @@ extern "C" { /** * Computes the nth Lucas number in single-precision floating-point format. */ -float stdlib_base_lucas( const int32_t n ); +float stdlib_base_lucasf( const int32_t n ); #ifdef __cplusplus } diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js new file mode 100644 index 000000000000..cc55a0cb05d1 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js @@ -0,0 +1,58 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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'; + +/** +* Compute the nth Lucas number in single-precision floating-point format. +* +* @module @stdlib/math/base/special/lucasf +* +* @example +* var lucasf = require( '@stdlib/math/base/special/lucasf' ); +* +* var y = lucasf( 0 ); +* // returns 2 +* +* y = lucasf( 1 ); +* // returns 1 +* +* y = lucasf( 2 ); +* // returns 3 +* +* y = lucasf( 3 ); +* // returns 4 +* +* y = lucasf( 4 ); +* // returns 7 +* +* y = lucasf( 5 ); +* // returns 11 +* +* y = lucasf( 6 ); +* // returns 18 +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/lucas.json b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/lucas.json new file mode 100644 index 000000000000..adace3c18e52 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/lucas.json @@ -0,0 +1 @@ +[2,1,3,4,7,11,18,29,47,76,123,199,322,521,843,1364,2207,3571,5778,9349,15127,24476,39603,64079,103682,167761,271443,439204,710647,1149851,1860498,3010349,4870847,7881196,12752043] diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js new file mode 100644 index 000000000000..f80a4ab111c0 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js @@ -0,0 +1,92 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var isIntegerf = require( '@stdlib/math/base/assert/is-integerf' ); +var MAX_LUCAS = 34; +var LUCAS = require( './lucas.json' ); + + +// MAIN // + +/** +* Computes the nth Lucas number in single-precision floating-point format. +* +* @param {NonNegativeInteger} n - the Lucas number to compute +* @returns {NonNegativeInteger} Lucas number +* +* @example +* var y = lucasf( 0 ); +* // returns 2 +* +* @example +* var y = lucasf( 1 ); +* // returns 1 +* +* @example +* var y = lucasf( 2 ); +* // returns 3 +* +* @example +* var y = lucasf( 3 ); +* // returns 4 +* +* @example +* var y = lucasf( 4 ); +* // returns 7 +* +* @example +* var y = lucasf( 5 ); +* // returns 11 +* +* @example +* var y = lucasf( 6 ); +* // returns 18 +* +* @example +* var y = lucasf( NaN ); +* // returns NaN +* +* @example +* var y = lucasf( 3.14 ); +* // returns NaN +* +* @example +* var y = lucasf( -1.0 ); +* // returns NaN +*/ +function lucasf( n ) { + if ( + isnanf( n ) || + isIntegerf( n ) === false || + n < 0 || + n > MAX_LUCAS + ) { + return NaN; + } + return LUCAS[ n ]; +} + + +// EXPORTS // + +module.exports = lucasf; diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js new file mode 100644 index 000000000000..bcb11fe34420 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js @@ -0,0 +1,74 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Computes the nth Lucas number in single-precision floating-point format. +* +* @private +* @param {NonNegativeInteger} n - the Lucas number to compute +* @returns {NonNegativeInteger} Lucas number +* +* @example +* var y = lucasf( 0 ); +* // returns 2 +* +* @example +* var y = lucasf( 1 ); +* // returns 1 +* +* @example +* var y = lucasf( 2 ); +* // returns 3 +* +* @example +* var y = lucasf( 3 ); +* // returns 4 +* +* @example +* var y = lucasf( 4 ); +* // returns 7 +* +* @example +* var y = lucasf( 5 ); +* // returns 11 +* +* @example +* var y = lucasf( 6 ); +* // returns 18 +* +* @example +* var y = lucasf( -1.0 ); +* // returns NaN +*/ +function lucasf( n ) { + return addon( n ); +} + + +// EXPORTS // + +module.exports = lucasf; diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile b/lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile index 904c7dc4bd7a..bcf18aa46655 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/Makefile @@ -1,7 +1,7 @@ #/ # @license Apache-2.0 # -# Copyright (c) 2023 The Stdlib Authors. +# Copyright (c) 2024 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. diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c index 4b5da1249404..feca2cce2137 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/addon.c @@ -19,4 +19,5 @@ #include "stdlib/math/base/special/lucasf.h" #include "stdlib/math/base/napi/unary.h" +// cppcheck-suppress shadowFunction STDLIB_MATH_BASE_NAPI_MODULE_I_F( stdlib_base_lucasf ) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js new file mode 100644 index 000000000000..c8765a8ffb61 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js @@ -0,0 +1,92 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 tape = require( 'tape' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var PINF = require( '@stdlib/constants/float32/pinf' ); +var lucasf = require( './../lib' ); + + +// FIXTURES // + +// For reference values, see https://oeis.org/A000032: +var LUCAS = require( './../lib/lucas.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof lucasf, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'if provided a negative number, the function returns `NaN`', function test( t ) { + var v; + var i; + + t.strictEqual( isnanf( lucasf( -3.14 ) ), true, 'returns NaN' ); + + for ( i = -1; i > -100; i-- ) { + v = lucasf( i ); + t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + } + t.end(); +}); + +tape( 'if provided positive infinity, the function returns `NaN`', function test( t ) { + var v = lucasf( PINF ); + t.strictEqual( isnanf( v ), true, 'returns NaN when provided +infinity' ); + t.end(); +}); + +tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) { + var v = lucasf( NaN ); + t.strictEqual( isnanf( v ), true, 'returns NaN when provided a NaN' ); + t.end(); +}); + +tape( 'if provided a non-integer, the function returns `NaN`', function test( t ) { + var v = lucasf( 3.14 ); + t.strictEqual( isnanf( v ), true, 'returns NaN' ); + t.end(); +}); + +tape( 'the function returns the nth Lucas number', function test( t ) { + var v; + var i; + for ( i = 0; i < 35; i++ ) { + v = lucasf( i ); + t.strictEqual( v, LUCAS[ i ], 'returns the '+i+'th Lucas number' ); + } + t.end(); +}); + +tape( 'if provided nonnegative integers greater than `34`, the function returns `NaN`', function test( t ) { + var i; + var v; + for ( i = 35; i < 500; i++ ) { + v = lucasf( i ); + t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + } + t.end(); +}); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js new file mode 100644 index 000000000000..d39d7bf62bbf --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js @@ -0,0 +1,79 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 tape = require( 'tape' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// FIXTURES // + +var LUCAS = require( './../lib/lucas.json' ); + + +// VARIABLES // + +var lucasf = tryRequire( resolve( __dirname, './../lib/native.js' ) ); +var opts = { + 'skip': ( lucasf instanceof Error ) +}; + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof lucasf, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'if provided a negative number, the function returns `NaN`', opts, function test( t ) { + var v; + var i; + + for ( i = -1; i > -100; i-- ) { + v = lucasf( i ); + t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + } + t.end(); +}); + +tape( 'the function returns the nth Lucas number', opts, function test( t ) { + var v; + var i; + for ( i = 0; i < 35; i++ ) { + v = lucasf( i ); + t.strictEqual( v, LUCAS[ i ], 'returns the '+i+'th Lucas number' ); + } + t.end(); +}); + +tape( 'if provided nonnegative integers less than `34`, the function returns `NaN`', opts, function test( t ) { + var i; + var v; + for ( i = 35; i < 500; i++ ) { + v = lucasf( i ); + t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + } + t.end(); +}); From 12a3f668c9e78cfbd496456ede7679072689475d Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Thu, 5 Dec 2024 17:41:52 +0530 Subject: [PATCH 04/18] feat: add math/base/special/lucasf --- .../special/lucasf/benchmark/benchmark.js | 282 ++++++++++++++++++ .../lucasf/benchmark/benchmark.native.js | 61 ++++ .../base/special/lucasf/benchmark/c/Makefile | 127 ++++++++ .../special/lucasf/benchmark/c/benchmark.c | 148 +++++++++ .../lucasf/benchmark/c/native/Makefile | 146 +++++++++ .../lucasf/benchmark/c/native/benchmark.c | 133 +++++++++ .../equation_lucas_recurrence_relation.svg | 78 +++++ .../docs/img/equation_lucas_sequence.svg | 71 +++++ .../math/base/special/lucasf/docs/repl.txt | 49 +++ .../base/special/lucasf/docs/types/index.d.ts | 78 +++++ .../base/special/lucasf/docs/types/test.ts | 44 +++ .../base/special/lucasf/examples/c/Makefile | 146 +++++++++ .../base/special/lucasf/examples/c/example.c | 31 ++ .../base/special/lucasf/examples/index.js | 29 ++ 14 files changed, 1423 insertions(+) create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/Makefile create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/Makefile create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_recurrence_relation.svg create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_sequence.svg create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/Makefile create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c create mode 100644 lib/node_modules/@stdlib/math/base/special/lucasf/examples/index.js diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js new file mode 100644 index 000000000000..1f9ce236dac2 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js @@ -0,0 +1,282 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 bench = require( '@stdlib/bench' ); +var randu = require( '@stdlib/random/base/randu' ); +var floorf = require( '@stdlib/math/base/special/floorf' ); +var roundf = require( '@stdlib/math/base/special/roundf' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var PHI = require( '@stdlib/constants/float32/phi' ); +var pkg = require( './../package.json' ).name; +var LUCAS = require( './../lib/lucas.json' ); +var lucasf = require( './../lib' ); + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var x; + var y; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 35.0 ); + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::analytic', function benchmark( b ) { + var x; + var y; + var i; + + function lucasf( n ) { + return roundf( pow( PHI, n ) ); + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 35.0 ); + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::table', function benchmark( b ) { + var x; + var y; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 35.0 ); + y = LUCAS[ x ]; + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::naive_recursion', function benchmark( b ) { + var x; + var y; + var i; + + function lucasf( n ) { + if ( n === 0 ) { + return 2; + } + if ( n === 1 ) { + return 1; + } + return lucasf( n-1 ) + lucasf( n-2 ); + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 40.0 ); // limit upper bound + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::recursion_memoized', function benchmark( b ) { + var arr; + var N; + var x; + var y; + var i; + + arr = new Array( 35 ); + arr[ 0 ] = 2; + arr[ 1 ] = 1; + N = 1; + + function lucasf( n ) { + if ( n <= N ) { + return arr[ n ]; + } + arr[ n ] = lucasf( n-1 ) + lucasf( n-2 ); + return arr[ n ]; + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 40.0 ); // limit upper bound + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::naive_iterative', function benchmark( b ) { + var x; + var y; + var i; + + function lucasf( n ) { + var arr; + var i; + + arr = new Array( n+1 ); + arr[ 0 ] = 2; + arr[ 1 ] = 1; + for ( i = 2; i <= n; i++ ) { + arr[ i ] = arr[ i-1 ] + arr[ i-2 ]; + } + return arr[ n ]; + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 35.0 ); + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::iterative', function benchmark( b ) { + var x; + var y; + var i; + + function lucasf( n ) { + var a; + var b; + var c; + var i; + + a = 2; + if ( n === 0 ) { + return a; + } + b = 1; + for ( i = 2; i <= n; i++ ) { + c = a + b; + a = b; + b = c; + } + return b; + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 35.0 ); + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::iterative_memoized', function benchmark( b ) { + var arr; + var N; + var x; + var y; + var i; + + arr = new Array( 35 ); + arr[ 0 ] = 2; + arr[ 1 ] = 1; + N = 1; + + function lucasf( n ) { + var i; + if ( n > N ) { + for ( i = N+1; i <= n; i++ ) { + arr[ i ] = arr[ i-1 ] + arr[ i-2 ]; + } + N = n; + } + return arr[ n ]; + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 35.0 ); + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js new file mode 100644 index 000000000000..5223a1532863 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js @@ -0,0 +1,61 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 bench = require( '@stdlib/bench' ); +var randu = require( '@stdlib/random/base/randu' ); +var floorf = require( '@stdlib/math/base/special/floorf' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var lucasf = tryRequire( resolve( __dirname, './../lib/native.js' ) ); +var opts = { + 'skip': ( lucasf instanceof Error ) +}; + + +// MAIN // + +bench( pkg+'::native', opts, function benchmark( b ) { + var x; + var y; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + x = floorf( randu() * 34.0 ); + y = lucasf( x ); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( y ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/Makefile b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/Makefile new file mode 100644 index 000000000000..e85bfcccdd04 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/Makefile @@ -0,0 +1,127 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2024 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. +#/ + + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of C targets: +c_targets := benchmark.out + + +# RULES # + +#/ +# Compiles C source files. +# +# @param {string} [C_COMPILER] - C compiler +# @param {string} [CFLAGS] - C compiler flags +# @param {(string|void)} [fPIC] - compiler flag indicating whether to generate position independent code +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler +# @param {string} CFLAGS - C compiler flags +# @param {(string|void)} fPIC - compiler flag indicating whether to generate position independent code +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) -o $@ $< -lm + +#/ +# Runs compiled benchmarks. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c new file mode 100644 index 000000000000..fddab3e54d21 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c @@ -0,0 +1,148 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 +#include +#include +#include +#include + +#define NAME "lucasf::naive_recursion" +#define ITERATIONS 100 +#define REPEATS 3 + +/** +* Prints the TAP version. +*/ +static void print_version( void ) { + printf( "TAP version 13\n" ); +} + +/** +* Prints the TAP summary. +* +* @param total total number of tests +* @param passing total number of passing tests +*/ +static void print_summary( int total, int passing ) { + printf( "#\n" ); + printf( "1..%d\n", total ); // TAP plan + printf( "# total %d\n", total ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + printf( "# ok\n" ); +} + +/** +* Prints benchmarks results. +* +* @param elapsed elapsed time in seconds +*/ +static void print_results( double elapsed ) { + double rate = (double)ITERATIONS / elapsed; + printf( " ---\n" ); + printf( " iterations: %d\n", ITERATIONS ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " rate: %0.9f\n", rate ); + printf( " ...\n" ); +} + +/** +* Returns a clock time. +* +* @return clock time +*/ +static double tic( void ) { + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; +} + +/** +* Generates a random number on the interval [0,1). +* +* @return random number +*/ +static float rand_float( void ) { + int r = rand(); + return (float)r / ( (float)RAND_MAX + 1.0f ); +} + +/** +* Computes the nth Lucas number in single-precision floating-point format. +* +* @param n Lucas number to compute +* @return Lucas number +*/ +int lucasf( int n ) { + if ( n == 0 ) { + return 2; + } + if ( n == 1 ) { + return 1; + } + return lucasf( n-1 ) + lucasf( n-2 ); +} + +/** +* Runs a benchmark. +* +* @return elapsed time in seconds +*/ +static double benchmark( void ) { + double elapsed; + double t; + int x; + int y; + int i; + + t = tic(); + for ( i = 0; i < ITERATIONS; i++ ) { + x = (int)floorf( 30.0f * rand_float() ); + y = lucasf( x ); + if ( y < 0 ) { + printf( "should return a nonnegative integer\n" ); + break; + } + } + elapsed = tic() - t; + if ( y < 0 ) { + printf( "should return a nonnegative integer\n" ); + } + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + double elapsed; + int i; + + // Use the current time to seed the random number generator: + srand( time( NULL ) ); + + print_version(); + for ( i = 0; i < REPEATS; i++ ) { + printf( "# c::%s\n", NAME ); + elapsed = benchmark(); + print_results( elapsed ); + printf( "ok %d benchmark finished\n", i+1 ); + } + print_summary( REPEATS, REPEATS ); +} diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/Makefile b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/Makefile new file mode 100644 index 000000000000..f69e9da2b4d3 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2024 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. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := benchmark.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled benchmarks. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c new file mode 100644 index 000000000000..953d226f1e1f --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c @@ -0,0 +1,133 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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/lucasf.h" +#include +#include +#include +#include +#include + +#define NAME "lucas" +#define ITERATIONS 100 +#define REPEATS 3 + +/** +* Prints the TAP version. +*/ +void print_version() { + printf( "TAP version 13\n" ); +} + +/** +* Prints the TAP summary. +* +* @param total total number of tests +* @param passing total number of passing tests +*/ +static void print_summary( int total, int passing ) { + printf( "#\n" ); + printf( "1..%d\n", total ); // TAP plan + printf( "# total %d\n", total ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + printf( "# ok\n" ); +} + +/** +* Prints benchmarks results. +* +* @param elapsed elapsed time in seconds +*/ +static void print_results( double elapsed ) { + double rate = (double)ITERATIONS / elapsed; + printf( " ---\n" ); + printf( " iterations: %d\n", ITERATIONS ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " rate: %0.9f\n", rate ); + printf( " ...\n" ); +} + +/** +* Returns a clock time. +* +* @return clock time +*/ +static double tic( void ) { + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; +} + +/** +* Generates a random number on the interval [0,1). +* +* @return random number +*/ +static float rand_float( void ) { + int r = rand(); + return (float)r / ( (float)RAND_MAX + 1.0f ); +} + +/** +* Runs a benchmark. +* +* @return elapsed time in seconds +*/ +static double benchmark( void ) { + double elapsed; + int32_t x; + double t; + float y; + int i; + + t = tic(); + for ( i = 0; i < ITERATIONS; i++ ) { + x = (int32_t)( 34.0f * rand_double() ); + y = stdlib_base_lucasf( x ); + if ( y != y ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( y != y ) { + printf( "should not return NaN\n" ); + } + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + double elapsed; + int i; + + // Use the current time to seed the random number generator: + srand( time( NULL ) ); + + print_version(); + for ( i = 0; i < REPEATS; i++ ) { + printf( "# c::native::%s\n", NAME ); + elapsed = benchmark(); + print_results( elapsed ); + printf( "ok %d benchmark finished\n", i+1 ); + } + print_summary( REPEATS, REPEATS ); +} diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_recurrence_relation.svg b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_recurrence_relation.svg new file mode 100644 index 000000000000..e2c3d6ada501 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_recurrence_relation.svg @@ -0,0 +1,78 @@ + +upper L Subscript n Baseline equals StartLayout Enlarged left-brace 1st Row 1st Column 2 2nd Column if n equals 0 2nd Row 1st Column 1 2nd Column if n equals 1 3rd Row 1st Column upper L Subscript n minus 1 Baseline plus upper L Subscript n minus 2 Baseline 2nd Column if n greater-than 1 EndLayout + + + \ No newline at end of file diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_sequence.svg b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_sequence.svg new file mode 100644 index 000000000000..244a9b9b00b9 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/img/equation_lucas_sequence.svg @@ -0,0 +1,71 @@ + +2 comma 1 comma 3 comma 4 comma 7 comma 11 comma 18 comma 29 comma 47 comma 76 comma 123 comma 199 comma 322 comma ellipsis + + + \ No newline at end of file diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt new file mode 100644 index 000000000000..c724fec5fc9c --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt @@ -0,0 +1,49 @@ + +{{alias}}( n ) + Computes the nth Lucas number in single-precision + floating-point format. + + Lucas numbers follow the recurrence relation + + L_n = L_{n-1} + L_{n-2} + + with seed values L_0 = 2 and L_1 = 1. + + If `n` is greater than `34`, the function returns `NaN`, as larger Lucas + numbers cannot be accurately represented due to limitations of single- + precision floating-point format. + + If not provided a nonnegative integer value, the function returns `NaN`. + + If provided `NaN`, the function returns `NaN`. + + Parameters + ---------- + n: integer + Input value. + + Returns + ------- + y: integer + Lucas number. + + Examples + -------- + > var y = {{alias}}( 0 ) + 2 + > y = {{alias}}( 1 ) + 1 + > y = {{alias}}( 2 ) + 3 + > y = {{alias}}( 3 ) + 4 + > y = {{alias}}( 4 ) + 7 + > y = {{alias}}( 35 ) + NaN + > y = {{alias}}( NaN ) + NaN + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts new file mode 100644 index 000000000000..a57aa6879590 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts @@ -0,0 +1,78 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2019 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. +*/ + +// TypeScript Version: 4.1 + +/** +* Computes the nth Lucas number in single-precision floating-point format. +* +* ## Notes +* +* - Lucas numbers follow the recurrence relation `L_n = L_{n-1} + L_{n-2}` with seed values `L_0 = 2` and `L_1 = 1`. +* - If `n` is greater than `34`, the function returns `NaN`, as larger Lucas numbers cannot be accurately represented due to limitations of single-precision floating-point format. +* - If not provided a nonnegative integer value, the function returns `NaN`. +* +* @param n - the Lucas number to compute +* @returns Lucas number +* +* @example +* var y = lucasf( 0 ); +* // returns 2 +* +* @example +* var y = lucasf( 1 ); +* // returns 1 +* +* @example +* var y = lucasf( 2 ); +* // returns 3 +* +* @example +* var y = lucasf( 3 ); +* // returns 4 +* +* @example +* var y = lucasf( 4 ); +* // returns 7 +* +* @example +* var y = lucasf( 5 ); +* // returns 11 +* +* @example +* var y = lucasf( 6 ); +* // returns 18 +* +* @example +* var y = lucasf( NaN ); +* // returns NaN +* +* @example +* var y = lucasf( 3.14 ); +* // returns NaN +* +* @example +* var y = lucasf( -1.0 ); +* // returns NaN +*/ +declare function lucasf( n: number ): number; + + +// EXPORTS // + +export = lucasf; diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/test.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/test.ts new file mode 100644 index 000000000000..5a14778ff8e2 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/test.ts @@ -0,0 +1,44 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2024 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. +*/ + +import lucasf = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + lucasf( 8 ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a value other than a number... +{ + lucasf( true ); // $ExpectError + lucasf( false ); // $ExpectError + lucasf( null ); // $ExpectError + lucasf( undefined ); // $ExpectError + lucasf( '5' ); // $ExpectError + lucasf( [] ); // $ExpectError + lucasf( {} ); // $ExpectError + lucasf( ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided insufficient arguments... +{ + lucasf(); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/Makefile b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/Makefile new file mode 100644 index 000000000000..6aed70daf167 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2024 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. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := example.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled examples. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c new file mode 100644 index 000000000000..c2e60e4680a5 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c @@ -0,0 +1,31 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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/lucasf.h" +#include +#include + +int main( void ) { + int32_t i; + float v; + + for ( i = 0; i < 35; i++ ) { + v = stdlib_base_lucasf( i ); + printf( "lucasf(%d) = %f\n", i, v ); + } +} diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/examples/index.js b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/index.js new file mode 100644 index 000000000000..60e93828e0f3 --- /dev/null +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/index.js @@ -0,0 +1,29 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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'; + +var lucasf = require( './../lib' ); + +var v; +var i; + +for ( i = 0; i < 35; i++ ) { + v = lucasf( i ); + console.log( v ); +} From ca173bd528fbdce7929a429d93ab36a7368a69c2 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Fri, 6 Dec 2024 11:00:10 +0000 Subject: [PATCH 05/18] chore: update copyright years --- .../@stdlib/math/base/special/lucasf/docs/types/index.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts index a57aa6879590..a1c7973d449f 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts @@ -1,7 +1,7 @@ /* * @license Apache-2.0 * -* Copyright (c) 2019 The Stdlib Authors. +* Copyright (c) 2024 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. From 0a221ceb632bc188ad1fc247a83081c6da7d0b6e Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Fri, 6 Dec 2024 16:37:25 +0530 Subject: [PATCH 06/18] fix: bugs removed --- .../math/base/special/lucasf/benchmark/c/native/benchmark.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c index 953d226f1e1f..2d21e000993d 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c @@ -98,7 +98,7 @@ static double benchmark( void ) { t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { - x = (int32_t)( 34.0f * rand_double() ); + x = (int32_t)( 34.0f * rand_float() ); y = stdlib_base_lucasf( x ); if ( y != y ) { printf( "should not return NaN\n" ); From 66a0a8c6229f3ab31ff8cccd714e8b51071e9311 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Fri, 6 Dec 2024 16:52:31 +0530 Subject: [PATCH 07/18] feat: updated benchmarks with pre-computation --- .../math/base/special/lucasf/benchmark/benchmark.js | 2 +- .../base/special/lucasf/benchmark/benchmark.native.js | 8 ++++---- .../base/special/lucasf/benchmark/c/native/benchmark.c | 9 ++++++--- 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js index 1f9ce236dac2..b49401fe341e 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js @@ -154,7 +154,7 @@ bench( pkg+'::recursion_memoized', function benchmark( b ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 40.0 ); // limit upper bound + x = floorf( randu() * 35.0 ); // limit upper bound y = lucasf( x ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js index 5223a1532863..fde08e121c9b 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js @@ -22,8 +22,7 @@ var resolve = require( 'path' ).resolve; var bench = require( '@stdlib/bench' ); -var randu = require( '@stdlib/random/base/randu' ); -var floorf = require( '@stdlib/math/base/special/floorf' ); +var randu = require( '@stdlib/random/array/discrete-uniform' ); var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); var tryRequire = require( '@stdlib/utils/try-require' ); var pkg = require( './../package.json' ).name; @@ -44,10 +43,11 @@ bench( pkg+'::native', opts, function benchmark( b ) { var y; var i; + x = randu( 100, -50, 50 ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 34.0 ); - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c index 2d21e000993d..06c0be54bf88 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c @@ -91,15 +91,18 @@ static float rand_float( void ) { */ static double benchmark( void ) { double elapsed; - int32_t x; + int32_t x[ 100 ]; double t; float y; int i; + for ( i = 0 ; i < 100 ; i++ ) { + x[ i ] = ( int32_t )( 34.0f * rand_float() ); + } + t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { - x = (int32_t)( 34.0f * rand_float() ); - y = stdlib_base_lucasf( x ); + y = stdlib_base_lucasf( x[ i % 100 ] ); if ( y != y ) { printf( "should not return NaN\n" ); break; From d394f5f33315d968acb441c73adb8416c8906c47 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Fri, 6 Dec 2024 16:54:36 +0530 Subject: [PATCH 08/18] feat: updated benchmarks with pre-computation --- .../math/base/special/lucasf/benchmark/benchmark.native.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js index fde08e121c9b..e18a48cd3b0f 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.native.js @@ -43,7 +43,7 @@ bench( pkg+'::native', opts, function benchmark( b ) { var y; var i; - x = randu( 100, -50, 50 ); + x = randu( 100, 0, 34 ); b.tic(); for ( i = 0; i < b.iterations; i++ ) { From 6d63bdda5c9473f113fb7ad9cb41556761513167 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 10 Dec 2024 12:34:34 +0530 Subject: [PATCH 09/18] fix: image errors fix --- lib/node_modules/@stdlib/math/base/special/lucasf/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md index d9c982df2907..235b07d7ee20 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md @@ -33,7 +33,7 @@ The [Lucas numbers][lucas-number] are the integer sequence ``` @@ -48,7 +48,7 @@ L_n = \begin{cases}2 & \textrm{if}\ n = 0\\1 & \textrm{if}\ n = 1\\L_{n-1} + L_{ ``` From 01f6fd313e71644ac13643674f93e591eb965cac Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Sat, 14 Dec 2024 16:55:06 +0000 Subject: [PATCH 10/18] chore: use macros instead of vars and updated benchmark --- .../math/base/special/lucasf/benchmark/c/benchmark.c | 9 ++++++--- .../@stdlib/math/base/special/lucasf/lib/main.js | 2 +- .../@stdlib/math/base/special/lucasf/manifest.json | 11 ++++++++--- .../@stdlib/math/base/special/lucasf/src/main.c | 3 +-- 4 files changed, 16 insertions(+), 9 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c index fddab3e54d21..f0854d405ec1 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/benchmark.c @@ -107,14 +107,17 @@ int lucasf( int n ) { static double benchmark( void ) { double elapsed; double t; - int x; + int x[ 100 ]; int y; int i; + for ( i = 0; i < 100; i++ ) { + x[ i ] = (int)floorf( 30.0f * rand_float() ); + } + t = tic(); for ( i = 0; i < ITERATIONS; i++ ) { - x = (int)floorf( 30.0f * rand_float() ); - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( y < 0 ) { printf( "should return a nonnegative integer\n" ); break; diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js index f80a4ab111c0..d28633858c1d 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js @@ -22,7 +22,7 @@ var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); var isIntegerf = require( '@stdlib/math/base/assert/is-integerf' ); -var MAX_LUCAS = 34; +var MAX_LUCAS = require( '@stdlib/constants/float32/max-safe-nth-lucas' ); var LUCAS = require( './lucas.json' ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/manifest.json b/lib/node_modules/@stdlib/math/base/special/lucasf/manifest.json index 6bfc690068b2..ce09484e2d1b 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/manifest.json +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/manifest.json @@ -36,7 +36,8 @@ "libraries": [], "libpath": [], "dependencies": [ - "@stdlib/math/base/napi/unary" + "@stdlib/math/base/napi/unary", + "@stdlib/constants/float32/max-safe-nth-lucas" ] }, { @@ -49,7 +50,9 @@ ], "libraries": [], "libpath": [], - "dependencies": [] + "dependencies": [ + "@stdlib/constants/float32/max-safe-nth-lucas" + ] }, { "task": "examples", @@ -61,7 +64,9 @@ ], "libraries": [], "libpath": [], - "dependencies": [] + "dependencies": [ + "@stdlib/constants/float32/max-safe-nth-lucas" + ] } ] } diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c index 922f5fcb2a9a..81acad026ee4 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c @@ -17,8 +17,7 @@ */ #include "stdlib/math/base/special/lucasf.h" - -static const int32_t STDLIB_CONSTANT_FLOAT32_MAX_SAFE_NTH_LUCAS = 34; +#include "stdlib/constants/float32/max_safe_nth_lucas.h" static const int32_t lucas_value[ 35 ] = { 2, From dc28013cc50a78da4e89f64598ea921448c2113c Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 17 Dec 2024 07:44:25 +0000 Subject: [PATCH 11/18] chore: indentation fixes --- .../lucasf/benchmark/c/native/benchmark.c | 96 +++++++++---------- .../base/special/lucasf/examples/c/example.c | 12 +-- .../math/base/special/lucasf/src/main.c | 8 +- 3 files changed, 58 insertions(+), 58 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c index 06c0be54bf88..4d19b219f7b5 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/c/native/benchmark.c @@ -31,7 +31,7 @@ * Prints the TAP version. */ void print_version() { - printf( "TAP version 13\n" ); + printf( "TAP version 13\n" ); } /** @@ -41,12 +41,12 @@ void print_version() { * @param passing total number of passing tests */ static void print_summary( int total, int passing ) { - printf( "#\n" ); - printf( "1..%d\n", total ); // TAP plan - printf( "# total %d\n", total ); - printf( "# pass %d\n", passing ); - printf( "#\n" ); - printf( "# ok\n" ); + printf( "#\n" ); + printf( "1..%d\n", total ); // TAP plan + printf( "# total %d\n", total ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + printf( "# ok\n" ); } /** @@ -55,12 +55,12 @@ static void print_summary( int total, int passing ) { * @param elapsed elapsed time in seconds */ static void print_results( double elapsed ) { - double rate = (double)ITERATIONS / elapsed; - printf( " ---\n" ); - printf( " iterations: %d\n", ITERATIONS ); - printf( " elapsed: %0.9f\n", elapsed ); - printf( " rate: %0.9f\n", rate ); - printf( " ...\n" ); + double rate = (double)ITERATIONS / elapsed; + printf( " ---\n" ); + printf( " iterations: %d\n", ITERATIONS ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " rate: %0.9f\n", rate ); + printf( " ...\n" ); } /** @@ -69,9 +69,9 @@ static void print_results( double elapsed ) { * @return clock time */ static double tic( void ) { - struct timeval now; - gettimeofday( &now, NULL ); - return (double)now.tv_sec + (double)now.tv_usec/1.0e6; + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; } /** @@ -80,8 +80,8 @@ static double tic( void ) { * @return random number */ static float rand_float( void ) { - int r = rand(); - return (float)r / ( (float)RAND_MAX + 1.0f ); + int r = rand(); + return (float)r / ( (float)RAND_MAX + 1.0f ); } /** @@ -90,47 +90,47 @@ static float rand_float( void ) { * @return elapsed time in seconds */ static double benchmark( void ) { - double elapsed; - int32_t x[ 100 ]; - double t; - float y; - int i; + double elapsed; + int32_t x[ 100 ]; + double t; + float y; + int i; for ( i = 0 ; i < 100 ; i++ ) { x[ i ] = ( int32_t )( 34.0f * rand_float() ); } - t = tic(); - for ( i = 0; i < ITERATIONS; i++ ) { - y = stdlib_base_lucasf( x[ i % 100 ] ); - if ( y != y ) { - printf( "should not return NaN\n" ); - break; - } - } - elapsed = tic() - t; - if ( y != y ) { - printf( "should not return NaN\n" ); - } - return elapsed; + t = tic(); + for ( i = 0; i < ITERATIONS; i++ ) { + y = stdlib_base_lucasf( x[ i % 100 ] ); + if ( y != y ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( y != y ) { + printf( "should not return NaN\n" ); + } + return elapsed; } /** * Main execution sequence. */ int main( void ) { - double elapsed; - int i; + double elapsed; + int i; - // Use the current time to seed the random number generator: - srand( time( NULL ) ); + // Use the current time to seed the random number generator: + srand( time( NULL ) ); - print_version(); - for ( i = 0; i < REPEATS; i++ ) { - printf( "# c::native::%s\n", NAME ); - elapsed = benchmark(); - print_results( elapsed ); - printf( "ok %d benchmark finished\n", i+1 ); - } - print_summary( REPEATS, REPEATS ); + print_version(); + for ( i = 0; i < REPEATS; i++ ) { + printf( "# c::native::%s\n", NAME ); + elapsed = benchmark(); + print_results( elapsed ); + printf( "ok %d benchmark finished\n", i+1 ); + } + print_summary( REPEATS, REPEATS ); } diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c index c2e60e4680a5..586c5b8d3d6f 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/examples/c/example.c @@ -21,11 +21,11 @@ #include int main( void ) { - int32_t i; - float v; + int32_t i; + float v; - for ( i = 0; i < 35; i++ ) { - v = stdlib_base_lucasf( i ); - printf( "lucasf(%d) = %f\n", i, v ); - } + for ( i = 0; i < 35; i++ ) { + v = stdlib_base_lucasf( i ); + printf( "lucasf(%d) = %f\n", i, v ); + } } diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c index 81acad026ee4..78477d9229b7 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c @@ -72,8 +72,8 @@ static const int32_t lucas_value[ 35 ] = { * // returns NaN */ float stdlib_base_lucasf( const int32_t n ) { - if ( n < 0 || n > STDLIB_CONSTANT_FLOAT32_MAX_SAFE_NTH_LUCAS ) { - return 0.0f / 0.0f; // NaN - } - return lucas_value[ n ]; + if ( n < 0 || n > STDLIB_CONSTANT_FLOAT32_MAX_SAFE_NTH_LUCAS ) { + return 0.0f / 0.0f; // NaN + } + return lucas_value[ n ]; } From d4a0d537ab960b996cebdf2e4385d8a7dd4e3290 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 17 Dec 2024 08:02:52 +0000 Subject: [PATCH 12/18] chore: update function descriptions --- .../@stdlib/math/base/special/lucasf/test/test.js | 10 +++++----- .../math/base/special/lucasf/test/test.native.js | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js index c8765a8ffb61..23a007e091db 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.js @@ -44,24 +44,24 @@ tape( 'if provided a negative number, the function returns `NaN`', function test var v; var i; - t.strictEqual( isnanf( lucasf( -3.14 ) ), true, 'returns NaN' ); + t.strictEqual( isnanf( lucasf( -3.14 ) ), true, 'returns expected value' ); for ( i = -1; i > -100; i-- ) { v = lucasf( i ); - t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + t.strictEqual( isnanf( v ), true, 'returns expected value when provided ' + i ); } t.end(); }); tape( 'if provided positive infinity, the function returns `NaN`', function test( t ) { var v = lucasf( PINF ); - t.strictEqual( isnanf( v ), true, 'returns NaN when provided +infinity' ); + t.strictEqual( isnanf( v ), true, 'returns expected value when provided +infinity' ); t.end(); }); tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) { var v = lucasf( NaN ); - t.strictEqual( isnanf( v ), true, 'returns NaN when provided a NaN' ); + t.strictEqual( isnanf( v ), true, 'returns expected value when provided a NaN' ); t.end(); }); @@ -86,7 +86,7 @@ tape( 'if provided nonnegative integers greater than `34`, the function returns var v; for ( i = 35; i < 500; i++ ) { v = lucasf( i ); - t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + t.strictEqual( isnanf( v ), true, 'returns expected value when provided ' + i ); } t.end(); }); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js index d39d7bf62bbf..5881849f95ec 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/test/test.native.js @@ -53,7 +53,7 @@ tape( 'if provided a negative number, the function returns `NaN`', opts, functio for ( i = -1; i > -100; i-- ) { v = lucasf( i ); - t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + t.strictEqual( isnanf( v ), true, 'returns expected value when provided ' + i ); } t.end(); }); @@ -73,7 +73,7 @@ tape( 'if provided nonnegative integers less than `34`, the function returns `Na var v; for ( i = 35; i < 500; i++ ) { v = lucasf( i ); - t.strictEqual( isnanf( v ), true, 'returns NaN when provided ' + i ); + t.strictEqual( isnanf( v ), true, 'returns expected value when provided ' + i ); } t.end(); }); From 1f77b727c0cdfc09dcf3efca5b5a1397d7cdced6 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 17 Dec 2024 08:12:52 +0000 Subject: [PATCH 13/18] feat: update benchmarks with precomputation --- .../special/lucasf/benchmark/benchmark.js | 43 +++++++++++-------- 1 file changed, 25 insertions(+), 18 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js index b49401fe341e..f0272abb9c06 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/benchmark/benchmark.js @@ -21,8 +21,7 @@ // MODULES // var bench = require( '@stdlib/bench' ); -var randu = require( '@stdlib/random/base/randu' ); -var floorf = require( '@stdlib/math/base/special/floorf' ); +var randu = require( '@stdlib/random/array/discrete-uniform' ); var roundf = require( '@stdlib/math/base/special/roundf' ); var pow = require( '@stdlib/math/base/special/pow' ); var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); @@ -39,10 +38,11 @@ bench( pkg, function benchmark( b ) { var y; var i; + x = randu( 100, 0, 34 ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 35.0 ); - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } @@ -64,10 +64,11 @@ bench( pkg+'::analytic', function benchmark( b ) { return roundf( pow( PHI, n ) ); } + x = randu( 100, 0, 34 ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 35.0 ); - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } @@ -85,10 +86,11 @@ bench( pkg+'::table', function benchmark( b ) { var y; var i; + x = randu( 100, 0, 34 ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 35.0 ); - y = LUCAS[ x ]; + y = LUCAS[ x[ i % 100 ] ]; if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } @@ -116,10 +118,11 @@ bench( pkg+'::naive_recursion', function benchmark( b ) { return lucasf( n-1 ) + lucasf( n-2 ); } + x = randu( 100, 0, 40 ); // limit upper bound + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 40.0 ); // limit upper bound - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } @@ -152,10 +155,11 @@ bench( pkg+'::recursion_memoized', function benchmark( b ) { return arr[ n ]; } + x = randu( 100, 0, 35 ); // limit upper bound + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 35.0 ); // limit upper bound - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } @@ -186,10 +190,11 @@ bench( pkg+'::naive_iterative', function benchmark( b ) { return arr[ n ]; } + x = randu( 100, 0, 35 ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 35.0 ); - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } @@ -226,10 +231,11 @@ bench( pkg+'::iterative', function benchmark( b ) { return b; } + x = randu( 100, 0, 35 ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 35.0 ); - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } @@ -265,10 +271,11 @@ bench( pkg+'::iterative_memoized', function benchmark( b ) { return arr[ n ]; } + x = randu( 100, 0, 35 ); + b.tic(); for ( i = 0; i < b.iterations; i++ ) { - x = floorf( randu() * 35.0 ); - y = lucasf( x ); + y = lucasf( x[ i % 100 ] ); if ( isnanf( y ) ) { b.fail( 'should not return NaN' ); } From eadb608bd4eb8318600c47b88145f88268b09b0b Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 17 Dec 2024 08:26:10 +0000 Subject: [PATCH 14/18] docs: update description --- lib/node_modules/@stdlib/math/base/special/lucasf/README.md | 4 ++-- .../@stdlib/math/base/special/lucasf/docs/repl.txt | 4 ++-- .../@stdlib/math/base/special/lucasf/docs/types/index.d.ts | 2 +- .../special/lucasf/include/stdlib/math/base/special/lucasf.h | 2 +- lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js | 2 +- .../@stdlib/math/base/special/lucasf/lib/native.js | 2 +- .../@stdlib/math/base/special/lucasf/package.json | 2 +- lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c | 2 +- 8 files changed, 10 insertions(+), 10 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md index 235b07d7ee20..9fd805aa86cd 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md @@ -68,7 +68,7 @@ var lucasf = require( '@stdlib/math/base/special/lucasf' ); #### lucasf( n ) -Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. +Compute/Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. ```javascript var v = lucasf( 0 ); @@ -171,7 +171,7 @@ for ( i = 0; i < 35; i++ ) { #### stdlib_base_lucasf( n ) -Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. +Compute/Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. ```c float out = stdlib_base_lucasf( 0 ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt index c724fec5fc9c..92546901714f 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt @@ -1,7 +1,7 @@ {{alias}}( n ) - Computes the nth Lucas number in single-precision - floating-point format. + Compute/Computes the nth Lucas number in + single-precision floating-point format. Lucas numbers follow the recurrence relation diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts index a1c7973d449f..b022b4ea4ff2 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts @@ -19,7 +19,7 @@ // TypeScript Version: 4.1 /** -* Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number in single-precision floating-point format. * * ## Notes * diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h index 13b00041d64d..702b90d19c8e 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h @@ -29,7 +29,7 @@ extern "C" { #endif /** -* Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number in single-precision floating-point format. */ float stdlib_base_lucasf( const int32_t n ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js index d28633858c1d..3b4e97f459f6 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js @@ -29,7 +29,7 @@ var LUCAS = require( './lucas.json' ); // MAIN // /** -* Computes the nth Lucas number in single-precision floating-point format. +* Cmopute/Computes the nth Lucas number in single-precision floating-point format. * * @param {NonNegativeInteger} n - the Lucas number to compute * @returns {NonNegativeInteger} Lucas number diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js index bcb11fe34420..564e843875f6 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js @@ -26,7 +26,7 @@ var addon = require( './../src/addon.node' ); // MAIN // /** -* Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number in single-precision floating-point format. * * @private * @param {NonNegativeInteger} n - the Lucas number to compute diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/package.json b/lib/node_modules/@stdlib/math/base/special/lucasf/package.json index 499d2470f300..6edefcb98bf9 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/package.json +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/math/base/special/lucasf", "version": "0.0.0", - "description": "Compute the nth Lucas number in single-precision floating-point format.", + "description": "Compute/Computes the nth Lucas number in single-precision floating-point format.", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c index 78477d9229b7..a6c43b7980de 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c @@ -58,7 +58,7 @@ static const int32_t lucas_value[ 35 ] = { }; /** -* Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number in single-precision floating-point format. * * @param n input value * @return output value From b4d38e55fb431224e04a4398156e81211499b65f Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 17 Dec 2024 08:49:55 +0000 Subject: [PATCH 15/18] feat: update descriptions --- lib/node_modules/@stdlib/math/base/special/lucasf/README.md | 6 +++--- .../@stdlib/math/base/special/lucasf/docs/repl.txt | 4 ++-- .../@stdlib/math/base/special/lucasf/docs/types/index.d.ts | 2 +- .../lucasf/include/stdlib/math/base/special/lucasf.h | 2 +- .../@stdlib/math/base/special/lucasf/lib/index.js | 2 +- .../@stdlib/math/base/special/lucasf/lib/main.js | 2 +- .../@stdlib/math/base/special/lucasf/lib/native.js | 2 +- .../@stdlib/math/base/special/lucasf/package.json | 2 +- .../@stdlib/math/base/special/lucasf/src/main.c | 2 +- 9 files changed, 12 insertions(+), 12 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md index 9fd805aa86cd..2f2cba235fd7 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md @@ -20,7 +20,7 @@ limitations under the License. # Lucas -> Compute the nth [Lucas number][lucas-number] in single-precision floating-point format. +> Compute/Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number.
@@ -68,7 +68,7 @@ var lucasf = require( '@stdlib/math/base/special/lucasf' ); #### lucasf( n ) -Compute/Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. +Compute/Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number. ```javascript var v = lucasf( 0 ); @@ -171,7 +171,7 @@ for ( i = 0; i < 35; i++ ) { #### stdlib_base_lucasf( n ) -Compute/Computes the nth [Lucas number][lucas-number] in single-precision floating-point format. +Compute/Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number. ```c float out = stdlib_base_lucasf( 0 ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt index 92546901714f..5665879ab876 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt @@ -1,7 +1,7 @@ {{alias}}( n ) - Compute/Computes the nth Lucas number in - single-precision floating-point format. + Compute/Computes the nth Lucas number as a + single-precision floating-point number. Lucas numbers follow the recurrence relation diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts index b022b4ea4ff2..86919640ae74 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts @@ -19,7 +19,7 @@ // TypeScript Version: 4.1 /** -* Compute/Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number as a single-precision floating-point number. * * ## Notes * diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h index 702b90d19c8e..3bf927ee78e0 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h @@ -29,7 +29,7 @@ extern "C" { #endif /** -* Compute/Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number as a single-precision floating-point number. */ float stdlib_base_lucasf( const int32_t n ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js index cc55a0cb05d1..9267ab2895da 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/index.js @@ -19,7 +19,7 @@ 'use strict'; /** -* Compute the nth Lucas number in single-precision floating-point format. +* Compute the nth Lucas number as a single-precision floating-point number. * * @module @stdlib/math/base/special/lucasf * diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js index 3b4e97f459f6..0bd8937ed060 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js @@ -29,7 +29,7 @@ var LUCAS = require( './lucas.json' ); // MAIN // /** -* Cmopute/Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number as a single-precision floating-point number. * * @param {NonNegativeInteger} n - the Lucas number to compute * @returns {NonNegativeInteger} Lucas number diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js index 564e843875f6..2656672544ca 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js @@ -26,7 +26,7 @@ var addon = require( './../src/addon.node' ); // MAIN // /** -* Compute/Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number as a single-precision floating-point number. * * @private * @param {NonNegativeInteger} n - the Lucas number to compute diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/package.json b/lib/node_modules/@stdlib/math/base/special/lucasf/package.json index 6edefcb98bf9..1d0d38074671 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/package.json +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/math/base/special/lucasf", "version": "0.0.0", - "description": "Compute/Computes the nth Lucas number in single-precision floating-point format.", + "description": "Compute/Computes the nth Lucas number as a single-precision floating-point number.", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c index a6c43b7980de..5da0402c2202 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c @@ -58,7 +58,7 @@ static const int32_t lucas_value[ 35 ] = { }; /** -* Compute/Computes the nth Lucas number in single-precision floating-point format. +* Compute/Computes the nth Lucas number as a single-precision floating-point number. * * @param n input value * @return output value From 309b056e85be49b1f1d81b2aac74192ea280efa8 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 17 Dec 2024 10:27:39 +0000 Subject: [PATCH 16/18] chore: correct descriptions --- lib/node_modules/@stdlib/math/base/special/lucasf/README.md | 6 +++--- .../@stdlib/math/base/special/lucasf/docs/repl.txt | 2 +- .../@stdlib/math/base/special/lucasf/docs/types/index.d.ts | 2 +- .../lucasf/include/stdlib/math/base/special/lucasf.h | 2 +- .../@stdlib/math/base/special/lucasf/lib/main.js | 2 +- .../@stdlib/math/base/special/lucasf/lib/native.js | 2 +- .../@stdlib/math/base/special/lucasf/package.json | 2 +- .../@stdlib/math/base/special/lucasf/src/main.c | 2 +- 8 files changed, 10 insertions(+), 10 deletions(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md index 2f2cba235fd7..f4e9c8dffa0d 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/README.md +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/README.md @@ -20,7 +20,7 @@ limitations under the License. # Lucas -> Compute/Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number. +> Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number.
@@ -68,7 +68,7 @@ var lucasf = require( '@stdlib/math/base/special/lucasf' ); #### lucasf( n ) -Compute/Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number. +Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number. ```javascript var v = lucasf( 0 ); @@ -171,7 +171,7 @@ for ( i = 0; i < 35; i++ ) { #### stdlib_base_lucasf( n ) -Compute/Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number. +Computes the nth [Lucas number][lucas-number] as a single-precision floating-point number. ```c float out = stdlib_base_lucasf( 0 ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt index 5665879ab876..5290a55cefb7 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/repl.txt @@ -1,6 +1,6 @@ {{alias}}( n ) - Compute/Computes the nth Lucas number as a + Computes the nth Lucas number as a single-precision floating-point number. Lucas numbers follow the recurrence relation diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts index 86919640ae74..c1409866f9cc 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts @@ -19,7 +19,7 @@ // TypeScript Version: 4.1 /** -* Compute/Computes the nth Lucas number as a single-precision floating-point number. +* Computes the nth Lucas number as a single-precision floating-point number. * * ## Notes * diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h index 3bf927ee78e0..e78e7e40b6e3 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/include/stdlib/math/base/special/lucasf.h @@ -29,7 +29,7 @@ extern "C" { #endif /** -* Compute/Computes the nth Lucas number as a single-precision floating-point number. +* Computes the nth Lucas number as a single-precision floating-point number. */ float stdlib_base_lucasf( const int32_t n ); diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js index 0bd8937ed060..810bb1bb358b 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/main.js @@ -29,7 +29,7 @@ var LUCAS = require( './lucas.json' ); // MAIN // /** -* Compute/Computes the nth Lucas number as a single-precision floating-point number. +* Computes the nth Lucas number as a single-precision floating-point number. * * @param {NonNegativeInteger} n - the Lucas number to compute * @returns {NonNegativeInteger} Lucas number diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js index 2656672544ca..e19928603374 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/lib/native.js @@ -26,7 +26,7 @@ var addon = require( './../src/addon.node' ); // MAIN // /** -* Compute/Computes the nth Lucas number as a single-precision floating-point number. +* Computes the nth Lucas number as a single-precision floating-point number. * * @private * @param {NonNegativeInteger} n - the Lucas number to compute diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/package.json b/lib/node_modules/@stdlib/math/base/special/lucasf/package.json index 1d0d38074671..9822b046b63d 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/package.json +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/math/base/special/lucasf", "version": "0.0.0", - "description": "Compute/Computes the nth Lucas number as a single-precision floating-point number.", + "description": "Compute the nth Lucas number as a single-precision floating-point number.", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c index 5da0402c2202..5d661617d820 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/src/main.c @@ -58,7 +58,7 @@ static const int32_t lucas_value[ 35 ] = { }; /** -* Compute/Computes the nth Lucas number as a single-precision floating-point number. +* Computes the nth Lucas number as a single-precision floating-point number. * * @param n input value * @return output value From 2afbe932300924fc3fe02b7e58c780598841ac26 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 17 Dec 2024 10:42:30 +0000 Subject: [PATCH 17/18] chore: correct descriptions --- .../@stdlib/math/base/special/lucasf/docs/types/index.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts index c1409866f9cc..d4042fdb9a65 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts @@ -19,7 +19,7 @@ // TypeScript Version: 4.1 /** -* Computes the nth Lucas number as a single-precision floating-point number. +* Compute the nth Lucas number as a single-precision floating-point number. * * ## Notes * From 8fbf8876f1330eb8504b2846a7b879e2ee3dcc2e Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Wed, 18 Dec 2024 04:55:42 +0000 Subject: [PATCH 18/18] chore: fix linting errors --- .../@stdlib/math/base/special/lucasf/docs/types/index.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts index d4042fdb9a65..c1409866f9cc 100644 --- a/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/math/base/special/lucasf/docs/types/index.d.ts @@ -19,7 +19,7 @@ // TypeScript Version: 4.1 /** -* Compute the nth Lucas number as a single-precision floating-point number. +* Computes the nth Lucas number as a single-precision floating-point number. * * ## Notes *