{"id":26555158,"url":"https://github.com/stdlib-js/ndarray-base-every","last_synced_at":"2026-05-07T04:31:41.000Z","repository":{"id":283412103,"uuid":"951631875","full_name":"stdlib-js/ndarray-base-every","owner":"stdlib-js","description":"Test whether every element in an ndarray is truthy.","archived":false,"fork":false,"pushed_at":"2025-06-22T08:15:58.000Z","size":1241,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":2,"default_branch":"main","last_synced_at":"2025-06-22T09:24:46.451Z","etag":null,"topics":["all","array","base","every","javascript","ndarray","node","node-js","nodejs","stdlib","strided","truthy","utility","utils"],"latest_commit_sha":null,"homepage":"https://github.com/stdlib-js/stdlib","language":"C","has_issues":false,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/stdlib-js.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":"CITATION.cff","codeowners":null,"security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null},"funding":{"github":["stdlib-js"],"open_collective":"stdlib","tidelift":"npm/@stdlib/stdlib"}},"created_at":"2025-03-20T01:51:54.000Z","updated_at":"2025-06-22T08:13:56.000Z","dependencies_parsed_at":"2025-04-13T01:39:21.618Z","dependency_job_id":"34494a66-81d2-42ff-aa52-46ffec97b1a8","html_url":"https://github.com/stdlib-js/ndarray-base-every","commit_stats":null,"previous_names":["stdlib-js/ndarray-base-every"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/stdlib-js/ndarray-base-every","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/stdlib-js%2Fndarray-base-every","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/stdlib-js%2Fndarray-base-every/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/stdlib-js%2Fndarray-base-every/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/stdlib-js%2Fndarray-base-every/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/stdlib-js","download_url":"https://codeload.github.com/stdlib-js/ndarray-base-every/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/stdlib-js%2Fndarray-base-every/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":273287604,"owners_count":25078570,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-09-02T02:00:09.530Z","response_time":77,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["all","array","base","every","javascript","ndarray","node","node-js","nodejs","stdlib","strided","truthy","utility","utils"],"created_at":"2025-03-22T10:25:07.616Z","updated_at":"2026-05-07T04:31:40.985Z","avatar_url":"https://github.com/stdlib-js.png","language":"C","funding_links":["https://github.com/sponsors/stdlib-js","https://opencollective.com/stdlib","https://tidelift.com/funding/github/npm/@stdlib/stdlib"],"categories":[],"sub_categories":[],"readme":"\u003c!--\n\n@license Apache-2.0\n\nCopyright (c) 2025 The Stdlib Authors.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n   http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\n--\u003e\n\n\n\u003cdetails\u003e\n  \u003csummary\u003e\n    About stdlib...\n  \u003c/summary\u003e\n  \u003cp\u003eWe believe in a future in which the web is a preferred environment for numerical computation. To help realize this future, we've built stdlib. stdlib is a standard library, with an emphasis on numerical and scientific computation, written in JavaScript (and C) for execution in browsers and in Node.js.\u003c/p\u003e\n  \u003cp\u003eThe library is fully decomposable, being architected in such a way that you can swap out and mix and match APIs and functionality to cater to your exact preferences and use cases.\u003c/p\u003e\n  \u003cp\u003eWhen you use stdlib, you can be absolutely certain that you are using the most thorough, rigorous, well-written, studied, documented, tested, measured, and high-quality code out there.\u003c/p\u003e\n  \u003cp\u003eTo join us in bringing numerical computing to the web, get started by checking us out on \u003ca href=\"https://github.com/stdlib-js/stdlib\"\u003eGitHub\u003c/a\u003e, and please consider \u003ca href=\"https://opencollective.com/stdlib\"\u003efinancially supporting stdlib\u003c/a\u003e. We greatly appreciate your continued support!\u003c/p\u003e\n\u003c/details\u003e\n\n# every\n\n[![NPM version][npm-image]][npm-url] [![Build Status][test-image]][test-url] [![Coverage Status][coverage-image]][coverage-url] \u003c!-- [![dependencies][dependencies-image]][dependencies-url] --\u003e\n\n\u003e Test whether every element in an ndarray is truthy.\n\n\u003csection class=\"intro\"\u003e\n\n\u003c/section\u003e\n\n\u003c!-- /.intro --\u003e\n\n\u003csection class=\"installation\"\u003e\n\n## Installation\n\n```bash\nnpm install @stdlib/ndarray-base-every\n```\n\nAlternatively,\n\n-   To load the package in a website via a `script` tag without installation and bundlers, use the [ES Module][es-module] available on the [`esm`][esm-url] branch (see [README][esm-readme]).\n-   If you are using Deno, visit the [`deno`][deno-url] branch (see [README][deno-readme] for usage intructions).\n-   For use in Observable, or in browser/node environments, use the [Universal Module Definition (UMD)][umd] build available on the [`umd`][umd-url] branch (see [README][umd-readme]).\n\nThe [branches.md][branches-url] file summarizes the available branches and displays a diagram illustrating their relationships.\n\nTo view installation and usage instructions specific to each branch build, be sure to explicitly navigate to the respective README files on each branch, as linked to above.\n\n\u003c/section\u003e\n\n\u003csection class=\"usage\"\u003e\n\n## Usage\n\n```javascript\nvar every = require( '@stdlib/ndarray-base-every' );\n```\n\n#### every( arrays )\n\nTests whether every element in an ndarray is truthy.\n\n\u003c!-- eslint-disable max-len --\u003e\n\n```javascript\nvar Float64Array = require( '@stdlib/array-float64' );\n\n// Create a data buffer:\nvar xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n\n// Define the shape of the input array:\nvar shape = [ 3, 1, 2 ];\n\n// Define the array strides:\nvar sx = [ 4, 4, 1 ];\n\n// Define the index offset:\nvar ox = 0;\n\n// Create the input ndarray-like object:\nvar x = {\n    'dtype': 'float64',\n    'data': xbuf,\n    'shape': shape,\n    'strides': sx,\n    'offset': ox,\n    'order': 'row-major'\n};\n\n// Test elements:\nvar out = every( [ x ] );\n// returns true\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: array-like object containing an input ndarray.\n\nThe provided ndarray should be an object with the following properties:\n\n-   **dtype**: data type.\n-   **data**: data buffer.\n-   **shape**: dimensions.\n-   **strides**: stride lengths.\n-   **offset**: index offset.\n-   **order**: specifies whether an ndarray is row-major (C-style) or column major (Fortran-style).\n\n\u003c/section\u003e\n\n\u003c!-- /.usage --\u003e\n\n\u003csection class=\"notes\"\u003e\n\n## Notes\n\n-   For very high-dimensional ndarrays which are non-contiguous, one should consider copying the underlying data to contiguous memory before performing the operation in order to achieve better performance.\n\n\u003c/section\u003e\n\n\u003c!-- /.notes --\u003e\n\n\u003csection class=\"examples\"\u003e\n\n## Examples\n\n\u003c!-- eslint no-undef: \"error\" --\u003e\n\n```javascript\nvar bernoulli = require( '@stdlib/random-array-bernoulli' );\nvar ndarray2array = require( '@stdlib/ndarray-base-to-array' );\nvar every = require( '@stdlib/ndarray-base-every' );\n\nvar x = {\n    'dtype': 'generic',\n    'data': bernoulli( 10, 0.9, {\n        'dtype': 'generic'\n    }),\n    'shape': [ 5, 2 ],\n    'strides': [ 2, 1 ],\n    'offset': 0,\n    'order': 'row-major'\n};\nconsole.log( ndarray2array( x.data, x.shape, x.strides, x.offset, x.order ) );\n\nvar out = every( [ x ] );\nconsole.log( out );\n```\n\n\u003c/section\u003e\n\n\u003c!-- /.examples --\u003e\n\n\u003c!-- C interface documentation. --\u003e\n\n* * *\n\n\u003csection class=\"c\"\u003e\n\n## C APIs\n\n\u003c!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. --\u003e\n\n\u003csection class=\"intro\"\u003e\n\nCharacter codes for data types:\n\n\u003c!-- The following is auto-generated. Do not manually edit. See scripts/loops.js. --\u003e\n\n\u003c!-- charcodes --\u003e\n\n-   **x**: `bool` (boolean).\n-   **z**: `complex128` (double-precision floating-point complex number).\n-   **c**: `complex64` (single-precision floating-point complex number).\n-   **f**: `float32` (single-precision floating-point number).\n-   **d**: `float64` (double-precision floating-point number).\n-   **k**: `int16` (signed 16-bit integer).\n-   **i**: `int32` (signed 32-bit integer).\n-   **s**: `int8` (signed 8-bit integer).\n-   **t**: `uint16` (unsigned 16-bit integer).\n-   **u**: `uint32` (unsigned 32-bit integer).\n-   **b**: `uint8` (unsigned 8-bit integer).\n\n\u003c!-- ./charcodes --\u003e\n\nFunction name suffix naming convention:\n\n```text\nstdlib_ndarray_every_\u003cinput_data_type\u003e_\u003coutput_data_type\u003e\n```\n\nFor example,\n\n\u003c!-- run-disable --\u003e\n\n```c\nvoid stdlib_ndarray_every_d_x(...) {...}\n```\n\nis a function which accepts one double-precision floating-point input ndarray and one boolean output ndarray.\n\nFunction name suffix naming convention for applying a predicate function:\n\n```text\nstdlib_ndarray_every_by_\u003cinput_data_type\u003e_\u003coutput_data_type\u003e[_as_\u003ccallback_arg_data_type\u003e_\u003ccallback_return_data_type\u003e]\n```\n\nFor example,\n\n\u003c!-- run-disable --\u003e\n\n```c\nvoid stdlib_ndarray_every_by_d_x(...) {...}\n```\n\nis a function which accepts one double-precision floating-point input ndarray and one boolean output ndarray. In other words, the suffix encodes the function type signature.\n\nTo support callbacks whose input arguments are of a different data type than the input ndarray data type, the naming convention supports appending an `as` suffix. For example,\n\n\u003c!-- run-disable --\u003e\n\n```c\nvoid stdlib_ndarray_every_by_f_x_as_d_x(...) {...}\n```\n\nis a function which accepts one single-precision floating-point input ndarray and one boolean output ndarray. However, the callback accepts double-precision floating-point numbers. Accordingly, the input values need to be cast using the following conversion sequence\n\n```c\n#include \u003cstdbool.h\u003e\n\n// Convert each input array element to double-precision:\ndouble in1 = (double)x[ i ];\n\n// Evaluate the callback:\nbool out = f( in1 );\n```\n\n\u003c/section\u003e\n\n\u003c!-- /.intro --\u003e\n\n\u003c!-- C usage documentation. --\u003e\n\n\u003csection class=\"usage\"\u003e\n\n### Usage\n\n```c\n#include \"stdlib/ndarray/base/every.h\"\n```\n\n\u003c!-- The following is auto-generated. Do not manually edit. See scripts/*loops.js. --\u003e\n\n\u003c!-- inline-loops --\u003e\n\n#### stdlib_ndarray_every_b_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_b_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_b_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_c_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float32/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_COMPLEX64;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 16, 8 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_c_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_c_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_d_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT64;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 16, 8 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_d_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_d_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_f_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_f_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_f_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_i_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_i_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_i_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_k_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_k_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_k_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_s_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_s_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_s_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_t_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_t_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_t_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_u_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_u_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_u_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_x_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_BOOL;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_x_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_x_x( struct ndarray *arrays[], void *data );\n```\n\n#### stdlib_ndarray_every_z_x( \\*arrays\\[], \\*data )\n\nTests whether every element in an input ndarray is truthy.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float64/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_COMPLEX128;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 32, 16 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_z_x( arrays, NULL );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to a zero-dimensional output ndarray.\n-   **data**: `[in] void*` function data. This argument is unused and should be a `NULL` pointer.\n\n```c\nint8_t stdlib_ndarray_every_z_x( struct ndarray *arrays[], void *data );\n```\n\n\u003c!-- ./inline-loops --\u003e\n\n\u003c!-- predicate-loops --\u003e\n\n#### stdlib_ndarray_every_by_b_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const uint8_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(uint8_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_c_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float32/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex64_t x ) {\n    return ( stdlib_complex64_real( x ) == 0.0f \u0026\u0026 stdlib_complex64_imag( x ) == 0.0f );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_c_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex64_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_c_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_d_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const double x ) {\n    return x == 0.0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_d_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(double)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_d_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_f_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const float x ) {\n    return x == 0.0f;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_f_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(float)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_f_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_i_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const int32_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_i_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(int32_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_i_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_k_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const int16_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_k_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(int16_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_k_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_t_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const uint16_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_t_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(uint16_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_t_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_u_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const uint32_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_u_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(uint32_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_u_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_b_x_as_z_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float64/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_UINT8;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 2, 1 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex128_t x ) {\n    return ( stdlib_complex128_real( x ) == 0.0 \u0026\u0026 stdlib_complex128_imag( x ) == 0.0 );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_b_x_as_z_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex128_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_b_x_as_z_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_c_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float32/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_COMPLEX64;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 16, 8 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex64_t x ) {\n    return ( stdlib_complex64_real( x ) == 0.0f \u0026\u0026 stdlib_complex64_imag( x ) == 0.0f );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_c_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex64_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_c_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_c_x_as_z_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float64/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_COMPLEX64;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 16, 8 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex128_t x ) {\n    return ( stdlib_complex128_real( x ) == 0.0 \u0026\u0026 stdlib_complex128_imag( x ) == 0.0 );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_c_x_as_z_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex128_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_c_x_as_z_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_d_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT64;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 16, 8 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const double x ) {\n    return x == 0.0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_d_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(double)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_d_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_d_x_as_z_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float64/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT64;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 16, 8 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex128_t x ) {\n    return ( stdlib_complex128_real( x ) == 0.0 \u0026\u0026 stdlib_complex128_imag( x ) == 0.0 );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_d_x_as_z_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex128_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_d_x_as_z_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_f_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const float x ) {\n    return x == 0.0f;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_f_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(float)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_f_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_f_x_as_c_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float32/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex64_t x ) {\n    return ( stdlib_complex64_real( x ) == 0.0f \u0026\u0026 stdlib_complex64_imag( x ) == 0.0f );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_f_x_as_c_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex64_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_f_x_as_c_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_f_x_as_d_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const double x ) {\n    return x == 0.0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_f_x_as_d_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(double)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_f_x_as_d_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_f_x_as_z_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float64/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_FLOAT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex128_t x ) {\n    return ( stdlib_complex128_real( x ) == 0.0 \u0026\u0026 stdlib_complex128_imag( x ) == 0.0 );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_f_x_as_z_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex128_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_f_x_as_z_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_i_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const int32_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_i_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(int32_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_i_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_i_x_as_d_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const double x ) {\n    return x == 0.0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_i_x_as_d_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(double)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_i_x_as_d_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_i_x_as_z_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float64/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT32;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 8, 4 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex128_t x ) {\n    return ( stdlib_complex128_real( x ) == 0.0 \u0026\u0026 stdlib_complex128_imag( x ) == 0.0 );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_i_x_as_z_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex128_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_i_x_as_z_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_k_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const int16_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_k_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(int16_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_k_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_k_x_as_c_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float32/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const stdlib_complex64_t x ) {\n    return ( stdlib_complex64_real( x ) == 0.0f \u0026\u0026 stdlib_complex64_imag( x ) == 0.0f );\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_k_x_as_c_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(stdlib_complex64_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_k_x_as_c_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_k_x_as_d_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const double x ) {\n    return x == 0.0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_k_x_as_d_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(double)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_k_x_as_d_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_k_x_as_f_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const float x ) {\n    return x == 0.0f;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_k_x_as_f_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(float)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_k_x_as_f_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_k_x_as_i_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define the index offsets:\nint64_t ox = 0;\nint64_t oy = 0;\n\n// Define the array order:\nenum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;\n\n// Specify the index mode:\nenum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;\n\n// Specify the subscript index modes:\nint8_t submodes[] = { imode };\nint64_t nsubmodes = 1;\n\n// Create an input ndarray:\nstruct ndarray *x = stdlib_ndarray_allocate( xdtype, xbuf, ndims, shx, sx, ox, order, imode, nsubmodes, submodes );\nif ( x == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an output ndarray:\nstruct ndarray *y = stdlib_ndarray_allocate( ydtype, ybuf, 0, shy, sy, oy, order, imode, nsubmodes, submodes );\nif ( y == NULL ) {\n    fprintf( stderr, \"Error allocating memory.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// Create an array containing the ndarrays:\nstruct ndarray *arrays[] = { x, y };\n\n// Define a callback:\nstatic bool fcn( const int32_t x ) {\n    return x == 0;\n}\n\n// Test elements:\nint8_t status = stdlib_ndarray_every_by_k_x_as_i_x( arrays, (void *)fcn );\nif ( status != 0 ) {\n    fprintf( stderr, \"Error during computation.\\n\" );\n    exit( EXIT_FAILURE );\n}\n\n// ...\n\n// Free allocated memory:\nstdlib_ndarray_free( x );\nstdlib_ndarray_free( y );\n```\n\nThe function accepts the following arguments:\n\n-   **arrays**: `[inout] struct ndarray**` array whose first element is a pointer to an input ndarray and whose second element is a pointer to an output ndarray.\n-   **fcn**: `[in] void*` a `bool (*f)(int32_t)` predicate function to apply provided as a `void` pointer.\n\n```c\nint8_t stdlib_ndarray_every_by_k_x_as_i_x( struct ndarray *arrays[], void *fcn );\n```\n\n#### stdlib_ndarray_every_by_k_x_as_z_x( \\*arrays\\[], \\*fcn )\n\nTests whether every element in an input ndarray is truthy according to a predicate function.\n\n```c\n#include \"stdlib/ndarray/dtypes.h\"\n#include \"stdlib/ndarray/index_modes.h\"\n#include \"stdlib/ndarray/orders.h\"\n#include \"stdlib/ndarray/ctor.h\"\n#include \"stdlib/complex/float64/ctor.h\"\n#include \u003cstdint.h\u003e\n#include \u003cstdlib.h\u003e\n#include \u003cstdio.h\u003e\n#include \u003cstdbool.h\u003e\n\n// Define the ndarray data types:\nenum STDLIB_NDARRAY_DTYPE xdtype = STDLIB_NDARRAY_INT16;\nenum STDLIB_NDARRAY_DTYPE ydtype = STDLIB_NDARRAY_BOOL;\n\n// Create underlying byte arrays:\nuint8_t xbuf[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\nuint8_t ybuf[] = { 0 };\n\n// Define the number of dimensions:\nint64_t ndims = 2;\n\n// Define the array shapes:\nint64_t shx[] = { 2, 2 };\nint64_t *shy = NULL;\n\n// Define the strides:\nint64_t sx[] = { 4, 2 };\nint64_t sy[] = { 0 };\n\n// Define t","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fstdlib-js%2Fndarray-base-every","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fstdlib-js%2Fndarray-base-every","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fstdlib-js%2Fndarray-base-every/lists"}