diff --git a/lib/node_modules/@stdlib/fft/rfftf/README.md b/lib/node_modules/@stdlib/fft/rfftf/README.md
new file mode 100644
index 000000000000..692078f12848
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/README.md
@@ -0,0 +1,186 @@
+
+
+# rfftf
+
+> Return a new [ndarray][@stdlib/ndarray/ctor] containing the one-dimensional discrete Fourier transform of a real-valued input [ndarray][@stdlib/ndarray/ctor].
+
+
+
+## Usage
+
+```javascript
+var rfftf = require( '@stdlib/fft/rfftf' );
+```
+
+#### rfftf( x\[, options] )
+
+Returns a new [ndarray][@stdlib/ndarray/ctor] containing the one-dimensional discrete Fourier transform of a real-valued input [ndarray][@stdlib/ndarray/ctor].
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, 3.0, 4.0 ] );
+
+var out = rfftf( x );
+// returns
+```
+
+The function has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+- **options**: function options (_optional_).
+
+The function accepts the following options:
+
+- **n**: number of points over which to compute the transform. If not provided, defaults to the length of the input [ndarray][@stdlib/ndarray/ctor]. If `n` is greater than the input length, the input is zero-padded. If `n` is less than the input length, the input is truncated.
+- **normalize**: normalization mode. Must be one of the following: `'backward'` (default), `'ortho'`, or `'forward'`.
+
+The returned [ndarray][@stdlib/ndarray/ctor] has a complex-valued floating-point [data type][@stdlib/ndarray/dtypes] determined by the input [data type][@stdlib/ndarray/dtypes]. For example, `float64` maps to `complex128`. The returned [ndarray][@stdlib/ndarray/ctor] has a length of `floor(N/2) + 1`, where `N` is the length of the sequence to transform.
+
+By default, the number of transform points equals the length of the input [ndarray][@stdlib/ndarray/ctor]. To specify a different number of transform points, provide an `n` option.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, 3.0, 4.0 ] );
+
+var out = rfftf( x, {
+ 'n': 8
+});
+// returns
+```
+
+By default, no normalization is applied to the transform result. To specify a normalization mode, provide a `normalize` option.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, 3.0, 4.0 ] );
+
+// Scale by 1/sqrt(N):
+var out = rfftf( x, {
+ 'normalize': 'ortho'
+});
+// returns
+```
+
+The normalization modes are as follows:
+
+- **backward**: no normalization (default).
+- **ortho**: scale by `1/sqrt(N)`, making the transform orthonormal.
+- **forward**: scale by `1/N`.
+
+#### rfftf.assign( x, out\[, options] )
+
+Computes the one-dimensional discrete Fourier transform of a real-valued input [ndarray][@stdlib/ndarray/ctor] and assigns the results to a provided output [ndarray][@stdlib/ndarray/ctor].
+
+```javascript
+var zeros = require( '@stdlib/ndarray/zeros' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, 2.0, 3.0, 4.0 ] );
+var out = zeros( [ 3 ], {
+ 'dtype': 'complex128'
+});
+
+var v = rfftf.assign( x, out );
+// returns
+
+var bool = ( v === out );
+// returns true
+```
+
+The function has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+- **out**: output [ndarray][@stdlib/ndarray/ctor]. Must have a complex-valued floating-point [data type][@stdlib/ndarray/dtypes].
+- **options**: function options (_optional_).
+
+The function accepts the following options:
+
+- **n**: number of points over which to compute the transform. If not provided, defaults to the length of the input [ndarray][@stdlib/ndarray/ctor]. If `n` is greater than the input length, the input is zero-padded. If `n` is less than the input length, the input is truncated.
+- **normalize**: normalization mode. Must be one of the following: `'backward'` (default), `'ortho'`, or `'forward'`.
+
+
+
+
+
+
+
+## Notes
+
+- The function does **not** mutate the input [ndarray][@stdlib/ndarray/ctor].
+- The output [ndarray][@stdlib/ndarray/ctor] contains only the non-negative frequency terms of the full DFT, exploiting the Hermitian symmetry of real-valued input. For an input of length `N`, the output has length `floor(N/2) + 1`.
+- The output [ndarray][@stdlib/ndarray/ctor] has a complex-valued floating-point [data type][@stdlib/ndarray/dtypes] determined by the input [data type][@stdlib/ndarray/dtypes]. For example, `float64` input maps to `complex128` output.
+- The DC component (index `0`) and, for even-length transforms, the Nyquist component (last index) are always purely real (i.e., have zero imaginary parts).
+- This transform is unnormalized by default. A call to this function followed by a call performing a backward transform will multiply the input by `N`. To obtain an orthonormal transform, set the `normalize` option to `'ortho'`.
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var uniform = require( '@stdlib/random/uniform' );
+var rfftf = require( '@stdlib/fft/rfftf' );
+
+// Generate an ndarray of random numbers:
+var x = uniform( [ 8 ], -10.0, 10.0, {
+ 'dtype': 'float64'
+});
+console.log( ndarray2array( x ) );
+
+// Perform operation:
+var out = rfftf( x );
+
+// Print the results:
+console.log( ndarray2array( out ) );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/ndarray/dtypes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/dtypes
+
+
+
+
diff --git a/lib/node_modules/@stdlib/fft/rfftf/benchmark/benchmark.assign.js b/lib/node_modules/@stdlib/fft/rfftf/benchmark/benchmark.assign.js
new file mode 100644
index 000000000000..8506cfe11814
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/benchmark/benchmark.assign.js
@@ -0,0 +1,118 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var uniform = require( '@stdlib/random/uniform' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var reinterpret128 = require( '@stdlib/strided/base/reinterpret-complex128' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assign = require( './../lib/assign.js' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var out;
+ var M;
+ var x;
+
+ M = floor( len/2 ) + 1;
+ x = uniform( [ len ], -50.0, 50.0, options );
+ out = zeros( [ M ], {
+ 'dtype': 'complex128'
+ });
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var view;
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = assign( x, out );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ view = reinterpret128( getData( o ), 0 );
+ if ( isnan( view[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( format( '%s:assign:dtype=%s,len=%d', pkg, options.dtype, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/fft/rfftf/benchmark/benchmark.js b/lib/node_modules/@stdlib/fft/rfftf/benchmark/benchmark.js
new file mode 100644
index 000000000000..45a168ebc790
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/benchmark/benchmark.js
@@ -0,0 +1,107 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/uniform' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var reinterpret128 = require( '@stdlib/strided/base/reinterpret-complex128' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var rfftf = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var x = uniform( [ len ], -50.0, 50.0, options );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var view;
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = rfftf( x );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ view = reinterpret128( getData( o ), 0 );
+ if ( isnan( view[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( format( '%s:dtype=%s,len=%d', pkg, options.dtype, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/fft/rfftf/docs/repl.txt b/lib/node_modules/@stdlib/fft/rfftf/docs/repl.txt
new file mode 100644
index 000000000000..cd954fc65176
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/docs/repl.txt
@@ -0,0 +1,90 @@
+
+{{alias}}( x[, options] )
+ Returns a new ndarray containing the one-dimensional discrete Fourier
+ transform of a real-valued input ndarray.
+
+ The returned ndarray has a complex-valued floating-point data type
+ determined by the input data type. For example, `float64` maps to
+ `complex128`.
+
+ The returned ndarray has a length of `floor(N/2) + 1`, where `N` is the
+ length of the sequence to transform.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or "generic" data type.
+
+ options: Object (optional)
+ Function options.
+
+ options.n: integer (optional)
+ Number of points over which to compute the transform. If not provided,
+ the number of points is equal to the length of the input array. If the
+ value is greater than the length of the input array, the input is
+ zero-padded. If the value is less than the length of the input array,
+ the input is truncated.
+
+ options.normalize: string (optional)
+ Normalization mode. Must be one of the following: 'backward' (default),
+ 'ortho', or 'forward'. When set to 'backward', no normalization is
+ applied. When set to 'ortho', the result is scaled by `1/sqrt(n)`.
+ When set to 'forward', the result is scaled by `1/n`.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+ > var out = {{alias}}( x )
+
+
+
+{{alias}}.assign( x, out[, options] )
+ Computes the one-dimensional discrete Fourier transform of a real-valued
+ input ndarray and assigns the results to a provided output ndarray.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or "generic" data type.
+
+ out: ndarray
+ Output array. Must have a complex-valued floating-point data type.
+
+ options: Object (optional)
+ Function options.
+
+ options.n: integer (optional)
+ Number of points over which to compute the transform. If not provided,
+ the number of points is equal to the length of the input array. If the
+ value is greater than the length of the input array, the input is
+ zero-padded. If the value is less than the length of the input array,
+ the input is truncated.
+
+ options.normalize: string (optional)
+ Normalization mode. Must be one of the following: 'backward' (default),
+ 'ortho', or 'forward'. When set to 'backward', no normalization is
+ applied. When set to 'ortho', the result is scaled by `1/sqrt(n)`.
+ When set to 'forward', the result is scaled by `1/n`.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+ > var opts = { 'dtype': 'complex128' };
+ > var out = {{alias:@stdlib/ndarray/zeros}}( [ 3 ], opts );
+ > var v = {{alias}}.assign( x, out )
+
+ > var bool = ( v === out )
+ true
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/fft/rfftf/docs/types/index.d.ts b/lib/node_modules/@stdlib/fft/rfftf/docs/types/index.d.ts
new file mode 100644
index 000000000000..8ad97a723a13
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/docs/types/index.d.ts
@@ -0,0 +1,187 @@
+/*
+* @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
+
+///
+
+import { realndarray, complexndarray, genericndarray } from '@stdlib/types/ndarray';
+
+/**
+* Input array.
+*/
+type InputArray = realndarray | genericndarray;
+
+/**
+* Interface defining options.
+*/
+interface Options {
+ /**
+ * Number of points over which to compute the transform.
+ */
+ n?: number;
+
+ /**
+ * Normalization mode.
+ */
+ normalize?: 'backward' | 'ortho' | 'forward';
+}
+
+/**
+* Interface for computing the forward real FFT.
+*/
+interface Rfftf {
+ /**
+ * Returns a new ndarray containing the one-dimensional discrete Fourier transform of a real-valued input ndarray.
+ *
+ * @param x - input ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ * var ndarray = require( '@stdlib/ndarray/ctor' );
+ *
+ * // Create a data buffer:
+ * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+ *
+ * // Define the shape of the input array:
+ * var sh = [ 4 ];
+ *
+ * // Define the array strides:
+ * var sx = [ 1 ];
+ *
+ * // Define the index offset:
+ * var ox = 0;
+ *
+ * // Create an input ndarray:
+ * var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+ *
+ * // Perform operation:
+ * var out = rfftf( x );
+ * // returns [ [ 10.0, 0.0 ], [ -2.0, 2.0 ], [ -2.0, 0.0 ] ]
+ */
+ ( x: InputArray, options?: Options ): complexndarray;
+
+ /**
+ * Computes the one-dimensional discrete Fourier transform of a real-valued input ndarray and assigns the results to a provided output ndarray.
+ *
+ * @param x - input ndarray
+ * @param out - output ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ * var ndarray = require( '@stdlib/ndarray/ctor' );
+ * var zeros = require( '@stdlib/ndarray/zeros' );
+ *
+ * // Create a data buffer:
+ * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+ *
+ * // Define the shape of the input array:
+ * var sh = [ 4 ];
+ *
+ * // Define the array strides:
+ * var sx = [ 1 ];
+ *
+ * // Define the index offset:
+ * var ox = 0;
+ *
+ * // Create an input ndarray:
+ * var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+ *
+ * // Create an output ndarray:
+ * var out = zeros( [ 3 ], { 'dtype': 'complex128' } );
+ *
+ * // Perform operation:
+ * var v = rfftf.assign( x, out );
+ * // returns [ [ 10.0, 0.0 ], [ -2.0, 2.0 ], [ -2.0, 0.0 ] ]
+ *
+ * var bool = ( v === out );
+ * // returns true
+ */
+ assign( x: InputArray, out: T, options?: Options ): T;
+}
+
+/**
+* Returns a new ndarray containing the one-dimensional discrete Fourier transform of a real-valued input ndarray.
+*
+* @param x - input ndarray
+* @param options - function options
+* @returns output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 4 ];
+*
+* // Define the array strides:
+* var sx = [ 1 ];
+*
+* // Define the index offset:
+* var ox = 0;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Perform operation:
+* var out = rfftf( x );
+* // returns [ [ 10.0, 0.0 ], [ -2.0, 2.0 ], [ -2.0, 0.0 ] ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var zeros = require( '@stdlib/ndarray/zeros' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 4 ];
+*
+* // Define the array strides:
+* var sx = [ 1 ];
+*
+* // Define the index offset:
+* var ox = 0;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Create an output ndarray:
+* var out = zeros( [ 3 ], { 'dtype': 'complex128' } );
+*
+* // Perform operation:
+* var v = rfftf.assign( x, out );
+* // returns [ [ 10.0, 0.0 ], [ -2.0, 2.0 ], [ -2.0, 0.0 ] ]
+*
+* var bool = ( v === out );
+* // returns true
+*/
+declare const rfftf: Rfftf;
+
+
+// EXPORTS //
+
+export = rfftf;
diff --git a/lib/node_modules/@stdlib/fft/rfftf/docs/types/test.ts b/lib/node_modules/@stdlib/fft/rfftf/docs/types/test.ts
new file mode 100644
index 000000000000..7f8ffdfb3da9
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/docs/types/test.ts
@@ -0,0 +1,182 @@
+/*
+* @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.
+*/
+
+/* eslint-disable space-in-parens */
+
+///
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import rfftf = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+ const x = zeros( [ 4 ], {
+ 'dtype': 'float64'
+ });
+
+ rfftf( x ); // $ExpectType complexndarray
+ rfftf( x, {} ); // $ExpectType complexndarray
+ rfftf( x, { 'n': 8 } ); // $ExpectType complexndarray
+ rfftf( x, { 'normalize': 'ortho' } ); // $ExpectType complexndarray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+ rfftf( '5' ); // $ExpectError
+ rfftf( 5 ); // $ExpectError
+ rfftf( true ); // $ExpectError
+ rfftf( false ); // $ExpectError
+ rfftf( null ); // $ExpectError
+ rfftf( void 0 ); // $ExpectError
+ rfftf( {} ); // $ExpectError
+ rfftf( ( x: number ): number => x ); // $ExpectError
+
+ rfftf( '5', {} ); // $ExpectError
+ rfftf( 5, {} ); // $ExpectError
+ rfftf( true, {} ); // $ExpectError
+ rfftf( false, {} ); // $ExpectError
+ rfftf( null, {} ); // $ExpectError
+ rfftf( void 0, {} ); // $ExpectError
+ rfftf( {}, {} ); // $ExpectError
+ rfftf( ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an options argument which is not an object...
+{
+ const x = zeros( [ 4 ], {
+ 'dtype': 'float64'
+ });
+
+ rfftf( x, '5' ); // $ExpectError
+ rfftf( x, 5 ); // $ExpectError
+ rfftf( x, true ); // $ExpectError
+ rfftf( x, false ); // $ExpectError
+ rfftf( x, null ); // $ExpectError
+ rfftf( x, [] ); // $ExpectError
+ rfftf( x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 4 ], {
+ 'dtype': 'float64'
+ });
+
+ rfftf(); // $ExpectError
+ rfftf( x, {}, {} ); // $ExpectError
+}
+
+// Attached to the function is an `assign` method which returns an ndarray...
+{
+ const x = zeros( [ 4 ], {
+ 'dtype': 'float64'
+ });
+ const out = zeros( [ 3 ], {
+ 'dtype': 'complex128'
+ });
+
+ rfftf.assign( x, out ); // $ExpectType complex128ndarray
+ rfftf.assign( x, out, {} ); // $ExpectType complex128ndarray
+ rfftf.assign( x, out, { 'normalize': 'ortho' } ); // $ExpectType complex128ndarray
+ rfftf.assign( x, out, { 'n': 8 } ); // $ExpectType complex128ndarray
+}
+
+// The compiler throws an error if the `assign` method is provided a first argument which is not an ndarray...
+{
+ const out = zeros( [ 3 ], {
+ 'dtype': 'complex128'
+ });
+
+ rfftf.assign( '5', out ); // $ExpectError
+ rfftf.assign( 5, out ); // $ExpectError
+ rfftf.assign( true, out ); // $ExpectError
+ rfftf.assign( false, out ); // $ExpectError
+ rfftf.assign( null, out ); // $ExpectError
+ rfftf.assign( void 0, out ); // $ExpectError
+ rfftf.assign( {}, out ); // $ExpectError
+ rfftf.assign( ( x: number ): number => x, out ); // $ExpectError
+
+ rfftf.assign( '5', out, {} ); // $ExpectError
+ rfftf.assign( 5, out, {} ); // $ExpectError
+ rfftf.assign( true, out, {} ); // $ExpectError
+ rfftf.assign( false, out, {} ); // $ExpectError
+ rfftf.assign( null, out, {} ); // $ExpectError
+ rfftf.assign( void 0, out, {} ); // $ExpectError
+ rfftf.assign( {}, out, {} ); // $ExpectError
+ rfftf.assign( ( x: number ): number => x, out, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an output argument which is not an ndarray...
+{
+ const x = zeros( [ 4 ], {
+ 'dtype': 'float64'
+ });
+
+ rfftf.assign( x, '5' ); // $ExpectError
+ rfftf.assign( x, 5 ); // $ExpectError
+ rfftf.assign( x, true ); // $ExpectError
+ rfftf.assign( x, false ); // $ExpectError
+ rfftf.assign( x, null ); // $ExpectError
+ rfftf.assign( x, void 0 ); // $ExpectError
+ rfftf.assign( x, {} ); // $ExpectError
+ rfftf.assign( x, ( x: number ): number => x ); // $ExpectError
+
+ rfftf.assign( x, '5', {} ); // $ExpectError
+ rfftf.assign( x, 5, {} ); // $ExpectError
+ rfftf.assign( x, true, {} ); // $ExpectError
+ rfftf.assign( x, false, {} ); // $ExpectError
+ rfftf.assign( x, null, {} ); // $ExpectError
+ rfftf.assign( x, void 0, {} ); // $ExpectError
+ rfftf.assign( x, {}, {} ); // $ExpectError
+ rfftf.assign( x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an options argument which is not an object...
+{
+ const x = zeros( [ 4 ], {
+ 'dtype': 'float64'
+ });
+ const out = zeros( [ 3 ], {
+ 'dtype': 'complex128'
+ });
+
+ rfftf.assign( x, out, '5' ); // $ExpectError
+ rfftf.assign( x, out, 5 ); // $ExpectError
+ rfftf.assign( x, out, true ); // $ExpectError
+ rfftf.assign( x, out, false ); // $ExpectError
+ rfftf.assign( x, out, null ); // $ExpectError
+ rfftf.assign( x, out, [] ); // $ExpectError
+ rfftf.assign( x, out, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 4 ], {
+ 'dtype': 'float64'
+ });
+ const out = zeros( [ 3 ], {
+ 'dtype': 'complex128'
+ });
+
+ rfftf.assign(); // $ExpectError
+ rfftf.assign( x ); // $ExpectError
+ rfftf.assign( x, out, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/fft/rfftf/examples/index.js b/lib/node_modules/@stdlib/fft/rfftf/examples/index.js
new file mode 100644
index 000000000000..db3a363d7861
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/examples/index.js
@@ -0,0 +1,35 @@
+/**
+* @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 ndarray2array = require( '@stdlib/ndarray/to-array' );
+var uniform = require( '@stdlib/random/uniform' );
+var rfftf = require( './../lib' );
+
+// Generate an ndarray of random numbers:
+var x = uniform( [ 8 ], -10.0, 10.0, {
+ 'dtype': 'float64'
+});
+console.log( ndarray2array( x ) );
+
+// Perform operation:
+var out = rfftf( x );
+
+// Print the results:
+console.log( ndarray2array( out ) );
diff --git a/lib/node_modules/@stdlib/fft/rfftf/lib/assign.js b/lib/node_modules/@stdlib/fft/rfftf/lib/assign.js
new file mode 100644
index 000000000000..705bf5e0ddc6
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/lib/assign.js
@@ -0,0 +1,178 @@
+/**
+* @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 hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var isPlainObject = require( '@stdlib/assert/is-plain-object' );
+var isNonNegativeInteger = require( '@stdlib/assert/is-nonnegative-integer' ).isPrimitive;
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var getStride = require( '@stdlib/ndarray/base/stride' );
+var getOffset = require( '@stdlib/ndarray/base/offset' );
+var sliceTo = require( '@stdlib/ndarray/base/slice-to' );
+var gcopy = require( '@stdlib/blas/base/gcopy' ).ndarray;
+var baseZeros = require( '@stdlib/ndarray/base/zeros' );
+var reinterpret128 = require( '@stdlib/strided/base/reinterpret-complex128' );
+var reinterpret64 = require( '@stdlib/strided/base/reinterpret-complex64' );
+var gscal = require( '@stdlib/blas/base/gscal' ).ndarray;
+var contains = require( '@stdlib/array/base/assert/contains' );
+var join = require( '@stdlib/array/base/join' );
+var format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// VARIABLES //
+
+var NORMS = [ 'backward', 'ortho', 'forward' ];
+
+
+// MAIN //
+
+/**
+* Computes the one-dimensional discrete Fourier transform of a real-valued input ndarray and assigns the result to a provided output ndarray.
+*
+* @param {ndarrayLike} x - input ndarray
+* @param {ndarrayLike} out - output ndarray
+* @param {Options} [options] - function options
+* @param {NonNegativeInteger} [options.n] - number of points over which to compute the transform
+* @param {string} [options.normalize='backward'] - normalization mode
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} second argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {Error} must provide valid options
+* @returns {ndarrayLike} output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var zeros = require( '@stdlib/ndarray/zeros' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 4 ];
+*
+* // Define the array strides:
+* var sx = [ 1 ];
+*
+* // Define the index offset:
+* var ox = 0;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Create an output ndarray:
+* var out = zeros( [ 3 ], { 'dtype': 'complex128' } );
+*
+* // Perform operation:
+* var v = rfftf( x, out );
+* // returns [ [ 10.0, 0.0 ], [ -2.0, 2.0 ], [ -2.0, 0.0 ] ]
+*
+* var bool = ( v === out );
+* // returns true
+*/
+function rfftf( x, out ) {
+ var options;
+ var norm;
+ var view;
+ var xdt;
+ var odt;
+ var sh;
+ var M;
+ var N;
+ var n;
+ var y;
+ var s;
+
+ if ( !isndarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
+ }
+ if ( !isndarrayLike( out ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must be an ndarray-like object. Value: `%s`.', out ) );
+ }
+ norm = 'backward';
+ xdt = getDType( x );
+ odt = getDType( out );
+ sh = getShape( x );
+ N = sh[ 0 ];
+ n = N;
+ if ( arguments.length > 2 ) {
+ options = arguments[ 2 ];
+ if ( !isPlainObject( options ) ) {
+ throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
+ if ( hasOwnProp( options, 'n' ) ) {
+ n = options.n;
+ if ( !isNonNegativeInteger( n ) ) {
+ throw new TypeError( format( 'invalid option. `%s` option must be a nonnegative integer. Option: `%s`.', 'n', n ) );
+ }
+ }
+ if ( hasOwnProp( options, 'normalize' ) ) {
+ norm = options.normalize;
+ if ( !contains( NORMS, norm ) ) {
+ throw new TypeError( format( 'invalid option. `%s` option must be one of the following: "%s". Option: `%s`.', 'normalize', join( NORMS, '", "' ), norm ) );
+ }
+ }
+ }
+ M = floor( n/2 ) + 1;
+
+ // When n differs from N, create a new input of length n:
+ if ( n !== N ) {
+ if ( n < N ) {
+ // Create a view of the first n elements:
+ x = sliceTo( x, [ n ], false, false );
+ } else {
+ // Create a new array of length n and copy the first N elements:
+ y = baseZeros( xdt, [ n ], getOrder( x ) );
+ gcopy( N, getData( x ), getStride( x, 0 ), getOffset( x ), getData( y ), 1, 0 ); // eslint-disable-line max-len
+ x = y;
+ }
+ }
+ // Compute the forward FFT:
+ base( out, x );
+
+ // Apply normalization:
+ if ( norm !== 'backward' ) {
+ if ( odt === 'complex128' ) {
+ view = reinterpret128( getData( out ), 0 );
+ } else {
+ view = reinterpret64( getData( out ), 0 );
+ }
+ if ( norm === 'ortho' ) {
+ s = 1.0 / sqrt( n );
+ } else {
+ s = 1.0 / n;
+ }
+ gscal( 2*M, s, view, 1, 0 );
+ }
+ return out;
+}
+
+
+// EXPORTS //
+
+module.exports = rfftf;
diff --git a/lib/node_modules/@stdlib/fft/rfftf/lib/base.js b/lib/node_modules/@stdlib/fft/rfftf/lib/base.js
new file mode 100644
index 000000000000..3223f737b66e
--- /dev/null
+++ b/lib/node_modules/@stdlib/fft/rfftf/lib/base.js
@@ -0,0 +1,192 @@
+/**
+* @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';
+
+/* eslint-disable vars-on-top */
+
+// MODULES //
+
+var dtypes = require( '@stdlib/ndarray/dtypes' );
+var factory = require( '@stdlib/ndarray/base/nullary-strided1d-dispatch-factory' );
+var isEven = require( '@stdlib/math/base/assert/is-even' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+var getStride = require( '@stdlib/ndarray/base/stride' );
+var getOffset = require( '@stdlib/ndarray/base/offset' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var gcopy = require( '@stdlib/blas/base/gcopy' ).ndarray;
+var reinterpret = require( '@stdlib/strided/base/reinterpret-complex' );
+var reinterpret128 = require( '@stdlib/strided/base/reinterpret-complex128' );
+var reinterpret64 = require( '@stdlib/strided/base/reinterpret-complex64' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Float32Array = require( '@stdlib/array/float32' );
+var drffti = require( '@stdlib/fft/base/fftpack/float64/rffti' );
+var drfftf = require( '@stdlib/fft/base/fftpack/float64/rfftf' );
+var srffti = require( '@stdlib/fft/base/fftpack/float32/rffti' );
+var srfftf = require( '@stdlib/fft/base/fftpack/float32/rfftf' );
+var grffti = require( '@stdlib/fft/base/fftpack/generic/rffti' );
+var grfftf = require( '@stdlib/fft/base/fftpack/generic/rfftf' );
+
+
+// FUNCTIONS //
+
+/**
+* Computes the forward FFT and writes results to the output complex ndarray.
+*
+* @private
+* @param {Function} reinterpret - complex-to-real reinterpret function
+* @param {Function} rffti - workspace initialization function
+* @param {Function} rfftf - forward FFT function
+* @param {Function} Workspace - typed array constructor for workspace
+* @param {ArrayLikeObject