About stdlib...

We 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.

The 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.

When 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.

To join us in bringing numerical computing to the web, get started by checking us out on GitHub, and please consider financially supporting stdlib. We greatly appreciate your continued support!

Function Object

C APIs for creating and managing ndarray function objects.

Installation

npm install @stdlib/ndarray-base-function-object

Alternatively,

• To load the package in a website via a script tag without installation and bundlers, use the ES Module available on the esm branch (see README).
• If you are using Deno, visit the deno branch (see README for usage intructions).
• For use in Observable, or in browser/node environments, use the Universal Module Definition (UMD) build available on the umd branch (see README).

The branches.md file summarizes the available branches and displays a diagram illustrating their relationships.

To 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.

Usage

var headerDir = require( '@stdlib/ndarray-base-function-object' );

headerDir

Absolute file path for the directory containing header files for C APIs.

var dir = headerDir;
// returns <string>

Examples

var headerDir = require( '@stdlib/ndarray-base-function-object' );

console.log( headerDir );

---

C APIs

Usage

#include "stdlib/ndarray/base/function_object.h"

ndarrayFunctionObject

Structure for grouping ndarray function information.

struct ndarrayFunctionObject {
    // ndarray function name:
    const char *name;

    // Number of input ndarrays:
    int32_t nin;

    // Number of output ndarrays:
    int32_t nout;

    // Total number of ndarray arguments (nin + nout):
    int32_t narrays;

    // Array containing ndarray functions:
    ndarrayFcn *functions;

    // Number of ndarray functions:
    int32_t nfunctions;

    // Array of type "numbers" (as enumerated elsewhere), where the total number of types equals `narrays * nfunctions` and where each set of `narrays` consecutive types (non-overlapping) corresponds to the set of ndarray argument types for a corresponding ndarray function:
    int32_t *types;

    // Array of void pointers corresponding to the "data" (e.g., callbacks) which should be passed to a respective ndarray function (note: the number of pointers should match the number of ndarray functions):
    void **data;
};

ndarrayFcn

Function pointer type for an ndarray function.

typedef int8_t (*ndarrayFcn)( struct ndarray *arrays[], void *data );

An ndarrayFcn function should accept the following arguments:

• arrays: [in] struct ndarray** array containing pointers to input and output ndarrays.
• data: [in] void* function data (e.g., a callback).

An ndarrayFcn function should return a status code (with 0 indicating success).

stdlib_ndarray_function_allocate( _name, nin, nout, _functions, nfunctions, _types, _data[] )

Returns a pointer to a dynamically allocated ndarray function object.

#include "stdlib/ndarray/base/unary.h"
#include "stdlib/ndarray/dtypes.h"
#include <stdlib.h>
#include <stdio.h>

// Define the function(s) we want to apply to ndarrays:
double scale( const double x ) {
    return x * 10.0;
}

// Define a function name:
const char name[] = "unary_ndarray_function";

// Define a list of ndarray functions (in this case, as the function to be applied accepts doubles, we only use ndarray functions which handle doubles as function arguments and, for the purposes of this example, we assume that the output ndarray is always a double-precision floating-point number array):
ndarrayFcn functions[] = {
    stdlib_ndarray_d_d,
    stdlib_ndarray_f_f_as_d_d,
    stdlib_ndarray_u_d_as_d_d,
    stdlib_ndarray_i_d_as_d_d,
    stdlib_ndarray_t_d_as_d_d,
    stdlib_ndarray_k_d_as_d_d,
    stdlib_ndarray_b_d_as_d_d,
    stdlib_ndarray_s_d_as_d_d
};

// Define the **ndarray** argument types for each ndarray function:
int32_t types[] = {
    STDLIB_NDARRAY_FLOAT64, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_FLOAT32, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_UINT32, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_INT32, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_UINT16, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_INT16, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_UINT8, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_INT8, STDLIB_NDARRAY_FLOAT64
};

// Define a list of ndarray function "data" (in this case, callbacks):
void *data[] = {
    (void *)scale,
    (void *)scale,
    (void *)scale,
    (void *)scale,
    (void *)scale,
    (void *)scale,
    (void *)scale,
    (void *)scale
};

// Create a new ndarray function object:
struct ndarrayFunctionObject *obj = stdlib_ndarray_function_allocate( name, 1, 1, functions, 8, types, data );
if ( obj == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// Free allocated memory:
stdlib_ndarray_function_free( obj );

The function accepts the following arguments:

• name: [in] char* ndarray function name.
• nin: [in] int32_t number of input ndarrays.
• nout: [in] int32_t number of output ndarrays.
• functions: [in] ndarrayFcn* array containing ndarray functions.
• nfunctions: [in] int32_t number of ndarray functions.
• types: [in] int32_t* array of type "numbers", where the total number of types equals (nin+nout)*nfunctions and where each set of nin+nout consecutive types (non-overlapping) corresponds to the set of ndarray argument types for a corresponding ndarray function.
• data: [in] void* array of void pointers corresponding to the "data" (e.g., callbacks) which should be passed to a respective ndarray function.

struct ndarrayFunctionObject * stdlib_ndarray_function_allocate( const char *name, int32_t nin, int32_t nout, ndarrayFcn *functions, int32_t nfunctions, int32_t *types, void *data[] )

The function returns a pointer to a dynamically allocated ndarray function or, if unable to allocate memory, a null pointer. The user is responsible for freeing the allocated memory.

stdlib_ndarray_function_free( *obj )

Frees an ndarray function object's allocated memory.

#include "stdlib/ndarray/base/unary.h"
#include "stdlib/ndarray/dtypes.h"
#include <stdlib.h>
#include <stdio.h>

// Define the function(s) we want to apply to ndarrays:
double scale( const double x ) {
    return x * 10.0;
}

// Define a function name:
const char name[] = "unary_ndarray_function";

// Define a list of ndarray functions:
ndarrayFcn functions[] = {
    stdlib_ndarray_d_d
};

// Define the **ndarray** argument types for each ndarray function:
int32_t types[] = {
    STDLIB_NDARRAY_FLOAT64, STDLIB_NDARRAY_FLOAT64
};

// Define a list of ndarray function "data" (in this case, callbacks):
void *data[] = {
    (void *)scale
};

// Create a new ndarray function object:
struct ndarrayFunctionObject *obj = stdlib_ndarray_function_allocate( name, 1, 1, functions, 1, types, data );
if ( obj == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Free allocated memory:
stdlib_ndarray_function_free( obj );

The function accepts the following arguments:

• obj: [in] ndarrayFunctionObject* ndarray function object.

void stdlib_ndarray_function_free( struct ndarrayFunctionObject *obj )

stdlib_ndarray_function_dispatch_index_of( _obj, _types )

Returns the first index of a function whose signature satisfies a provided list of array types.

#include "stdlib/ndarray/base/unary.h"
#include "stdlib/ndarray/dtypes.h"
#include <stdlib.h>
#include <stdio.h>

// Define the function(s) we want to apply to ndarrays:
double scale( const double x ) {
    return x * 10.0;
}

// ...

// Define a function name:
const char name[] = "unary_ndarray_function";

// Define a list of ndarray functions:
ndarrayFcn functions[] = {
    stdlib_ndarray_d_d,
    stdlib_ndarray_f_f_as_d_d
};

// Define the **ndarray** argument types for each ndarray function:
int32_t types[] = {
    STDLIB_NDARRAY_FLOAT64, STDLIB_NDARRAY_FLOAT64,
    STDLIB_NDARRAY_FLOAT32, STDLIB_NDARRAY_FLOAT64
};

// Define a list of ndarray function "data" (in this case, callbacks):
void *data[] = {
    (void *)scale,
    (void *)scale
};

// Create a new ndarray function object:
struct ndarrayFunctionObject *obj = stdlib_ndarray_function_allocate( name, 1, 1, functions, 2, types, data );
if ( obj == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Define a list of types on which to dispatch:
int32_t itypes[] = {
    STDLIB_NDARRAY_FLOAT32, STDLIB_NDARRAY_FLOAT64
};

// Find a function satisfying the list of types:
int64_t idx = stdlib_ndarray_function_dispatch_index_of( obj, itypes );
if ( idx < 0 ) {
    fprintf( stderr, "Unable to find function.\n" );
    exit( 1 );
}

// ...

// Free allocated memory:
stdlib_ndarray_function_free( obj );

The function accepts the following arguments:

• obj: [in] ndarrayFunctionObject* ndarray function object.
• types: [in] int32_t* list of array types on which to dispatch.

int64_t stdlib_ndarray_function_dispatch_index_of( const struct ndarrayFunctionObject *obj, const int32_t *types )

If a function is found, the function returns the index of the function, and the function returns -1 if unable to find a function.

---

Notice

This package is part of stdlib, a standard library for JavaScript and Node.js, with an emphasis on numerical and scientific computing. The library provides a collection of robust, high performance libraries for mathematics, statistics, streams, utilities, and more.

For more information on the project, filing bug reports and feature requests, and guidance on how to develop stdlib, see the main project repository.

Community

---

License

See LICENSE.

Copyright

Copyright © 2016-2025. The Stdlib Authors.