diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/README.md b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/README.md
new file mode 100644
index 000000000000..817d341ddc91
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/README.md
@@ -0,0 +1,279 @@
+
+
+# Cumulative Distribution Function
+
+> [Wald][wald-distribution] distribution [cumulative distribution function][cdf].
+
+
+
+The [cumulative distribution function][cdf] for a [Wald][wald-distribution] random variable is
+
+
+
+```math
+F(x;\mu,\lambda) = \Phi\!\left(\sqrt{\frac{\lambda}{x}}\left(\frac{x}{\mu}-1\right)\right) + \exp\!\left(\frac{2\lambda}{\mu}\right)\,\Phi\!\left(-\sqrt{\frac{\lambda}{x}}\left(\frac{x}{\mu}+1\right)\right)
+```
+
+
+
+where `µ > 0` is the mean and `λ > 0` is the shape parameter.
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var cdf = require( '@stdlib/stats/base/dists/wald/cdf' );
+```
+
+#### cdf( x, mu, lambda )
+
+Evaluates the [cumulative distribution function][cdf] (CDF) for a [Wald][wald-distribution] distribution with parameters `mu` (mean) and `lambda` (shape parameter).
+
+```javascript
+var y = cdf( 2.0, 2.0, 1.0 );
+// returns ~0.714
+
+y = cdf( 1.0, 2.0, 1.0 );
+// returns ~0.490
+
+y = cdf( 4.0, 2.0, 1.0 );
+// returns ~0.873
+```
+
+If provided `NaN` as any argument, the function returns `NaN`.
+
+```javascript
+var y = cdf( NaN, 2.0, 1.0 );
+// returns NaN
+
+y = cdf( 2.0, NaN, 1.0 );
+// returns NaN
+
+y = cdf( 2.0, 2.0, NaN );
+// returns NaN
+```
+
+If provided `mu <= 0` or `lambda < 0`, the function returns `NaN`.
+
+```javascript
+var y = cdf( 2.0, 0.0, -3.0 );
+// returns NaN
+
+y = cdf( 2.0, -1.0, -2.0 );
+// returns NaN
+
+y = cdf( 2.0, -2.0, -1.0 );
+// returns NaN
+```
+
+If provided `x <= 0`, the function returns `0`.
+
+```javascript
+var y = cdf( 0.0, 2.0, 1.0 );
+// returns 0.0
+
+y = cdf( -1.0, 2.0, 1.0 );
+// returns 0.0
+```
+
+If `lambda = 0`, the function evaluates the [CDF][cdf] of a [degenerate distribution][degenerate-distribution] centered at `mu`.
+
+```javascript
+var y = cdf( 2.0, 8.0, 0.0 );
+// returns 0.0
+
+y = cdf( 8.0, 8.0, 0.0 );
+// returns 1.0
+
+y = cdf( 10.0, 8.0, 0.0 );
+// returns 1.0
+```
+
+#### cdf.factory( mu, lambda )
+
+Returns a function for evaluating the [cumulative distribution function][cdf] of a wald distribution with parameters `mu` and `lambda`.
+
+```javascript
+var mycdf = cdf.factory( 1.0, 1.0 );
+
+var y = mycdf( 2.0 );
+// returns ~0.885
+
+y = mycdf( 8.0 );
+// returns ~0.999
+```
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var uniform = require( '@stdlib/random/array/uniform' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var cdf = require( '@stdlib/stats/base/dists/wald/cdf' );
+
+var opts = {
+ 'dtype': 'float64'
+};
+var x = uniform( 10, EPS, 10.0, opts );
+var mu = uniform( 10, EPS, 10.0, opts );
+var lambda = uniform( 10, EPS, 20.0, opts );
+
+logEachMap( 'x: %0.4f, µ: %0.4f, λ: %0.4f, f(x;µ,λ): %0.4f', x, mu, lambda, cdf );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+#include "stdlib/stats/base/dists/wald/cdf.h"
+```
+
+#### stdlib_base_dists_wald_cdf( x, mu, lambda )
+
+Evaluates the [cumulative distribution function][cdf] (CDF) for a [Wald][wald-distribution] distribution with parameters `mu` (mean) and `lambda` (shape parameter).
+
+```c
+double out = stdlib_base_dists_wald_cdf( 2.0, 1.0, 1.0 );
+// returns ~0.885
+```
+
+The function accepts the following arguments:
+
+- **x**: `[in] double` input value.
+- **mu**: `[in] double` mean.
+- **lambda**: `[in] double` shape parameter.
+
+```c
+double stdlib_base_dists_wald_cdf( const double x, const double mu, const double lambda );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+#include "stdlib/stats/base/dists/wald/cdf.h"
+#include "stdlib/constants/float64/eps.h"
+#include
+#include
+#include
+
+static double random_uniform( const double min, const double max ) {
+ double v = (double)rand() / ( (double)RAND_MAX + 1.0 );
+ return min + ( v*(max-min) );
+}
+
+int main( void ) {
+ double lambda;
+ double mu;
+ double x;
+ double y;
+ int i;
+
+ for ( i = 0; i < 10; i++ ) {
+ x = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 );
+ mu = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 );
+ lambda = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 );
+ y = stdlib_base_dists_wald_cdf( x, mu, lambda );
+ printf( "x: %lf, µ: %lf, λ: %lf, F(x;µ,λ): %lf\n", x, mu, lambda, y );
+ }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[cdf]: https://en.wikipedia.org/wiki/Cumulative_distribution_function
+
+[wald-distribution]: https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution
+
+[degenerate-distribution]: https://en.wikipedia.org/wiki/Degenerate_distribution
+
+
+
+
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/benchmark.js
new file mode 100644
index 000000000000..598c51a7e667
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/benchmark.js
@@ -0,0 +1,84 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var cdf = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var lambda;
+ var len;
+ var mu;
+ var x;
+ var y;
+ var i;
+
+ len = 100;
+ x = uniform( len, EPS, 100.0 );
+ mu = uniform( len, EPS, 50.0 );
+ lambda = uniform( len, EPS, 20.0 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ y = cdf( x[ i % len ], mu[ i % len ], lambda[ i % len ] );
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( format( '%s:factory', pkg ), function benchmark( b ) {
+ var mycdf;
+ var x;
+ var y;
+ var i;
+
+ mycdf = cdf.factory( 1.0, 1.5 );
+ x = uniform( 100, EPS, 10.0 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ y = mycdf( x[ i % x.length ] );
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/benchmark.native.js
new file mode 100644
index 000000000000..d2df93f87788
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/benchmark.native.js
@@ -0,0 +1,68 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var cdf = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var opts = {
+ 'skip': ( cdf instanceof Error )
+};
+
+
+// MAIN //
+
+bench( pkg+'::native', opts, function benchmark( b ) {
+ var lambda;
+ var len;
+ var mu;
+ var x;
+ var y;
+ var i;
+
+ len = 100;
+ x = uniform( len, EPS, 100.0 );
+ mu = uniform( len, EPS, 50.0 );
+ lambda = uniform( len, EPS, 20.0 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ y = cdf( x[ i % len ], mu[ i % len ], lambda[ i % len ] );
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/c/Makefile b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/c/Makefile
new file mode 100644
index 000000000000..7b114bb8537f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2026 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/stats/base/dists/wald/cdf/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/c/benchmark.c
new file mode 100644
index 000000000000..e57aa87cdc64
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/c/benchmark.c
@@ -0,0 +1,144 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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/stats/base/dists/wald/cdf.h"
+#include "stdlib/constants/float64/eps.h"
+#include
+#include
+#include
+#include
+#include
+
+#define NAME "wald-cdf"
+#define ITERATIONS 1000000
+#define REPEATS 3
+#define LEN 100
+
+/**
+* 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 [min,max).
+*
+* @param min minimum value (inclusive)
+* @param max maximum value (exclusive)
+* @return random number
+*/
+static double random_uniform( const double min, const double max ) {
+ double v = (double)rand() / ( (double)RAND_MAX + 1.0 );
+ return min + ( v*(max-min) );
+}
+
+/**
+* Runs a benchmark.
+*
+* @return elapsed time in seconds
+*/
+static double benchmark( void ) {
+ double lambda[ 100 ];
+ double mu[ 100 ];
+ double x[ 100 ];
+ double elapsed;
+ double y;
+ double t;
+ int i;
+
+ for ( i = 0; i < 100; i++ ) {
+ x[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 100.0 );
+ mu[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 50.0 );
+ lambda[ i ] = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 20.0 );
+ }
+
+ t = tic();
+ for ( i = 0; i < ITERATIONS; i++ ) {
+ y = stdlib_base_dists_wald_cdf( x[ i%100 ], mu[ i%100 ], lambda[ 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;
+
+ // 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/stats/base/dists/wald/cdf/benchmark/r/DESCRIPTION b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/r/DESCRIPTION
new file mode 100644
index 000000000000..e494f25a67d1
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/r/DESCRIPTION
@@ -0,0 +1,9 @@
+Package: dinvgauss-benchmarks
+Title: Benchmarks
+Version: 0.0.0
+Authors@R: person("stdlib", "js", role = c("aut","cre"))
+Description: Benchmarks.
+Depends: R (>=3.4.0)
+Imports:
+ microbenchmark
+LazyData: true
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/r/benchmark.R b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/r/benchmark.R
new file mode 100644
index 000000000000..48173180ff4c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/benchmark/r/benchmark.R
@@ -0,0 +1,109 @@
+#!/usr/bin/env Rscript
+#
+# @license Apache-2.0
+#
+# Copyright (c) 2026 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.
+
+# Set the precision to 16 digits:
+options( digits = 16L );
+
+#' Run benchmarks.
+#'
+#' @examples
+#' main();
+main <- function() {
+ # Define benchmark parameters:
+ name <- "dist-wald-cdf";
+ iterations <- 1000000L;
+ repeats <- 3L;
+
+ #' Print the TAP version.
+ #'
+ #' @examples
+ #' print_version();
+ print_version <- function() {
+ cat( "TAP version 13\n" );
+ }
+
+ #' Print the TAP summary.
+ #'
+ #' @param total Total number of tests.
+ #' @param passing Total number of passing tests.
+ #'
+ #' @examples
+ #' print_summary( 3, 3 );
+ print_summary <- function( total, passing ) {
+ cat( "#\n" );
+ cat( paste0( "1..", total, "\n" ) ); # TAP plan
+ cat( paste0( "# total ", total, "\n" ) );
+ cat( paste0( "# pass ", passing, "\n" ) );
+ cat( "#\n" );
+ cat( "# ok\n" );
+ }
+
+ #' Print benchmark results.
+ #'
+ #' @param iterations Number of iterations.
+ #' @param elapsed Elapsed time in seconds.
+ #'
+ #' @examples
+ #' print_results( 10000L, 0.131009101868 );
+ print_results <- function( iterations, elapsed ) {
+ rate <- iterations / elapsed;
+ cat( " ---\n" );
+ cat( paste0( " iterations: ", iterations, "\n" ) );
+ cat( paste0( " elapsed: ", elapsed, "\n" ) );
+ cat( paste0( " rate: ", rate, "\n" ) );
+ cat( " ...\n" );
+ }
+
+ #' Run a benchmark.
+ #'
+ #' ## Notes
+ #'
+ #' * We compute and return a total "elapsed" time, rather than the minimum
+ #' evaluation time, to match benchmark results in other languages (e.g.,
+ #' Python).
+ #'
+ #'
+ #' @param iterations Number of Iterations.
+ #' @return Elapsed time in seconds.
+ #'
+ #' @examples
+ #' elapsed <- benchmark( 10000L );
+ benchmark <- function( iterations ) {
+ # Run the benchmarks:
+ results <- microbenchmark::microbenchmark( dinvgauss( runif( 1, .Machine$double.eps, 100.0 ), runif( 1, .Machine$double.eps, 50.0 ), runif( 1, .Machine$double.eps, 20.0 ) ), times = iterations );
+
+ # Sum all the raw timing results to get a total "elapsed" time:
+ elapsed <- sum( results$time );
+
+ # Convert the elapsed time from nanoseconds to seconds:
+ elapsed <- elapsed / 1.0e9;
+
+ return( elapsed );
+ }
+
+ print_version();
+ for ( i in 1:repeats ) {
+ cat( paste0( "# r::", name, "\n" ) );
+ elapsed <- benchmark( iterations );
+ print_results( iterations, elapsed );
+ cat( paste0( "ok ", i, " benchmark finished", "\n" ) );
+ }
+ print_summary( repeats, repeats );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/binding.gyp b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/binding.gyp
new file mode 100644
index 000000000000..0d6508a12e99
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/binding.gyp
@@ -0,0 +1,170 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2026 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/stats/base/dists/wald/cdf/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/repl.txt
new file mode 100644
index 000000000000..63956c0dee6b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/repl.txt
@@ -0,0 +1,81 @@
+
+{{alias}}( x, μ, λ )
+ Evaluates the cumulative distribution function (CDF) for a Wald
+ distribution with mean `μ` and shape parameter `λ` at a value `x`.
+
+ If provided `NaN` as any argument, the function returns `NaN`.
+
+ If provided `μ <= 0`, the function returns `NaN`.
+
+ If provided `λ <= 0`, the function returns `NaN`.
+
+ Parameters
+ ----------
+ x: number
+ Input value.
+
+ μ: number
+ Mean parameter.
+
+ λ: number
+ Shape parameter.
+
+ Returns
+ -------
+ out: number
+ Evaluated CDF.
+
+ Examples
+ --------
+ > var y = {{alias}}( 2.0, 1.0, 1.0 )
+ ~0.885
+ > y = {{alias}}( 0.5, 2.0, 3.0 )
+ ~0.055
+ > y = {{alias}}( -1.0, 4.0, 2.0 )
+ 0.0
+ > y = {{alias}}( NaN, 0.0, 1.0 )
+ NaN
+ > y = {{alias}}( 0.0, NaN, 1.0 )
+ NaN
+ > y = {{alias}}( 0.0, 0.0, NaN )
+ NaN
+
+ // Negative shape parameter:
+ > y = {{alias}}( 2.0, 1.0, -1.0 )
+ NaN
+
+ // Degenerate distribution when `λ = 0.0`:
+ > y = {{alias}}( 2.0, 8.0, 0.0 )
+ 0.0
+ > y = {{alias}}( 8.0, 8.0, 0.0 )
+ 1.0
+ > y = {{alias}}( 10.0, 8.0, 0.0 )
+ 1.0
+
+
+{{alias}}.factory( μ, λ )
+ Returns a function for evaluating the cumulative distribution function (CDF)
+ of a wald distribution with mean `μ` and shape parameter `λ`.
+
+ Parameters
+ ----------
+ μ: number
+ Mean parameter.
+
+ λ: number
+ Shape parameter.
+
+ Returns
+ -------
+ cdf: Function
+ Cumulative distribution function (CDF).
+
+ Examples
+ --------
+ > var myCDF = {{alias}}.factory( 10.0, 2.0 );
+ > var y = myCDF( 10.0 )
+ ~0.777
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/types/index.d.ts
new file mode 100644
index 000000000000..333117d08d2b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/types/index.d.ts
@@ -0,0 +1,111 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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
+
+/**
+* Evaluates the cumulative distribution function (CDF) for a Wald distribution.
+*
+* @param x - input value
+* @returns evaluated CDF
+*/
+type Unary = ( x: number ) => number;
+
+/**
+* Interface for the cumulative distribution function (CDF) of a Wald distribution.
+*/
+interface CDF {
+ /**
+ * Evaluates the cumulative distribution function (CDF) for a Wald distribution with mean `mu` and shape parameter `lambda` at a value `x`.
+ *
+ * ## Notes
+ *
+ * - If provided `lambda < 0`, the function returns `NaN`.
+ *
+ * @param x - input value
+ * @param mu - mean
+ * @param lambda - shape parameter
+ * @returns evaluated cumulative distribution function
+ *
+ * @example
+ * var y = cdf( 2.0, 1.0, 1.0 );
+ * // returns ~0.885
+ *
+ * @example
+ * var y = cdf( 0.5, 2.0, 3.0 );
+ * // returns ~0.055
+ *
+ * @example
+ * var y = cdf( NaN, 0.0, 0.0 );
+ * // returns NaN
+ *
+ * @example
+ * var y = cdf( 0.0, NaN, 1.0 );
+ * // returns NaN
+ *
+ * @example
+ * var y = cdf( 0.0, 0.0, NaN );
+ * // returns NaN
+ *
+ * @example
+ * // Negative shape parameter:
+ * var y = cdf( 2.0, 0.0, -1.0 );
+ * // returns NaN
+ */
+ ( x: number, mu: number, lambda: number ): number;
+
+ /**
+ * Returns a function for evaluating the cumulative distribution function (CDF) for a Wald distribution.
+ *
+ * @param mu - mean
+ * @param lambda - shape parameter
+ * @returns function to evaluate the cumulative distribution function
+ *
+ * @example
+ * var myCDF = cdf.factory( 10.0, 2.0 );
+ * var y = myCDF( 10.0 );
+ * // returns ~0.777
+ *
+ * y = myCDF( 12.0 );
+ * // returns ~0.808
+ */
+ factory( mu: number, lambda: number ): Unary;
+}
+
+/**
+* Wald distribution cumulative distribution function (CDF).
+*
+* @param x - input value
+* @param mu - mean
+* @param lambda - shape parameter
+* @returns evaluated CDF
+*
+* @example
+* var y = cdf( 2.0, 1.0, 1.0 );
+* // returns ~0.885
+*
+* var myCDF = cdf.factory( 10.0, 2.0 );
+* y = myCDF( 10.0 );
+* // returns ~0.777
+*/
+declare var cdf: CDF;
+
+
+// EXPORTS //
+
+export = cdf;
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/types/test.ts
new file mode 100644
index 000000000000..68240f51cfb8
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/docs/types/test.ts
@@ -0,0 +1,119 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 cdf = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+ cdf( 2, 2, 4 ); // $ExpectType number
+ cdf( 1, 2, 8 ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided values other than three numbers...
+{
+ cdf( true, 3, 6 ); // $ExpectError
+ cdf( false, 2, 4 ); // $ExpectError
+ cdf( '5', 1, 2 ); // $ExpectError
+ cdf( [], 1, 2 ); // $ExpectError
+ cdf( {}, 2, 4 ); // $ExpectError
+ cdf( ( x: number ): number => x, 2, 4 ); // $ExpectError
+
+ cdf( 9, true, 12 ); // $ExpectError
+ cdf( 9, false, 12 ); // $ExpectError
+ cdf( 5, '5', 10 ); // $ExpectError
+ cdf( 8, [], 16 ); // $ExpectError
+ cdf( 9, {}, 18 ); // $ExpectError
+ cdf( 8, ( x: number ): number => x, 16 ); // $ExpectError
+
+ cdf( 9, 5, true ); // $ExpectError
+ cdf( 9, 5, false ); // $ExpectError
+ cdf( 5, 2, '5' ); // $ExpectError
+ cdf( 8, 4, [] ); // $ExpectError
+ cdf( 9, 4, {} ); // $ExpectError
+ cdf( 8, 5, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ cdf(); // $ExpectError
+ cdf( 2 ); // $ExpectError
+ cdf( 2, 0 ); // $ExpectError
+ cdf( 2, 0, 4, 1 ); // $ExpectError
+}
+
+// Attached to main export is a `factory` method which returns a function...
+{
+ cdf.factory( 3, 4 ); // $ExpectType Unary
+}
+
+// The `factory` method returns a function which returns a number...
+{
+ const fcn = cdf.factory( 3, 4 );
+ fcn( 2 ); // $ExpectType number
+}
+
+// The compiler throws an error if the function returned by the `factory` method is provided invalid arguments...
+{
+ const fcn = cdf.factory( 3, 4 );
+ fcn( true ); // $ExpectError
+ fcn( false ); // $ExpectError
+ fcn( '5' ); // $ExpectError
+ fcn( [] ); // $ExpectError
+ fcn( {} ); // $ExpectError
+ fcn( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function returned by the `factory` method is provided an unsupported number of arguments...
+{
+ const fcn = cdf.factory( 3, 4 );
+ fcn(); // $ExpectError
+ fcn( 2, 0 ); // $ExpectError
+ fcn( 2, 0, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `factory` method is provided values other than two numbers...
+{
+ cdf.factory( true, 3 ); // $ExpectError
+ cdf.factory( false, 2 ); // $ExpectError
+ cdf.factory( '5', 1 ); // $ExpectError
+ cdf.factory( [], 1 ); // $ExpectError
+ cdf.factory( {}, 2 ); // $ExpectError
+ cdf.factory( ( x: number ): number => x, 2 ); // $ExpectError
+
+ cdf.factory( 9, true ); // $ExpectError
+ cdf.factory( 9, false ); // $ExpectError
+ cdf.factory( 5, '5' ); // $ExpectError
+ cdf.factory( 8, [] ); // $ExpectError
+ cdf.factory( 9, {} ); // $ExpectError
+ cdf.factory( 8, ( x: number ): number => x ); // $ExpectError
+
+ cdf.factory( [], true ); // $ExpectError
+ cdf.factory( {}, false ); // $ExpectError
+ cdf.factory( false, '5' ); // $ExpectError
+ cdf.factory( {}, [] ); // $ExpectError
+ cdf.factory( '5', ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `factory` method is provided an unsupported number of arguments...
+{
+ cdf.factory( 0 ); // $ExpectError
+ cdf.factory( 0, 4, 8 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/c/Makefile b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/c/Makefile
new file mode 100644
index 000000000000..c8f8e9a1517b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2026 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/stats/base/dists/wald/cdf/examples/c/example.c b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/c/example.c
new file mode 100644
index 000000000000..14a77c0aec07
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/c/example.c
@@ -0,0 +1,44 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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/stats/base/dists/wald/cdf.h"
+#include "stdlib/constants/float64/eps.h"
+#include
+#include
+#include
+
+static double random_uniform( const double min, const double max ) {
+ double v = (double)rand() / ( (double)RAND_MAX + 1.0 );
+ return min + ( v*(max-min) );
+}
+
+int main( void ) {
+ double lambda;
+ double mu;
+ double x;
+ double y;
+ int i;
+
+ for ( i = 0; i < 10; i++ ) {
+ x = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 );
+ mu = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 );
+ lambda = random_uniform( STDLIB_CONSTANT_FLOAT64_EPS, 10.0 );
+ y = stdlib_base_dists_wald_cdf( x, mu, lambda );
+ printf( "x: %lf, µ: %lf, λ: %lf, F(x;µ,λ): %lf\n", x, mu, lambda, y );
+ }
+}
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/index.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/index.js
new file mode 100644
index 000000000000..10e12f42c78f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/examples/index.js
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 uniform = require( '@stdlib/random/array/uniform' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var cdf = require( './../lib' );
+
+var opts = {
+ 'dtype': 'float64'
+};
+var x = uniform( 10, EPS, 10.0, opts );
+var mu = uniform( 10, EPS, 10.0, opts );
+var lambda = uniform( 10, EPS, 20.0, opts );
+
+logEachMap( 'x: %0.4f, µ: %0.4f, λ: %0.4f, f(x;µ,λ): %0.4f', x, mu, lambda, cdf );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/include.gypi b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/include.gypi
new file mode 100644
index 000000000000..bee8d41a2caf
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/include.gypi
@@ -0,0 +1,53 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2026 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': [
+ '
+ */
+ function cdf( x ) {
+ var t1;
+ var t2;
+ var z;
+
+ if ( isnan( x ) ) {
+ return NaN;
+ }
+ if ( x <= 0.0 ) {
+ return 0.0;
+ }
+ z = sqrt( lambda / x );
+
+ // Φ(a) = 0.5 * erfc( -a / √2 )
+ t1 = 0.5 * erfc( ( -z * ( ( x / mu ) - 1.0 ) ) / sqrt( 2.0 ) );
+ t2 = C * 0.5 * erfc( ( z * ( ( x / mu ) + 1.0 ) ) / sqrt( 2.0 ) );
+ return t1 + t2;
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = factory;
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/index.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/index.js
new file mode 100644
index 000000000000..0855c01e086e
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/index.js
@@ -0,0 +1,51 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+/**
+* Wald distribution cumulative distribution function (CDF).
+*
+* @module @stdlib/stats/base/dists/wald/cdf
+*
+* @example
+* var cdf = require( '@stdlib/stats/base/dists/wald/cdf' );
+*
+* var y = cdf( 2.0, 1.0, 1.0 );
+* // returns ~0.885
+*
+* var myCDF = cdf.factory( 2.0, 1.0 );
+* y = myCDF( 2.0 );
+* // returns ~0.714
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var main = require( './main.js' );
+var factory = require( './factory.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'factory', factory );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/main.js
new file mode 100644
index 000000000000..7b87b92364a4
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/main.js
@@ -0,0 +1,115 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 exp = require( '@stdlib/math/base/special/exp' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var erfc = require( '@stdlib/math/base/special/erfc' );
+var PINF = require( '@stdlib/constants/float64/pinf' );
+
+
+// MAIN //
+
+/**
+* Evaluates the cumulative distribution function (CDF) for a Wald distribution with mean `mu` and shape parameter `lambda` at a value `x`.
+*
+* @param {number} x - input value
+* @param {number} mu - mean
+* @param {NonNegativeNumber} lambda - shape parameter
+* @returns {Probability} evaluated cumulative distribution function
+*
+* @example
+* var y = cdf( 2.0, 1.0, 1.0 );
+* // returns ~0.885
+*
+* @example
+* var y = cdf( 0.5, 2.0, 3.0 );
+* // returns ~0.055
+*
+* @example
+* var y = cdf( NaN, 1.0, 1.0 );
+* // returns NaN
+*
+* @example
+* var y = cdf( 1.0, NaN, 1.0 );
+* // returns NaN
+*
+* @example
+* var y = cdf( 1.0, 1.0, NaN );
+* // returns NaN
+*
+* @example
+* // Non-positive mean:
+* var y = cdf( 2.0, 0.0, 1.0 );
+* // returns NaN
+*
+* @example
+* // Negative shape parameter:
+* var y = cdf( 2.0, 1.0, -1.0 );
+* // returns NaN
+*
+* @example
+* // Zero shape parameter (degenerate distribution):
+* var y = cdf( 1.0, 1.0, 0.0 );
+* // returns 1.0
+*
+* @example
+* var y = cdf( 0.0, 1.0, 1.0 );
+* // returns 0.0
+*/
+function cdf( x, mu, lambda ) {
+ var t1;
+ var t2;
+ var C;
+ var z;
+
+ if (
+ isnan( x ) ||
+ isnan( mu ) ||
+ isnan( lambda ) ||
+ mu <= 0.0 ||
+ lambda < 0.0
+ ) {
+ return NaN;
+ }
+ if ( lambda === 0.0 ) {
+ return ( x < mu ) ? 0.0 : 1.0;
+ }
+ if ( x <= 0.0 ) {
+ return 0.0;
+ }
+ if ( x === PINF ) {
+ return 1.0;
+ }
+ C = exp( 2.0 * lambda / mu );
+ z = sqrt( lambda / x );
+
+ // Φ(a) = 0.5 * erfc( -a / sqrt( 2 ) )
+ t1 = 0.5 * erfc( ( -z * ( ( x / mu ) - 1.0 ) ) / sqrt( 2.0 ) );
+ t2 = C * 0.5 * erfc( ( z * ( ( x / mu ) + 1.0 ) ) / sqrt( 2.0 ) );
+ return t1 + t2;
+}
+
+
+// EXPORTS //
+
+module.exports = cdf;
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/native.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/native.js
new file mode 100644
index 000000000000..69ff3b4e453d
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/lib/native.js
@@ -0,0 +1,69 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 //
+
+/**
+* Evaluates the cumulative distribution function (CDF) for a Wald distribution with mean `mu` and shape parameter `lambda` at a value `x`.
+*
+* @private
+* @param {number} x - input value
+* @param {number} mu - mean
+* @param {number} lambda - shape parameter
+* @returns {Probability} evaluated cumulative distribution function
+*
+* @example
+* var y = cdf( 2.0, 1.0, 1.0 );
+* // returns ~0.885
+*
+* @example
+* var y = cdf( 0.5, 2.0, 3.0 );
+* // returns ~0.055
+*
+* @example
+* var y = cdf( NaN, 0.0, 1.0 );
+* // returns NaN
+*
+* @example
+* var y = cdf( 0.0, NaN, 1.0 );
+* // returns NaN
+*
+* @example
+* var y = cdf( 0.0, 0.0, NaN );
+* // returns NaN
+*
+* @example
+* // Negative shape parameter:
+* var y = cdf( 2.0, 0.0, -1.0 );
+* // returns NaN
+*/
+function cdf( x, mu, lambda ) {
+ return addon( x, mu, lambda );
+}
+
+
+// EXPORTS //
+
+module.exports = cdf;
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/manifest.json b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/manifest.json
new file mode 100644
index 000000000000..9b4c576a0994
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/manifest.json
@@ -0,0 +1,90 @@
+{
+ "options": {
+ "task": "build",
+ "wasm": false
+ },
+ "fields": [
+ {
+ "field": "src",
+ "resolve": true,
+ "relative": true
+ },
+ {
+ "field": "include",
+ "resolve": true,
+ "relative": true
+ },
+ {
+ "field": "libraries",
+ "resolve": false,
+ "relative": false
+ },
+ {
+ "field": "libpath",
+ "resolve": true,
+ "relative": false
+ }
+ ],
+ "confs": [
+ {
+ "task": "build",
+ "wasm": false,
+ "src": [
+ "./src/main.c"
+ ],
+ "include": [
+ "./include"
+ ],
+ "libraries": [],
+ "libpath": [],
+ "dependencies": [
+ "@stdlib/math/base/napi/ternary",
+ "@stdlib/math/base/assert/is-nan",
+ "@stdlib/math/base/special/erfc",
+ "@stdlib/math/base/special/sqrt",
+ "@stdlib/math/base/special/exp",
+ "@stdlib/constants/float64/pinf"
+ ]
+ },
+ {
+ "task": "benchmark",
+ "wasm": false,
+ "src": [
+ "./src/main.c"
+ ],
+ "include": [
+ "./include"
+ ],
+ "libraries": [],
+ "libpath": [],
+ "dependencies": [
+ "@stdlib/math/base/assert/is-nan",
+ "@stdlib/math/base/special/erfc",
+ "@stdlib/math/base/special/sqrt",
+ "@stdlib/math/base/special/exp",
+ "@stdlib/constants/float64/pinf",
+ "@stdlib/constants/float64/eps"
+ ]
+ },
+ {
+ "task": "examples",
+ "wasm": false,
+ "src": [
+ "./src/main.c"
+ ],
+ "include": [
+ "./include"
+ ],
+ "libraries": [],
+ "libpath": [],
+ "dependencies": [
+ "@stdlib/math/base/assert/is-nan",
+ "@stdlib/math/base/special/erfc",
+ "@stdlib/math/base/special/sqrt",
+ "@stdlib/math/base/special/exp",
+ "@stdlib/constants/float64/pinf",
+ "@stdlib/constants/float64/eps"
+ ]
+ }
+ ]
+}
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/package.json b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/package.json
new file mode 100644
index 000000000000..6d8c93d9a825
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/package.json
@@ -0,0 +1,71 @@
+{
+ "name": "@stdlib/stats/base/dists/wald/cdf",
+ "version": "0.0.0",
+ "description": "Wald distribution cumulative distribution function (CDF).",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "gypfile": true,
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "include": "./include",
+ "lib": "./lib",
+ "src": "./src",
+ "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",
+ "statistics",
+ "stats",
+ "distribution",
+ "dist",
+ "probability",
+ "cdf",
+ "cumulative distribution",
+ "distribution function",
+ "inverse",
+ "gaussian",
+ "wald",
+ "univariate",
+ "continuous"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/Makefile b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/Makefile
new file mode 100644
index 000000000000..2caf905cedbe
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/Makefile
@@ -0,0 +1,70 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2026 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/stats/base/dists/wald/cdf/src/addon.c b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/addon.c
new file mode 100644
index 000000000000..3ae24c620f82
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/addon.c
@@ -0,0 +1,22 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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/stats/base/dists/wald/cdf.h"
+#include "stdlib/math/base/napi/ternary.h"
+
+STDLIB_MATH_BASE_NAPI_MODULE_DDD_D( stdlib_base_dists_wald_cdf )
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/main.c b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/main.c
new file mode 100644
index 000000000000..baa0b1a89380
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/src/main.c
@@ -0,0 +1,67 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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/stats/base/dists/wald/cdf.h"
+#include "stdlib/math/base/assert/is_nan.h"
+#include "stdlib/math/base/special/sqrt.h"
+#include "stdlib/math/base/special/exp.h"
+#include "stdlib/math/base/special/erfc.h"
+#include "stdlib/constants/float64/pinf.h"
+
+/**
+* Evaluates the cumulative distribution function (CDF) for a Wald distribution with mean `mu` and shape parameter `lambda` at a value `x`.
+*
+* @param x input value
+* @param mu mean
+* @param lambda shape parameter
+* @return evaluated cumulative distribution function
+*
+* @example
+* double y = stdlib_base_dists_wald_cdf( 2.0, 1.0, 1.0 );
+* // returns ~0.885
+*/
+double stdlib_base_dists_wald_cdf( const double x, const double mu, const double lambda ) {
+ double C;
+ double z;
+ double t1;
+ double t2;
+
+ if (
+ stdlib_base_is_nan( x ) ||
+ stdlib_base_is_nan( mu ) ||
+ stdlib_base_is_nan( lambda ) ||
+ mu <= 0.0 ||
+ lambda < 0.0
+ ) {
+ return 0.0/0.0; // NaN
+ }
+ if ( lambda == 0.0 ) {
+ return ( x < mu ) ? 0.0 : 1.0;
+ }
+ if ( x <= 0.0 ) {
+ return 0.0;
+ }
+ if ( x == STDLIB_CONSTANT_FLOAT64_PINF ) {
+ return 1.0;
+ }
+ C = stdlib_base_exp( 2.0 * ( lambda / mu ) );
+ z = stdlib_base_sqrt( lambda / x );
+ t1 = 0.5 * stdlib_base_erfc( ( -z * ( ( x / mu ) - 1.0 ) ) / stdlib_base_sqrt( 2.0 ) );
+ t2 = C * 0.5 * stdlib_base_erfc( ( z * ( ( x / mu ) + 1.0 ) ) / stdlib_base_sqrt( 2.0 ) );
+ return t1 + t2;
+}
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/REQUIRE b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/REQUIRE
new file mode 100644
index 000000000000..98be20b58ed3
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/REQUIRE
@@ -0,0 +1,3 @@
+Distributions 0.23.8
+julia 1.5
+JSON 0.21
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/data.json b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/data.json
new file mode 100644
index 000000000000..ddb9531d856f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/data.json
@@ -0,0 +1 @@
+{"expected":[0.956031860972232,0.7222410074214104,0.8388262233512366,0.8063887690741013,0.8993139816208725,0.8754608601606477,0.999857458956787,0.5446625611270753,0.9999219753683246,0.7007193572895988,0.05086146646705278,0.9609072030079305,0.9252233812473168,0.7958070715252243,0.8856198861175603,0.8616320127365377,0.5569342708856,0.6376098409431302,0.8121774439437746,0.5858488156886867,0.8171722709992562,0.6660520279350101,0.768927369212703,0.8409556904974325,0.3930698331676592,0.9089425375062343,0.800636475911108,0.9423977609194308,0.9732221977795502,0.8791812378672993,0.7866151725297192,0.6962333142145349,0.98350473578428,0.5792110472701381,0.7789599352514637,0.8630046536813258,0.9234734033401704,0.93882411947924,0.8684156693232986,0.41248050205809866,0.9192555074415594,0.9592077588644018,0.8394361950927777,0.860700802122654,0.9999999999949734,0.996688525144456,0.8918301639069863,0.847082670992373,0.7535769524105298,0.7924197892407122,0.9741000985461694,0.9996560104745966,0.9218095060200042,0.9710744180680723,0.7018774730314714,0.7405146608193169,0.27411061858629243,0.7333264345523395,0.9999999987532546,0.8914927886458963,0.7883964267140454,0.9999999942442925,0.9135916155064817,1.0,0.4319246946453399,0.9250238576511429,0.7860620958440139,0.6831537509896327,0.80676499801222,0.9939896265478079,0.9324940259747342,0.8793211283380593,0.6514949014453674,0.764372969376012,0.9009677859775579,0.658985893632694,0.8725109653410115,0.5214717769434215,0.9783763207358217,0.9563876792800233,0.9999999975726171,0.9092384901183699,0.9998834526817215,0.9481714276277563,0.8415257350164043,0.8882108308915957,0.7087396828351278,0.9999999999863065,0.874653119480443,0.9314179379685698,0.9986242241761004,0.9999999998862069,1.0,0.9244768544152053,0.9980933741882426,0.7448978634354545,1.0,0.9999914987850471,0.7974936479566863,0.9726371937648199],"x":[13.339281437460926,8.912977822167623,7.957102979390953,12.35436075718989,12.339969578719508,9.426438819747993,7.668296686294445,2.1692153609558864,3.4011347534176264,4.316025794292218,0.9229530194288167,12.963376756163369,12.579123639323475,9.42877594141134,13.138345132228055,14.638348080601085,3.2260969229502034,1.9913522817051794,12.776384124822453,5.024551384281849,2.7721049432643445,2.3868544647055563,5.257862949798037,13.812211159458977,2.4862822750483264,14.590746978893641,6.4403741375779155,12.611340074957582,6.457315339899419,13.825962721789326,4.452905814552913,7.692526981282094,10.546791344686156,3.1270439637182728,4.834256558797152,6.077225515583834,14.585076117850093,7.962641893506339,10.58892375842925,3.0697152886318437,13.33067599052857,15.01262679185554,5.152307422328827,8.872690692769739,15.154656348820843,9.01678384855629,12.393058949720189,12.06997916590109,8.003819435019004,11.948335659807748,13.713030468065579,5.1479634590575944,15.340185710069127,6.9659536427799145,3.0455122037183604,4.905635731970286,0.6814221257735477,4.215139415441513,10.11901634772521,14.889324187414767,8.156143098870603,11.271219164804084,5.202777507536254,15.229988224497541,1.9923931965184833,13.904761893546372,8.021688402301471,6.589330870271463,9.787917171979615,11.198896805725724,4.617404483308332,11.210732912052421,4.064462822290395,5.6565954384854065,10.46528011160431,5.1957240537306,11.974906110785032,3.680827180042188,12.591779723408235,9.011386213102261,15.050092105608336,13.426827000980886,14.794174426259755,14.377462361122904,8.558162962971371,12.638995058209323,2.4246318923228096,3.9757011380532896,13.369756594138892,13.845018861840108,11.299472587885253,11.644206825711048,15.377602790237713,15.468280067699677,9.38039592535914,7.1861475106420345,6.961492820897222,13.69799515148088,10.549343020608445,13.861341125809924],"lambda":[5.417493694832523,3.5238789952256355,3.5826503423369296,4.184161736888616,0.8192276763027957,3.8234223345936043,5.24402809615151,2.309116620114125,4.931035351845412,3.697177902023129,4.501040152049077,0.824316365749665,1.2608698335750619,3.898962176748363,1.9071768838155563,1.0661200524023957,1.737892413325985,1.0848520354174775,3.0524265066226564,4.53590051159232,1.5104329780565457,0.7030050012556267,4.170922611811294,4.18321781425974,4.493616146773953,1.5484848673662235,1.0672123408307272,2.550969419066164,4.240019299144688,2.1981332587295075,0.6206860389947129,5.135115262868535,3.0702149233353544,1.5707969073148815,1.5000651539453742,1.5176015099584297,3.5864184276547055,1.0268631923725597,0.8463599628736713,4.548706801031815,2.875127608083551,0.6875958040761105,1.3430356528748306,1.0547237778575038,2.9663969613697834,4.698529152765462,0.5210199539475586,2.173072691108242,2.7356096134666825,2.752535763924649,1.7634914482320796,3.7626355853845452,0.5800087175995862,4.959236947028113,1.525834277516708,0.7858374963721533,1.2274214567711716,0.7113886242245666,5.43845371287312,0.7690464980421842,1.4177051259025553,5.232575917856365,1.0883665720453035,5.1262093477379915,3.854078463131324,0.6832137945767492,2.0050045722480188,3.6146711847936275,1.9224041853642089,1.433517350792024,1.2181291874967266,3.7132086033156604,2.2047841616030497,4.234870757836539,5.488042283848636,2.1830671389382292,0.8362336779732822,3.4350849308482485,1.5279102835798999,5.377250049346257,3.160931851557253,3.4603513066608573,2.2861637737327833,4.603233814395376,1.5377032103904522,1.4260707211992152,0.988941315869017,5.382372903686453,5.414570172697367,3.7333515739305314,1.1346820229529104,2.1663751137306297,3.6307189578704184,1.1245714812983527,2.011184331744004,4.334090729997929,4.6898987995397,3.135883299543926,1.6494665397527486,0.6962598250060021],"mu":[4.5771270178283565,9.3038859744059,4.751722281845909,8.622974877299928,5.365916778152899,4.803906912583415,1.5325534802851288,3.2224329281058823,0.8644822375289214,4.011919264456063,6.823244256201491,2.778350896580743,4.150228657173185,6.766276040985014,6.042580299851276,10.208458752908047,8.658156905045317,2.835350340487461,9.145377871783827,6.887255654961294,1.8038160785970498,5.147573707948909,3.992401134498663,8.176927813847698,4.793060487504502,5.568353900405826,5.758055021819357,4.050259728920674,2.2345142248166567,6.647223601651859,5.341113052143289,7.635005091794672,2.623011728366624,7.510277907433075,3.969683058783067,3.212129974556723,5.481133786015191,2.418478449916674,6.403403094251223,6.376906389977452,5.037231671293051,3.095048794125324,3.0990537808571776,5.13411445216048,0.9674224972726893,2.1326067610011186,7.245593011100204,7.202350251207326,7.384763227640857,9.867527626581284,2.9942318005224298,1.1199702230489568,5.41025396282806,2.500518259740811,3.221200261662754,10.194295014059612,2.6719688263393477,9.034951928168692,1.1548691956614061,7.804069225669068,7.982762972431228,1.2588672904070015,2.0276911410334892,0.7361314763042155,3.2147938658289905,4.523033556030375,6.728967197191859,7.363485284959012,7.692277686051631,1.759800837729782,1.6645332784000517,5.51699948211175,5.365498592468808,4.367273775239145,4.948392272389236,7.829106616414316,7.2822988911752935,6.61862674845449,2.5674119529149104,3.38556043542913,1.1554783727393232,5.514779981695591,1.6138025966888931,4.9021119688877945,5.315381522103928,5.762061122219851,2.6969213971232806,0.6069810825927209,6.836374954246834,5.043637672806245,1.310431194116007,0.7800923422731771,0.8212929183510083,5.040283626021764,1.5125599301679544,6.054329705696015,0.5186875283592192,1.4946400377219333,10.083078015018645,2.4084751094236774]}
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/runner.jl b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/runner.jl
new file mode 100644
index 000000000000..ac4ece6b1b62
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/fixtures/julia/runner.jl
@@ -0,0 +1,77 @@
+#!/usr/bin/env julia
+#
+# @license Apache-2.0
+#
+# Copyright (c) 2026 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 Distributions: cdf, InverseGaussian
+import JSON
+
+"""
+ gen( x, mu, lambda, name )
+
+Generate fixture data and write to file.
+
+# Arguments
+
+* `x`: input value
+* `mu`: mean
+* `lambda`: shape parameter
+* `name::AbstractString`: output filename
+
+# Examples
+
+``` julia
+julia> x = rand( 1000 ) .* 15.0 .+ 0.1;
+julia> mu = rand( 1000 ) .* 10.0 .+ 0.1;
+julia> lambda = rand( 1000 ) .* 5.0 .+ 0.1;
+julia> gen( x, mu, lambda, "data.json" );
+```
+"""
+function gen( x, mu, lambda, name )
+ z = Array{Float64}( undef, length(x) );
+ for i in eachindex(x)
+ z[ i ] = cdf( InverseGaussian( mu[i], lambda[i] ), x[i] );
+ end
+
+ # Store data to be written to file as a collection:
+ data = Dict([
+ ("x", x),
+ ("mu", mu),
+ ("lambda", lambda),
+ ("expected", z)
+ ]);
+
+ # 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 fixtures:
+x = rand( 100 ) .* 15.0 .+ 0.5;
+mu = rand( 100 ) .* 10.0 .+ 0.5;
+lambda = rand( 100 ) .* 5.0 .+ 0.5;
+gen( x, mu, lambda, "data.json" );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.cdf.js
new file mode 100644
index 000000000000..f69df5087afd
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.cdf.js
@@ -0,0 +1,126 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
+var PINF = require( '@stdlib/constants/float64/pinf' );
+var NINF = require( '@stdlib/constants/float64/ninf' );
+var cdf = 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 cdf, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
+ var y = cdf( NaN, 0.0, 1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+ y = cdf( 0.0, NaN, 1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+ y = cdf( 0.0, 1.0, NaN );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if provided `+infinity` for `x` and a valid `mu` and `lambda`, the function returns `1`', function test( t ) {
+ var y = cdf( PINF, 1.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if provided `-infinity` for `x` and a valid `mu` and `lambda`, the function returns `0`', function test( t ) {
+ var y = cdf( NINF, 1.0, 0.0 );
+ t.strictEqual( y, 0.0, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if provided a negative `lambda`, the function always returns `NaN`', function test( t ) {
+ var y;
+
+ y = cdf( 2.0, 0.0, -1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 0.0, 0.0, -1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, 0.0, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, PINF, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, NINF, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, NaN, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'if provided `lambda` equals `0`, the function evaluates a degenerate distribution centered at `mu`', function test( t ) {
+ var y;
+
+ y = cdf( 2.0, 2.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
+
+ y = cdf( 3.0, 2.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
+
+ y = cdf( 1.0, 2.0, 0.0 );
+ t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
+
+ t.end();
+});
+
+tape( 'the function evaluates the cdf for `x` given parameters `mu` and `lambda`', function test( t ) {
+ var expected;
+ var lambda;
+ var mu;
+ var i;
+ var x;
+ var y;
+
+ expected = data.expected;
+ x = data.x;
+ mu = data.mu;
+ lambda = data.lambda;
+ for ( i = 0; i < x.length; i++ ) {
+ y = cdf( x[i], mu[i], lambda[i] );
+ if ( y === expected[i] ) {
+ t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+ } else {
+ t.ok( isAlmostSameValue( y, expected[i], 1600 ), 'within tolerance. x: '+x[ i ]+'. mu: '+mu[i]+'. lambda: '+lambda[i]+'. y: '+y+'. E: '+expected[ i ]+'.' );
+ }
+ }
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.factory.js
new file mode 100644
index 000000000000..32a12fd929cf
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.factory.js
@@ -0,0 +1,171 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
+var PINF = require( '@stdlib/constants/float64/pinf' );
+var NINF = require( '@stdlib/constants/float64/ninf' );
+var factory = require( './../lib/factory.js' );
+
+
+// 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 factory, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function returns a function', function test( t ) {
+ var cdf = factory( 0.0, 1.0 );
+ t.strictEqual( typeof cdf, 'function', 'returns expected value' );
+ t.end();
+});
+
+tape( 'if provided `NaN` for any parameter, the created function returns `NaN`', function test( t ) {
+ var cdf;
+ var y;
+
+ cdf = factory( 0.0, 1.0 );
+ y = cdf( NaN );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( NaN, 1.0 );
+ y = cdf( 0.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( 1.0, NaN );
+ y = cdf( 0.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( NaN, NaN );
+ y = cdf( 0.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( NaN, NaN );
+ y = cdf( NaN );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'if provided a valid `mu` and `lambda`, the function returns a function which returns `1` when provided `+infinity` for `x`', function test( t ) {
+ var cdf;
+ var y;
+
+ cdf = factory( 1.0, 0.0 );
+ y = cdf( PINF );
+ t.strictEqual( y, 1.0, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'if provided a valid `mu` and `lambda`, the function returns a function which returns `0` when provided `-infinity` for `x`', function test( t ) {
+ var cdf;
+ var y;
+
+ cdf = factory( 1.0, 0.0 );
+ y = cdf( NINF );
+ t.strictEqual( y, 0.0, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'if provided a negative `lambda`, the created function always returns `NaN`', function test( t ) {
+ var cdf;
+ var y;
+
+ cdf = factory( 0.0, -1.0 );
+
+ y = cdf( 2.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 0.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( 0.0, NINF );
+ y = cdf( 2.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( PINF, NINF );
+ y = cdf( 2.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( NINF, NINF );
+ y = cdf( 2.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ cdf = factory( NaN, NINF );
+ y = cdf( 2.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'if `lambda` equals `0`, the created function evaluates a degenerate distribution centered at `mu`', function test( t ) {
+ var cdf;
+ var y;
+
+ cdf = factory( 2.0, 0.0 );
+
+ y = cdf( 2.0, 2.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns expected value' );
+
+ y = cdf( 3.0, 2.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns expected value' );
+
+ y = cdf( 1.0, 2.0, 0.0 );
+ t.strictEqual( y, 0.0, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function evaluates the cdf for `x` given parameters `mu` and `lambda`', function test( t ) {
+ var expected;
+ var lambda;
+ var cdf;
+ var mu;
+ var x;
+ var y;
+ var i;
+
+ expected = data.expected;
+ x = data.x;
+ mu = data.mu;
+ lambda = data.lambda;
+ for ( i = 0; i < x.length; i++ ) {
+ cdf = factory( mu[i], lambda[i] );
+ y = cdf( x[i] );
+ if ( y === expected[i] ) {
+ t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+ } else {
+ t.ok( isAlmostSameValue( y, expected[i], 1500 ), 'within tolerance. x: '+x[ i ]+'. mu: '+mu[i]+'. lambda: '+lambda[i]+'. y: '+y+'. E: '+expected[ i ]+'.' );
+ }
+ }
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.js
new file mode 100644
index 000000000000..85a2b4b63e97
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.js
@@ -0,0 +1,38 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 cdf = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof cdf, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
+ t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.native.js
new file mode 100644
index 000000000000..3c041e090429
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/dists/wald/cdf/test/test.native.js
@@ -0,0 +1,135 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 tryRequire = require( '@stdlib/utils/try-require' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
+var PINF = require( '@stdlib/constants/float64/pinf' );
+var NINF = require( '@stdlib/constants/float64/ninf' );
+
+
+// FIXTURES //
+
+var data = require( './fixtures/julia/data.json' );
+
+
+// VARIABLES //
+
+var cdf = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var opts = {
+ 'skip': ( cdf instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof cdf, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
+ var y = cdf( NaN, 0.0, 1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+ y = cdf( 0.0, NaN, 1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+ y = cdf( 0.0, 1.0, NaN );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if provided `+infinity` for `x` and a valid `mu` and `lambda`, the function returns `1`', opts, function test( t ) {
+ var y = cdf( PINF, 1.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if provided `-infinity` for `x` and a valid `mu` and `lambda`, the function returns `0`', opts, function test( t ) {
+ var y = cdf( NINF, 1.0, 0.0 );
+ t.strictEqual( y, 0.0, 'returns expected value' );
+ t.end();
+});
+
+tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts, function test( t ) {
+ var y;
+
+ y = cdf( 2.0, 0.0, -1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 0.0, 0.0, -1.0 );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, 0.0, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, PINF, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, NINF, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ y = cdf( 2.0, NaN, NINF );
+ t.strictEqual( isnan( y ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'if provided `lambda` equals `0`, the function evaluates a degenerate distribution centered at `mu`', opts, function test( t ) {
+ var y;
+
+ y = cdf( 2.0, 2.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
+
+ y = cdf( 3.0, 2.0, 0.0 );
+ t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
+
+ y = cdf( 1.0, 2.0, 0.0 );
+ t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
+
+ t.end();
+});
+
+tape( 'the function evaluates the cdf for `x` given parameters `mu` and `lambda`', opts, function test( t ) {
+ var expected;
+ var lambda;
+ var mu;
+ var x;
+ var y;
+ var i;
+
+ expected = data.expected;
+ x = data.x;
+ mu = data.mu;
+ lambda = data.lambda;
+ for ( i = 0; i < x.length; i++ ) {
+ y = cdf( x[i], mu[i], lambda[i] );
+ if ( y === expected[i] ) {
+ t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+ } else {
+ t.ok( isAlmostSameValue( y, expected[i], 1500 ), 'within tolerance. x: '+x[ i ]+'. mu: '+mu[i]+'. lambda: '+lambda[i]+'. y: '+y+'. E: '+expected[ i ]+'.' );
+ }
+ }
+ t.end();
+});