feat: add examples tests benchmarks

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: passed
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: aayush0325

lib/node_modules/@stdlib/lapack/base/dlapy2/benchmark/benchmark.js

@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var pkg = require( './../package.json' ).name;
+var dlapy2 = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+	var len;
+	var x;
+	var y;
+	var z;
+	var i;
+
+	len = 100;
+	x = uniform( len, -50, 50 );
+	y = uniform( len, -50, 50 );
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		z = dlapy2( x[ i % len ], y[ i % len ] );
+		if ( isnan( z ) ) {
+			b.fail( 'should not return NaN' );
+		}
+	}
+	b.toc();
+	if ( isnan( z ) ) {
+		b.fail( 'should not return NaN' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});

lib/node_modules/@stdlib/lapack/base/dlapy2/examples/index.js

@@ -0,0 +1,31 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var dlapy2 = require( './../lib' );
+
+var opts = {
+	'dtype': 'float64'
+};
+var x = discreteUniform( 100, -50, 50, opts );
+var y = discreteUniform( 100, -50, 50, opts );
+
+logEachMap( 'dlapy2( %d, %d ) = %0.4f', x, y, dlapy2 );

lib/node_modules/@stdlib/lapack/base/dlapy2/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@stdlib/lapack/base/dlapy2",
+  "version": "0.0.0",
+  "description": "LAPACK routine to calculate sqrt( x^2 + y^2 ) in a manner which doesn't cause unnecessary overflow.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "mathematics",
+    "math",
+    "lapack",
+    "dlapy2",
+    "copy",
+    "linear",
+    "algebra",
+    "subroutines",
+    "array",
+    "ndarray",
+    "matrix",
+    "float64",
+    "double",
+    "float64array"
+  ]
+}

lib/node_modules/@stdlib/lapack/base/dlapy2/test/fixtures/julia/REQUIRE

@@ -0,0 +1,2 @@
+julia 1.5
+JSON 0.21

lib/node_modules/@stdlib/lapack/base/dlapy2/test/fixtures/julia/data.json

@@ -0,0 +1,69 @@
+#!/usr/bin/env julia
+#
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import JSON
+
+"""
+	gen( x, y, name )
+
+Generate fixture data and write to file.
+
+# Arguments
+
+* `x`: x-values
+* `y`: y-values
+* `name::AbstractString`: output filename
+
+# Examples
+
+``` julia
+julia> x = rand( 2003 ) .* 1000.0;
+julia> y = rand( 2003 ) .* 1000.0;
+julia> gen( x, y, \"data.json\" );
+```
+"""
+function gen( x, y, name )
+	h = hypot.( x, y );
+
+	# Store data to be written to file as a collection:
+	data = Dict([
+		("x", x),
+		("y", y),
+		("expected", h)
+	]);
+
+	# Based on the script directory, create an output filepath:
+	filepath = joinpath( dir, name );
+
+	# Write the data to the output filepath as JSON:
+	outfile = open( filepath, "w" );
+	write( outfile, JSON.json(data) );
+	write( outfile, "\n" );
+	close( outfile );
+end
+
+# Get the filename:
+file = @__FILE__;
+
+# Extract the directory in which this file resides:
+dir = dirname( file );
+
+# Generate fixture data:
+x = rand( 2003 ) .* 2000.0 .- 1000.0;
+y = rand( 2003 ) .* 2000.0 .- 1000.0;
+gen( x, y, "data.json" );

lib/node_modules/@stdlib/lapack/base/dlapy2/test/fixtures/julia/runner.jl

@@ -0,0 +1,143 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var PINF = require( '@stdlib/constants/float64/pinf' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
+var dlapy2 = require( './../lib' );
+
+
+// FIXTURES //
+
+var data = require( './fixtures/julia/data.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dlapy2, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function returns `NaN` if either argument is `NaN` but not `+-infinity`', function test( t ) {
+	var h;
+
+	h = dlapy2( NaN, 3.14 );
+	t.strictEqual( isnan( h ), true, 'returns expected value' );
+
+	h = dlapy2( 3.14, NaN );
+	t.strictEqual( isnan( h ), true, 'returns expected value' );
+
+	h = dlapy2( NaN, NaN );
+	t.strictEqual( isnan( h ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns `+0` if both arguments are `+-0`', function test( t ) {
+	var h;
+
+	h = dlapy2( +0.0, +0.0 );
+	t.strictEqual( isPositiveZero( h ), true, 'returns expected value' );
+
+	h = dlapy2( -0.0, +0.0 );
+	t.strictEqual( isPositiveZero( h ), true, 'returns expected value' );
+
+	h = dlapy2( +0.0, -0.0 );
+	t.strictEqual( isPositiveZero( h ), true, 'returns expected value' );
+
+	h = dlapy2( -0.0, -0.0 );
+	t.strictEqual( isPositiveZero( h ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function computes the hypotenuse', function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var h;
+	var x;
+	var y;
+	var i;
+
+	x = data.x;
+	y = data.y;
+	expected = data.expected;
+
+	for ( i = 0; i < x.length; i++ ) {
+		h = dlapy2( x[ i ], y[ i ] );
+		if ( h === expected[ i ] ) {
+			t.ok( true, 'x: '+x[i]+'. y: '+y[i]+'. h: '+h+'. Expected: '+expected[i]+'.' );
+		} else {
+			delta = abs( h - expected[ i ] );
+			tol = 1.5 * EPS * abs( expected[ i ] );
+			t.strictEqual( delta <= tol, true, 'within tolerance. x: '+x[i]+'. y: '+y[i]+'. h: '+h+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function computes the hypotenuse (canonical inputs)', function test( t ) {
+	var h;
+
+	h = dlapy2( 3.0, 4.0 );
+	t.strictEqual( h, 5.0, 'returns expected value' );
+
+	h = dlapy2( 6.0, 8.0 );
+	t.strictEqual( h, 10.0, 'returns expected value' );
+
+	h = dlapy2( 5.0, 12.0 );
+	t.strictEqual( h, 13.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function avoids overflow', function test( t ) {
+	var h;
+
+	h = sqrt( pow( 1.0e308, 2 ) + pow( 1.0e308, 2 ) );
+	t.strictEqual( h, PINF, 'returns expected value' );
+
+	h = dlapy2( 1.0e308, 1.0e308 );
+	t.strictEqual( h, 1.4142135623730951e308, 'avoids overflow' );
+
+	t.end();
+});
+
+tape( 'the function avoids underflow', function test( t ) {
+	var h;
+
+	h = sqrt( pow( 1.0e-200, 2 ) + pow( 1e-200, 2 ) );
+	t.strictEqual( h, 0.0, 'returns 0' );
+
+	h = dlapy2( 1.0e-200, 1.0e-200 );
+	t.strictEqual( h, 1.414213562373095e-200, 'avoids underflow' );
+
+	t.end();
+});