feat: add C implementation for `blas/ext/base/ndarray/ztril` by yb175 · Pull Request #16063 · stdlib-js/stdlib

yb175 · 2026-10-11T13:20:41Z

Related to #14819.

Description

What is the purpose of this pull request?

This pull request:

Adds a native C ndarray implementation for blas/ext/base/ndarray/ztril, using the existing strided C routine.
Adds the Node.js addon and uses the native implementation when available, with the JavaScript implementation as a fallback.
Adds native tests, benchmarks, a C example, and C API documentation.

Related Issues

Does this pull request have any related issues?

This pull request has the following related issues:

[RFC]: add C implementations for blas/ext/base/ndarray packages #14819

Questions

Any questions for reviewers of this pull request?

The native JS wrapper extracts k from the generic scalar ndarray and passes a float64 scalar ndarray to C, so the existing JS example works. For direct C callers, should stdlib_blas_ext_ztril require a 0-D float64 ndarray for k, or support other numeric dtypes? Since the C function returns void, how would you prefer it to handle an unsupported dtype or unreadable scalar?

Other

Any other information relevant to this pull request? This may include screenshots, references, and/or implementation notes.

No.

Checklist

Please ensure the following tasks are completed before submitting this pull request.

Read, understood, and followed the contributing guidelines.

AI Assistance

When authoring the changes proposed in this PR, did you use any kind of AI assistance?

Yes
No

If you answered "yes" above, how did you use AI assistance?

Code generation (e.g., when writing an implementation or fixing a bug)
Test/benchmark generation
Documentation (including examples)
Research and understanding

Disclosure

If you answered "yes" to using AI assistance, please provide a short disclosure indicating how you used AI assistance. This helps reviewers determine how much scrutiny to apply when reviewing your contribution. Example disclosures: "This PR was written primarily by Claude Code." or "I consulted ChatGPT to understand the codebase, but the proposed changes were fully authored manually by myself.".

I used codex for tests generation and documentation writing , all the changes made by ai are reviewed carefully

@stdlib-js/reviewers

stdlib-bot · 2026-10-11T13:32:50Z

Coverage Report

Package	Statements	Branches	Functions	Lines
blas/ext/base/ndarray/ztril	$\\color{green}227/227$ $\\color{green}+0.00\\%$	$\\color{green}7/7$ $\\color{green}+0.00\\%$	$\\color{green}2/2$ $\\color{green}+0.00\\%$	$\\color{green}227/227$ $\\color{green}+0.00\\%$

The above coverage report was generated for the changes in this PR.

AryanSharma48 · 2026-10-13T21:24:01Z

+<section class="notes">
+
+-   Elements outside of the copied region are left unchanged.
+
+</section>


Suggested change

<section class="notes">

- Elements outside of the copied region are left unchanged.

</section>

<section class="notes">

### Notes

- Elements outside of the copied region are left unchanged.

</section>

Whenever <section class="notes"> in the C APIs section contains text, it must include a ### Notes heading right after opening the tag (see e.g. znancount/README.md and zany/README.md).

kgryte · 2026-10-13T21:40:30Z

+		stdlib_blas_ext_ztril( arrays );
+	}
+	elapsed = tic() - t;
+	for ( j = 0; j < len; j++ ) {
+		parts.value = dataB[ j ];
+		if ( isnan( parts.parts[ 0 ] ) || isnan( parts.parts[ 1 ] ) ) {
+			fprintf( stderr, "should not return NaN\n" );
+			break;
+		}
+	}


This is not what is desired. You a) need to retain an assertion check within the hot loop and b) should be using functional accessors, such as complex/float64/real and complex/float64/imag.

yb175 · 2026-10-14T07:50:34Z

Thanks for the feedback. I added the ### Notes heading and moved the NaN check into the benchmark’s hot loop, using the complex/float64/real and complex/float64/imag accessors. Please let me know if anything else is needed!

yb175 · 2026-10-14T11:18:08Z

while reviewing the implementation I made few changes following merged PRs convention

switched k to an int32 ndarray throughout the package. following the discussion in feat: add C implementation blas/ext/base/ndarray/dtril #14471
updated C examples to use stlib_complex128_t buffers
added browser fallback in package.json
Made the C benchmark report a TAP failure if NaN is detected
updated the native Js benchmark check both real and imaginary components

ujjwalv01 · 2026-10-14T13:27:46Z

+*
+* @param iterations   number of iterations
+* @param n            number of matrix rows and columns
+* @param passed       whether the benchmark passed


No longer needed.

Suggested change

* @param passed whether the benchmark passed

ujjwalv01 · 2026-10-14T13:27:50Z

+* @param passed       whether the benchmark passed
+* @return             elapsed time in seconds
+*/
+static double benchmark( int iterations, int n, int *passed ) {


Suggested change

static double benchmark( int iterations, int n, int *passed ) {

static double benchmark( int iterations, int n ) {

ujjwalv01 · 2026-10-14T13:27:53Z

+	shape[ 1 ] = n;
+	strides[ 0 ] = (int64_t)n * STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT;
+	strides[ 1 ] = STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT;
+	kstrides[ 0 ] = STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT;


0-d strides should be 0.

Suggested change

kstrides[ 0 ] = STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT;

kstrides[ 0 ] = 0;

ujjwalv01 · 2026-10-14T13:28:38Z

This should benchmark the JS implementation directly, as in zwxsa.

Suggested change

var ztril = require( './../lib/main.js' );

ujjwalv01 · 2026-10-14T13:28:48Z

This should match benchmark.js apart from the native wiring (resolve, tryRequire, opts, and ::native in the name), as in zwxsa. Right now the requires are reordered, options is inlined, the @param text and main() are changed, and there's an extra imag check.

ujjwalv01 · 2026-10-14T13:29:04Z

 *     -   a two-dimensional input ndarray corresponding to `A`.
 *     -   a two-dimensional output ndarray corresponding to `B`.
-*     -   a zero-dimensional ndarray specifying the diagonal above which to ignore.
+*     -   a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.


Suggested change

* - a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.

* - a zero-dimensional ndarray specifying the diagonal above which to ignore.

ujjwalv01 · 2026-10-14T13:29:15Z

        - a two-dimensional output ndarray corresponding to `B`.
-        - a zero-dimensional ndarray specifying the diagonal above which to
-        ignore.
+        - an int32 scalar ndarray for the diagonal above which to ignore.


Please keep the original wording; only the dtype in the example should change.

Suggested change

- an int32 scalar ndarray for the diagonal above which to ignore.

- a zero-dimensional ndarray specifying the diagonal above which to

ignore.

ujjwalv01 · 2026-10-14T13:29:28Z

+
+	// Specify the array strides (in bytes):
+	int64_t strides[] = { 2 * STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT, STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT };
+	int64_t kstrides[] = { STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT };


0-d strides should be { 0 }.

Suggested change

int64_t kstrides[] = { STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT };

int64_t kstrides[] = { 0 };

ujjwalv01 · 2026-10-14T13:29:50Z

 *     -   a two-dimensional input ndarray corresponding to `A`.
 *     -   a two-dimensional output ndarray corresponding to `B`.
-*     -   a zero-dimensional ndarray specifying the diagonal above which to ignore.
+*     -   a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.


Same as dtril: only generic → int32 should change.

Suggested change

* - a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.

* - a zero-dimensional ndarray specifying the diagonal above which to ignore.

ujjwalv01 · 2026-10-14T13:29:56Z

+*
+*     -   a two-dimensional input ndarray corresponding to `A`.
+*     -   a two-dimensional output ndarray corresponding to `B`.
+*     -   a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.


Suggested change

* - a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.

* - a zero-dimensional ndarray specifying the diagonal above which to ignore.

ujjwalv01 · 2026-10-14T13:30:10Z

+*
+*     -   a two-dimensional input ndarray corresponding to `A`.
+*     -   a two-dimensional output ndarray corresponding to `B`.
+*     -   a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.


Suggested change

* - a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.

* - a zero-dimensional ndarray specifying the diagonal above which to ignore.

ujjwalv01 · 2026-10-14T13:31:06Z

    -   a two-dimensional input ndarray corresponding to `A`.
    -   a two-dimensional output ndarray corresponding to `B`.
-    -   a zero-dimensional ndarray specifying the diagonal above which to ignore. A value equal to zero refers to the main diagonal, greater than zero refers to a diagonal above the main diagonal, and less than zero refers to a diagonal below the main diagonal.
+    -   a zero-dimensional int32 ndarray specifying the diagonal above which to ignore. A value equal to zero refers to the main diagonal, greater than zero refers to a diagonal above the main diagonal, and less than zero refers to a diagonal below the main diagonal.


Suggested change

- a zero-dimensional int32 ndarray specifying the diagonal above which to ignore. A value equal to zero refers to the main diagonal, greater than zero refers to a diagonal above the main diagonal, and less than zero refers to a diagonal below the main diagonal.

- a zero-dimensional ndarray specifying the diagonal above which to ignore. A value equal to zero refers to the main diagonal, greater than zero refers to a diagonal above the main diagonal, and less than zero refers to a diagonal below the main diagonal.

ujjwalv01 · 2026-10-14T13:31:10Z

+int32_t dataK[] = { 0 };
+int64_t shape[] = { 2, 2 };
+int64_t strides[] = { 2 * STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT, STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT };
+int64_t kstrides[] = { STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT };


0-d strides should be { 0 }.

Suggested change

int64_t kstrides[] = { STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT };

int64_t kstrides[] = { 0 };

ujjwalv01 · 2026-10-14T13:31:13Z

+
+    -   `[in] struct ndarray*` a two-dimensional input ndarray corresponding to `A`.
+    -   `[inout] struct ndarray*` a two-dimensional output ndarray corresponding to `B`.
+    -   `[in] struct ndarray*` a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.


Suggested change

- `[in] struct ndarray*` a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.

- `[in] struct ndarray*` a zero-dimensional ndarray specifying the diagonal above which to ignore.

ujjwalv01 · 2026-10-14T13:31:18Z

+
+    // Specify the array strides (in bytes):
+    int64_t strides[] = { 2 * STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT, STDLIB_NDARRAY_COMPLEX128_BYTES_PER_ELEMENT };
+    int64_t kstrides[] = { STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT };


0-d strides should be { 0 }.

Suggested change

int64_t kstrides[] = { STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT };

int64_t kstrides[] = { 0 };

ujjwalv01 · 2026-10-14T13:35:51Z

+	const struct ndarray *A = arrays[ 0 ];
+	const struct ndarray *B = arrays[ 1 ];
+	const struct ndarray *karr = arrays[ 2 ];
+
+	const int64_t *shape = stdlib_ndarray_shape( A );
+	const CBLAS_INT M = (CBLAS_INT)shape[ 0 ];
+	const CBLAS_INT N = (CBLAS_INT)shape[ 1 ];
+
+	const CBLAS_INT strideA1 = (CBLAS_INT)stdlib_ndarray_stride_elements( A, 0 );
+	const CBLAS_INT strideA2 = (CBLAS_INT)stdlib_ndarray_stride_elements( A, 1 );
+	const CBLAS_INT offsetA = (CBLAS_INT)stdlib_ndarray_offset_elements( A );
+	const CBLAS_INT strideB1 = (CBLAS_INT)stdlib_ndarray_stride_elements( B, 0 );
+	const CBLAS_INT strideB2 = (CBLAS_INT)stdlib_ndarray_stride_elements( B, 1 );
+	const CBLAS_INT offsetB = (CBLAS_INT)stdlib_ndarray_offset_elements( B );
+
+	// The typed getter assumes that the output type matches the ndarray dtype:
+	if ( stdlib_ndarray_dtype( karr ) != STDLIB_NDARRAY_INT32 ) {
+		return;
+	}
+	int32_t k_value;
+	if ( stdlib_ndarray_get_int32( karr, NULL, &k_value ) != 0 ) {
+		return;
+	}
+	const CBLAS_INT k = (CBLAS_INT)k_value;


Read k directly, as in zwxsa.

Suggested change

const struct ndarray *A = arrays[ 0 ];

const struct ndarray *B = arrays[ 1 ];

const struct ndarray *karr = arrays[ 2 ];

const int64_t *shape = stdlib_ndarray_shape( A );

const CBLAS_INT M = (CBLAS_INT)shape[ 0 ];

const CBLAS_INT N = (CBLAS_INT)shape[ 1 ];

const CBLAS_INT strideA1 = (CBLAS_INT)stdlib_ndarray_stride_elements( A, 0 );

const CBLAS_INT strideA2 = (CBLAS_INT)stdlib_ndarray_stride_elements( A, 1 );

const CBLAS_INT offsetA = (CBLAS_INT)stdlib_ndarray_offset_elements( A );

const CBLAS_INT strideB1 = (CBLAS_INT)stdlib_ndarray_stride_elements( B, 0 );

const CBLAS_INT strideB2 = (CBLAS_INT)stdlib_ndarray_stride_elements( B, 1 );

const CBLAS_INT offsetB = (CBLAS_INT)stdlib_ndarray_offset_elements( B );

// The typed getter assumes that the output type matches the ndarray dtype:

if ( stdlib_ndarray_dtype( karr ) != STDLIB_NDARRAY_INT32 ) {

return;

}

int32_t k_value;

if ( stdlib_ndarray_get_int32( karr, NULL, &k_value ) != 0 ) {

return;

}

const CBLAS_INT k = (CBLAS_INT)k_value;

const struct ndarray *A = arrays[ 0 ];

const struct ndarray *B = arrays[ 1 ];

int32_t k;

stdlib_ndarray_get_int32( arrays[ 2 ], NULL, &k );

const CBLAS_INT M = stdlib_ndarray_dimension( A, 0 );

const CBLAS_INT N = stdlib_ndarray_dimension( A, 1 );

const CBLAS_INT strideA1 = stdlib_ndarray_stride_elements( A, 0 );

const CBLAS_INT strideA2 = stdlib_ndarray_stride_elements( A, 1 );

const CBLAS_INT offsetA = stdlib_ndarray_offset_elements( A );

const CBLAS_INT strideB1 = stdlib_ndarray_stride_elements( B, 0 );

const CBLAS_INT strideB2 = stdlib_ndarray_stride_elements( B, 1 );

const CBLAS_INT offsetB = stdlib_ndarray_offset_elements( B );

@yb175 This is only partly applied. k_value, the (CBLAS_INT) casts on the strides, and const CBLAS_INT k = (CBLAS_INT)k_value; are still there. Please apply the suggestion as is.

ujjwalv01 · 2026-10-14T13:36:53Z

+	*passed = 1;
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		stdlib_blas_ext_ztril( arrays );
+		if (
+			stdlib_complex128_real( dataB[ 0 ] ) != stdlib_complex128_real( dataB[ 0 ] ) ||
+			stdlib_complex128_imag( dataB[ 0 ] ) != stdlib_complex128_imag( dataB[ 0 ] )
+		) {
+			fprintf( stderr, "should not return NaN\n" );
+			*passed = 0;
+			break;
+		}
+	}
+	elapsed = tic() - t;


Follow the standard layout, as in dtril.

Suggested change

*passed = 1;

t = tic();

for ( i = 0; i < iterations; i++ ) {

stdlib_blas_ext_ztril( arrays );

if (

stdlib_complex128_real( dataB[ 0 ] ) != stdlib_complex128_real( dataB[ 0 ] ) ||

stdlib_complex128_imag( dataB[ 0 ] ) != stdlib_complex128_imag( dataB[ 0 ] )

) {

fprintf( stderr, "should not return NaN\n" );

*passed = 0;

break;

}

}

elapsed = tic() - t;

t = tic();

for ( i = 0; i < iterations; i++ ) {

stdlib_blas_ext_ztril( arrays );

if ( stdlib_complex128_real( dataB[ 0 ] ) != stdlib_complex128_real( dataB[ 0 ] ) || stdlib_complex128_imag( dataB[ 0 ] ) != stdlib_complex128_imag( dataB[ 0 ] ) ) {

printf( "should not return NaN\n" );

break;

}

}

elapsed = tic() - t;

if ( stdlib_complex128_real( dataB[ 0 ] ) != stdlib_complex128_real( dataB[ 0 ] ) || stdlib_complex128_imag( dataB[ 0 ] ) != stdlib_complex128_imag( dataB[ 0 ] ) ) {

printf( "should not return NaN\n" );

}

ujjwalv01 · 2026-10-14T13:37:57Z

+	double elapsed;
+	int count;
+	int passing;
+	int passed;
+	int iter;
+	int n;
+	int i;
+	int j;
+
+	srand( (unsigned int)time( NULL ) );
+	print_version();
+	count = 0;
+	passing = 0;
+	for ( i = MIN; i <= MAX; i++ ) {
+		n = (int)pow( 10.0, (double)i );
+		iter = ITERATIONS / (int)pow( 10.0, (double)(2*(i-1)) );
+		for ( j = 0; j < REPEATS; j++ ) {
+			count += 1;
+			printf( "# c::%s:size=%d\n", NAME, n*n );
+			elapsed = benchmark( iter, n, &passed );
+			if ( passed ) {
+				print_results( iter, elapsed );
+				passing += 1;
+				printf( "ok %d benchmark finished\n", count );
+			} else {
+				printf( "not ok %d benchmark detected NaN\n", count );
+			}
+		}
+	}
+	print_summary( count, passing );
+	return ( passing == count ) ? 0 : 1;


Same here: standard main() layout.

Suggested change

double elapsed;

int count;

int passing;

int passed;

int iter;

int n;

int i;

int j;

srand( (unsigned int)time( NULL ) );

print_version();

count = 0;

passing = 0;

for ( i = MIN; i <= MAX; i++ ) {

n = (int)pow( 10.0, (double)i );

iter = ITERATIONS / (int)pow( 10.0, (double)(2*(i-1)) );

for ( j = 0; j < REPEATS; j++ ) {

count += 1;

printf( "# c::%s:size=%d\n", NAME, n*n );

elapsed = benchmark( iter, n, &passed );

if ( passed ) {

print_results( iter, elapsed );

passing += 1;

printf( "ok %d benchmark finished\n", count );

} else {

printf( "not ok %d benchmark detected NaN\n", count );

}

}

}

print_summary( count, passing );

return ( passing == count ) ? 0 : 1;

double elapsed;

int count;

int iter;

int n;

int i;

int j;

// Use the current time to seed the random number generator:

srand( time( NULL ) );

print_version();

count = 0;

for ( i = MIN; i <= MAX; i++ ) {

n = pow( 10, i );

iter = ITERATIONS / pow( 10, 2*(i-1) );

for ( j = 0; j < REPEATS; j++ ) {

count += 1;

printf( "# c::%s:size=%d\n", NAME, n*n );

elapsed = benchmark( iter, n );

print_results( iter, elapsed );

printf( "ok %d benchmark finished\n", count );

}

}

print_summary( count, count );

ujjwalv01 · 2026-10-14T13:39:56Z

@yb175 , Left a few suggestions, PTAL;

kgryte · 2026-10-14T13:43:52Z

@yb175 In general, you need to pay much closer attention to how other packages are structured. Only the minimal essential changes should be present among separate similar packages.

yb175 · 2026-10-14T13:56:03Z

@yb175 In general, you need to pay much closer attention to how other packages are structured. Only the minimal essential changes should be present among separate similar packages.

Thanks @kgryte for the feedback , from next time I would carefully observe the merged PRs from the similar packages before opening future PRs 😊

ujjwalv01 · 2026-10-14T14:09:19Z

+	printf( "# total %d\n", total );
+	printf( "# pass  %d\n", passing );
+	printf( "#\n" );
+	printf( "# %s\n", passing == total ? "ok" : "not ok" );


Suggested change

printf( "# %s\n", passing == total ? "ok" : "not ok" );

printf( "# ok\n" );

ujjwalv01 · 2026-10-14T14:09:20Z

+}
+
+/**
+* Prints benchmark results.


Suggested change

* Prints benchmark results.

* Prints benchmarks results.

@yb175 This one was missed.

ujjwalv01 · 2026-10-14T14:09:23Z

+* Returns the current time.
+*
+* @return current time in seconds


Suggested change

* Returns the current time.

*

* @return current time in seconds

* Returns a clock time.

*

* @return clock time

ujjwalv01 · 2026-10-14T14:16:45Z

 * // returns true
 */
-declare function ztril( arrays: [ complex128ndarray, complex128ndarray, typedndarray<number> ] ): complex128ndarray;
+declare function ztril( arrays: [ complex128ndarray, complex128ndarray, int32ndarray ] ): complex128ndarray;


@kgryte Is it okay for k to be int32ndarray here as well ?

yb175 · 2026-10-14T18:16:59Z

addressed all other review suggestions . leaving the int32ndarray type question open until I get @kgryte guidance , Then I will follow up with that change .

ujjwalv01 · 2026-10-15T02:08:00Z

+var bench = require( '@stdlib/bench' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
+var Complex128Matrix = require( '@stdlib/ndarray/matrix/complex128' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var real = require( '@stdlib/complex/float64/real' );
+var tryRequire = require( '@stdlib/utils/try-require' );


Keep the same order as benchmark.js.

Suggested change

var bench = require( '@stdlib/bench' );

var pow = require( '@stdlib/math/base/special/pow' );

var format = require( '@stdlib/string/format' );

var Complex128Matrix = require( '@stdlib/ndarray/matrix/complex128' );

var uniform = require( '@stdlib/random/array/uniform' );

var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );

var isnan = require( '@stdlib/math/base/assert/is-nan' );

var real = require( '@stdlib/complex/float64/real' );

var tryRequire = require( '@stdlib/utils/try-require' );

var bench = require( '@stdlib/bench' );

var uniform = require( '@stdlib/random/array/uniform' );

var Complex128Matrix = require( '@stdlib/ndarray/matrix/complex128' );

var isnan = require( '@stdlib/math/base/assert/is-nan' );

var real = require( '@stdlib/complex/float64/real' );

var pow = require( '@stdlib/math/base/special/pow' );

var format = require( '@stdlib/string/format' );

var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );

var tryRequire = require( '@stdlib/utils/try-require' );

ujjwalv01 · 2026-10-15T02:08:16Z

+var ztril = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var opts = {
+	'skip': ( ztril instanceof Error )
+};


Suggested change

var ztril = tryRequire( resolve( __dirname, './../lib/native.js' ) );

var opts = {

'skip': ( ztril instanceof Error )

};

var ztril = tryRequire( resolve( __dirname, './../lib/native.js' ) );

var opts = {

'skip': ( ztril instanceof Error )

};

var options = {

'dtype': 'float64'

};

ujjwalv01 · 2026-10-15T02:08:21Z

+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} N - number of rows and columns


Suggested change

* @param {PositiveInteger} N - number of rows and columns

* @param {PositiveInteger} N - number of elements along each dimension

ujjwalv01 · 2026-10-15T02:09:06Z

+	abuf = uniform( N*N*2, -100.0, 100.0, {
+		'dtype': 'float64'
+	});
+	bbuf = uniform( N*N*2, -100.0, 100.0, {
+		'dtype': 'float64'
+	});
+	A = new Complex128Matrix( abuf.buffer, 0, N, N );
+	B = new Complex128Matrix( bbuf.buffer, 0, N, N );


Suggested change

abuf = uniform( N*N*2, -100.0, 100.0, {

'dtype': 'float64'

});

bbuf = uniform( N*N*2, -100.0, 100.0, {

'dtype': 'float64'

});

A = new Complex128Matrix( abuf.buffer, 0, N, N );

B = new Complex128Matrix( bbuf.buffer, 0, N, N );

abuf = uniform( N*N*2, -100.0, 100.0, options );

bbuf = uniform( N*N*2, -100.0, 100.0, options );

A = new Complex128Matrix( abuf.buffer, 0, N, N );

B = new Complex128Matrix( bbuf.buffer, 0, N, N );

feat: add C implementation for blas/ext/base/ndarray/ztril

9db7165

yb175 requested a review from a team October 11, 2026 13:20

Merge branch 'develop' into feat/ndarray-ztril-c

d3177f2

stdlib-bot added BLAS Issue or pull request related to Basic Linear Algebra Subprograms (BLAS). Needs Review A pull request which needs code review. labels Oct 11, 2026

yb175 added 2 commits October 11, 2026 13:41

fix: address ztril CI lint failures

24c00e2

fix : add TAP plan comment

bf66638

AryanSharma48 reviewed Oct 13, 2026

View reviewed changes

kgryte reviewed Oct 13, 2026

View reviewed changes

kgryte added Needs Changes Pull request which needs changes before being merged. and removed Needs Review A pull request which needs code review. labels Oct 13, 2026

This comment was marked as outdated.

Sign in to view

fix: address review feedback

6159e8c

fix: align ztril native implementation with conventions

32f1bc6

yb175 added 2 commits October 14, 2026 11:21

fix : fixed the ci failure

d4fbd6f

fix: wrap ztril REPL help text to satisfy lint

1dc85ec

ujjwalv01 reviewed Oct 14, 2026

View reviewed changes

fix : adressed the changes requested

5347939

ujjwalv01 reviewed Oct 15, 2026

View reviewed changes

	static double benchmark( int iterations, int n, int *passed ) {
	static double benchmark( int iterations, int n ) {

	kstrides[ 0 ] = STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT;
	kstrides[ 0 ] = 0;

	* - a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.
	* - a zero-dimensional ndarray specifying the diagonal above which to ignore.

	- an int32 scalar ndarray for the diagonal above which to ignore.
	- a zero-dimensional ndarray specifying the diagonal above which to
	ignore.

	int64_t kstrides[] = { STDLIB_NDARRAY_INT32_BYTES_PER_ELEMENT };
	int64_t kstrides[] = { 0 };

	- a zero-dimensional int32 ndarray specifying the diagonal above which to ignore. A value equal to zero refers to the main diagonal, greater than zero refers to a diagonal above the main diagonal, and less than zero refers to a diagonal below the main diagonal.
	- a zero-dimensional ndarray specifying the diagonal above which to ignore. A value equal to zero refers to the main diagonal, greater than zero refers to a diagonal above the main diagonal, and less than zero refers to a diagonal below the main diagonal.

	- `[in] struct ndarray*` a zero-dimensional int32 ndarray specifying the diagonal above which to ignore.
	- `[in] struct ndarray*` a zero-dimensional ndarray specifying the diagonal above which to ignore.

	printf( "# %s\n", passing == total ? "ok" : "not ok" );
	printf( "# ok\n" );

	* @param {PositiveInteger} N - number of rows and columns
	* @param {PositiveInteger} N - number of elements along each dimension

Conversation

yb175 commented Oct 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Description

Related Issues

Questions

Other

Checklist

AI Assistance

Disclosure

Uh oh!

stdlib-bot commented Oct 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Coverage Report

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

This comment was marked as outdated.

Uh oh!

yb175 commented Oct 14, 2026

Uh oh!

yb175 commented Oct 14, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ujjwalv01 commented Oct 14, 2026

Uh oh!

kgryte commented Oct 14, 2026

Uh oh!

yb175 commented Oct 14, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ujjwalv01 Oct 14, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

yb175 commented Oct 11, 2026 •

edited

Loading

stdlib-bot commented Oct 11, 2026 •

edited

Loading

ujjwalv01 Oct 14, 2026 •

edited

Loading