ndarray

Usage

#include "stdlib/ndarray/ctor.h"

ndarray

Structure holding ndarray data.

#include "stdlib/ndarray/dtypes.h"
#include "stdlib/ndarray/index_modes.h"
#include "stdlib/ndarray/orders.h"
#include "stdlib/ndarray/base/bytes_per_element.h"
#include <stdint.h>

struct ndarray {
    // Underlying data type:
    int16_t dtype;

    // Pointer to the underlying byte array:
    uint8_t *data;

    // Number of array dimensions:
    int64_t ndims;

    // Array shape (dimensions):
    int64_t *shape;

    // Array strides (in bytes) specifying how to iterate over a strided array:
    int64_t *strides;

    // Byte offset which specifies the location at which to start iterating over array elements:
    int64_t offset;

    // Array order (either row-major (C-style) or column-major (Fortran-style)):
    int8_t order;

    // Mode specifying how to handle indices which exceed array dimensions:
    int8_t imode;

    // Number of subscript modes:
    int64_t nsubmodes;

    // Mode(s) specifying how to handle subscripts which exceed array dimensions on a per dimension basis:
    int8_t *submodes;

    // Number of array elements:
    int64_t length;

    // Size in bytes:
    int64_t byteLength;

    // Number of bytes per element (i.e., item size):
    int64_t BYTES_PER_ELEMENT;

    // Bit mask providing information regarding the memory layout of the array (e.g., see macros):
    int64_t flags;
};

STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG

Macro defining a flag indicating whether an ndarray is row-major (C-style) contiguous.

#define STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG 0x0001

Notes:

• Row-major order indicates that the last ndarray index varies the fastest.
• Contiguous means that an ndarray is compatible with being stored in a single memory segment and that ndarray elements are adjacent to each other in memory.
• strides array is in reverse order to that of column-major order.
• An ndarray can be both row-major and column-major contiguous (e.g., if an ndarray is one-dimensional).

STDLIB_NDARRAY_COLUMN_MAJOR_CONTIGUOUS_FLAG

Macro defining a flag indicating whether an ndarray is column-major (Fortran-style) contiguous.

#define STDLIB_NDARRAY_COLUMN_MAJOR_CONTIGUOUS_FLAG 0x0002

Notes:

• Column-major order indicates that the first ndarray index varies the fastest.
• Contiguous means that an ndarray is compatible with being stored in a single memory segment and that ndarray elements are adjacent to each other in memory.
• strides array is in reverse order to that of row-major order.
• An ndarray can be both row-major and column-major contiguous (e.g., if an ndarray is one-dimensional).

stdlib_ndarray_allocate( dtype, *data, ndims, *shape, *strides, offset, order, imode, nsubmodes, *submodes )

Returns a pointer to a dynamically allocated ndarray.

#include "stdlib/ndarray/ctor.h"
#include "stdlib/ndarray/dtypes.h"
#include "stdlib/ndarray/index_modes.h"
#include "stdlib/ndarray/orders.h"
#include "stdlib/ndarray/base/bytes_per_element.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

// Specify the underlying data type:
enum STDLIB_NDARRAY_DTYPE dtype = STDLIB_NDARRAY_FLOAT64;

// Create an underlying byte array:
uint8_t buffer[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

// Specify the number of array dimensions:
int64_t ndims = 1;

// Specify the array shape:
int64_t shape[] = { 3 }; // vector consisting of 3 doubles

// Specify the array strides:
int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };

// Specify the byte offset:
int64_t offset = 0;

// Specify the array order (note: this does not matter for a 1-dimensional array):
enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;

// Specify the index mode:
enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;

// Specify the subscript index modes:
int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };
int64_t nsubmodes = 1;

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( dtype, buffer, ndims, shape, strides, offset, order, imode, nsubmodes, submodes );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• dtype: [in] int16_t data type.
• data: [in] uint8_t* pointer to the underlying byte array.
• ndims: [in] int64_t number of dimensions.
• shape: [in] int64_t* array shape (i.e., dimensions).
• strides: [in] int64_t* array strides (in bytes).
• offset: [in] int64_t byte offset specifying the location of the first element.
• order: [in] int8_t specifies whether an array is row-major (C-style) or column-major (Fortran-style).
• imode: [in] int8_t specifies the index mode (i.e., how to handle indices which exceed array dimensions).
• nsubmodes: [in] int64_t number of subscript modes.
• submodes: [in] int8_t* specifies how to handle subscripts which exceed array dimensions on a per dimension basis (if provided fewer submodes than dimensions, submodes are recycled using modulo arithmetic).

struct ndarray * stdlib_ndarray_allocate( int16_t dtype, uint8_t *data, int64_t ndims, int64_t *shape, int64_t *strides, int64_t offset, int8_t order, int8_t imode, int64_t nsubmodes, int8_t *submodes );

Notes:

• The user is responsible for freeing the allocated memory.

stdlib_ndarray_bytelength( *arr )

Returns the size of an ndarray (in bytes).

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the ndarray size:
int64_t N = stdlib_ndarray_bytelength( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t stdlib_ndarray_bytelength( const struct ndarray *arr );

stdlib_ndarray_data( *arr )

Returns a pointer to an ndarray's underlying byte array.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the underlying byte array:
uint8_t *data = stdlib_ndarray_data( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

uint8_t * stdlib_ndarray_data( const struct ndarray *arr );

stdlib_ndarray_dimension( *arr, i )

Returns an ndarray dimension.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve a dimension:
int64_t dim = stdlib_ndarray_dimension( x, 0 );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• i: [in] int64_t dimension index.

int64_t stdlib_ndarray_dimension( const struct ndarray *arr, const int64_t i );

Notes:

• The function does perform bounds checking for the dimension index.

stdlib_ndarray_disable_flags( *arr, flags )

Disables specified ndarray flags.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Disables specified ndarray flags:
int8_t status = stdlib_ndarray_disable_flags( x, STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• flags: [in] int64_t bit mask to disable flags.

The function returns a status code of 0 if able to successfully disable flags.

int8_t stdlib_ndarray_disable_flags( const struct ndarray *arr, const int64_t flags );

Notes:

• The function does not perform any sanity checks and assumes the user knows what s/he is doing.

stdlib_ndarray_dtype( *arr )

Returns the data type of an ndarray.

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

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the dtype:
enum STDLIB_NDARRAY_DTYPE dtype = stdlib_ndarray_dtype( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int16_t stdlib_ndarray_dtype( const struct ndarray *arr );

stdlib_ndarray_enable_flags( *arr, flags )

Enables specified ndarray flags.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Enables specified ndarray flags:
int8_t status = stdlib_ndarray_enable_flags( x, STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• flags: [in] int64_t bit mask to enable flags.

The function returns a status code of 0 if able to successfully enable flags.

int8_t stdlib_ndarray_enable_flags( const struct ndarray *arr, const int64_t flags );

Notes:

• The function does not perform any sanity checks and assumes the user knows what s/he is doing.

stdlib_ndarray_flags( *arr )

Returns ndarray flags as a single integer value.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the ndarray flags:
int64_t flags = stdlib_ndarray_flags( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t stdlib_ndarray_flags( const struct ndarray *arr );

stdlib_ndarray_free( *arr )

Frees an ndarray's allocated memory.

#include "stdlib/ndarray/ctor.h"
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

void stdlib_ndarray_free( struct ndarray *arr );

stdlib_ndarray_has_flags( *arr, flags )

Tests whether an ndarray has specified flags enabled.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Test whether an ndarray is row-major contiguous:
int8_t out = stdlib_ndarray_flags( x, STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• flags: [in] int64_t bit mask specifying flags to test against.

The function returns 1 if flags are set and 0 otherwise.

int8_t stdlib_ndarray_has_flags( const struct ndarray *arr, const int64_t flags );

stdlib_ndarray_index_mode( *arr )

Returns the index mode of an ndarray.

#include "stdlib/ndarray/ctor.h"
#include "stdlib/ndarray/index_modes.h"
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the index mode:
enum STDLIB_NDARRAY_INDEX_MODE imode = stdlib_ndarray_index_mode( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int8_t stdlib_ndarray_index_mode( const struct ndarray *arr );

stdlib_ndarray_length( *arr )

Returns the number of elements in an ndarray.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the number of elements:
int64_t N = stdlib_ndarray_length( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t stdlib_ndarray_length( const struct ndarray *arr );

stdlib_ndarray_ndims( *arr )

Returns the number of ndarray dimensions.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the number of dimensions:
int64_t ndims = stdlib_ndarray_ndims( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t stdlib_ndarray_ndims( const struct ndarray *arr );

stdlib_ndarray_nsubmodes( *arr )

Returns the number of ndarray subscript modes.

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the number of index modes:
int64_t n = stdlib_ndarray_nsubmodes( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t stdlib_ndarray_nsubmodes( const struct ndarray *arr );

stdlib_ndarray_offset( *arr )

Returns an ndarray index offset (in bytes).

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the index offset:
int64_t offset = stdlib_ndarray_offset( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t stdlib_ndarray_offset( const struct ndarray *arr );

stdlib_ndarray_order( *arr )

Returns the order of an ndarray.

#include "stdlib/ndarray/ctor.h"
#include "stdlib/ndarray/orders.h"
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the order:
enum STDLIB_NDARRAY_ORDER order = stdlib_ndarray_order( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int8_t stdlib_ndarray_order( const struct ndarray *arr );

stdlib_ndarray_shape( *arr )

Returns a pointer to an array containing an ndarray shape (dimensions).

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the shape:
int64_t *shape = stdlib_ndarray_shape( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t * stdlib_ndarray_shape( const struct ndarray *arr );

stdlib_ndarray_stride( *arr, i )

Returns an ndarray stride (in bytes).

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve a stride:
int64_t s = stdlib_ndarray_stride( x, 0 );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• i: [in] int64_t dimension index.

int64_t stdlib_ndarray_stride( const struct ndarray *arr, const int64_t i );

Notes:

• the function does perform bounds checking for the dimension index.

stdlib_ndarray_strides( *arr )

Returns a pointer to an array containing ndarray strides (in bytes).

#include "stdlib/ndarray/ctor.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the strides:
int64_t *strides = stdlib_ndarray_strides( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int64_t * stdlib_ndarray_strides( const struct ndarray *arr );

stdlib_ndarray_submode( *arr, i )

Returns an ndarray subscript mode.

#include "stdlib/ndarray/ctor.h"
#include "stdlib/ndarray/index_modes.h"
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve an index mode:
enum STDLIB_NDARRAY_INDEX_MODE mode = stdlib_ndarray_submode( x, 0 );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• i: [in] int64_t dimension index.

int8_t stdlib_ndarray_submode( const struct ndarray *arr, const int64_t i );

Notes:

• If an ndarray has fewer subscript modes than dimensions, modes are recycled using modulo arithmetic.
• The function does not perform bounds checking for the dimension index.

stdlib_ndarray_submodes( *arr )

Returns ndarray subscript modes.

#include "stdlib/ndarray/ctor.h"
#include "stdlib/ndarray/index_modes.h"
#include <stdlib.h>
#include <stdio.h>

// ...

// Create an ndarray:
struct ndarray *x = stdlib_ndarray_allocate( ... );
if ( x == NULL ) {
    fprintf( stderr, "Error allocating memory.\n" );
    exit( 1 );
}

// ...

// Retrieve the index subscript modes:
int8_t *modes = stdlib_ndarray_submodes( x );

// ...

// Free allocated memory:
stdlib_ndarray_free( x );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.

int8_t * stdlib_ndarray_submodes( const struct ndarray *arr );

stdlib_ndarray_get( *arr, *sub, *out )

Returns an ndarray data element.

int8_t stdlib_ndarray_get( const struct ndarray *arr, const int64_t *sub, void *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] void * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function requires a void pointer for the output address out in order to provide a generic API supporting ndarrays having different data types.

stdlib_ndarray_get_float64( *arr, *sub, *out )

Returns a double-precision floating-point ndarray data element.

int8_t stdlib_ndarray_get_float64( const struct ndarray *arr, const int64_t *sub, double *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] double * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_float32( *arr, *sub, *out )

Returns a single-precision floating-point ndarray data element.

int8_t stdlib_ndarray_get_float32( const struct ndarray *arr, const int64_t *sub, float *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] float * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_uint64( *arr, *sub, *out )

Returns an unsigned 64-bit integer ndarray data element.

int8_t stdlib_ndarray_get_uint64( const struct ndarray *arr, const int64_t *sub, uint64_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] uint64_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_int64( *arr, *sub, *out )

Returns a signed 64-bit integer ndarray data element.

int8_t stdlib_ndarray_get_int64( const struct ndarray *arr, const int64_t *sub, int64_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] int64_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_uint32( *arr, *sub, *out )

Returns an unsigned 32-bit integer ndarray data element.

int8_t stdlib_ndarray_get_uint32( const struct ndarray *arr, const int64_t *sub, uint32_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] uint32_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_int32( *arr, *sub, *out )

Returns a signed 32-bit integer ndarray data element.

int8_t stdlib_ndarray_get_int32( const struct ndarray *arr, const int64_t *sub, int32_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] int32_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_uint16( *arr, *sub, *out )

Returns an unsigned 16-bit integer ndarray data element.

int8_t stdlib_ndarray_get_uint16( const struct ndarray *arr, const int64_t *sub, uint16_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] uint16_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_int16( *arr, *sub, *out )

Returns a signed 16-bit integer ndarray data element.

int8_t stdlib_ndarray_get_int16( const struct ndarray *arr, const int64_t *sub, int16_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] int16_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_uint8( *arr, *sub, *out )

Returns an unsigned 8-bit integer ndarray data element.

int8_t stdlib_ndarray_get_uint8( const struct ndarray *arr, const int64_t *sub, uint8_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] uint8_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_int8( *arr, *sub, *out )

Returns a signed 8-bit integer ndarray data element.

int8_t stdlib_ndarray_get_int8( const struct ndarray *arr, const int64_t *sub, int8_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] int8_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_complex128( *arr, *sub, *out )

Returns a double-precision complex floating-point ndarray data element.

int8_t stdlib_ndarray_get_complex128( const struct ndarray *arr, const int64_t *sub, stdlib_complex128_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] stdlib_complex128_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_complex64( *arr, *sub, *out )

Returns a single-precision complex floating-point ndarray data element.

int8_t stdlib_ndarray_get_complex64( const struct ndarray *arr, const int64_t *sub, stdlib_complex64_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] stdlib_complex64_t * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_bool( *arr, *sub, *out )

Returns a boolean ndarray data element.

int8_t stdlib_ndarray_get_bool( const struct ndarray *arr, const int64_t *sub, bool *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.
• out: [out] bool * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.

stdlib_ndarray_get_ptr( *arr, *sub )

Returns a pointer to an ndarray data element in the underlying byte array.

uint8_t * stdlib_ndarray_get_ptr( const struct ndarray *arr, const int64_t *sub );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• sub: [in] int64_t * ndarray subscripts.

stdlib_ndarray_get_ptr_value( *arr, *idx, *out )

Returns an ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_value( const struct ndarray *arr, const uint8_t *idx, void *out );

The function accepts the following arguments:

• arr: [in] struct ndarray * input ndarray.
• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] void * output address.

Notes:

• The function does not perform bounds checking and assumes you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• The function requires a void pointer for the output address out in order to provide a generic API supporting ndarrays having different data types.

stdlib_ndarray_get_ptr_float64( *idx, *out )

Returns a double-precision floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_float64( const uint8_t *idx, double *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] double * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_float32( *idx, *out )

Returns a single-precision floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_float32( const uint8_t *idx, float *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] float * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_uint64( *idx, *out )

Returns an unsigned 64-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_uint64( const uint8_t *idx, uint64_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] uint64_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_int64( *idx, *out )

Returns a signed 64-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_int64( const uint8_t *idx, int64_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] int64_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_uint32( *idx, *out )

Returns an unsigned 32-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_uint32( const uint8_t *idx, uint32_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] uint32_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_int32( *idx, *out )

Returns a signed 32-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_int32( const uint8_t *idx, int32_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] int32_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_uint16( *idx, *out )

Returns an unsigned 16-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_uint16( const uint8_t *idx, uint16_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] uint16_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_int16( *idx, *out )

Returns a signed 16-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_int16( const uint8_t *idx, int16_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] int16_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_uint8( *idx, *out )

Returns an unsigned 8-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_uint8( const uint8_t *idx, uint8_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] uint8_t * output address.

Notes:

• The function always returns 0.

stdlib_ndarray_get_ptr_int8( *idx, *out )

Returns a signed 8-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_int8( const uint8_t *idx, int8_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] int8_t * output address.

Notes:

• The function always returns 0.

stdlib_ndarray_get_ptr_complex128( *idx, *out )

Returns a double-precision complex floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_complex128( const uint8_t *idx, stdlib_complex128_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] stdlib_complex128_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_complex64( *idx, *out )

Returns a single-precision complex floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_complex64( const uint8_t *idx, stdlib_complex64_t *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] stdlib_complex64_t * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_get_ptr_bool( *idx, *out )

Returns a boolean ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_get_ptr_bool( const uint8_t *idx, bool *out );

The function accepts the following arguments:

• idx: [in] uint8_t * byte array pointer to an ndarray data element.
• out: [out] bool * output address.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_iget( *arr, idx, *out )

Returns an ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget( const struct ndarray *arr, const int64_t idx, void *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] void * output address.

Notes:

• The function returns -1 if unable to get an element and 0 otherwise.
• The function requires a void pointer for the output address out in order to provide a generic API supporting ndarrays having different data types.
• The function places the burden on the user to ensure that the output address is compatible with the data type of input ndarray data elements.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_float64( *arr, idx, *out )

Returns a double-precision floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_float64( const struct ndarray *arr, const int64_t idx, double *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] double * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_float32( *arr, idx, *out )

Returns a single-precision floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_float32( const struct ndarray *arr, const int64_t idx, float *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] float * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_uint64( *arr, idx, *out )

Returns an unsigned 64-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_uint64( const struct ndarray *arr, const int64_t idx, uint64_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] uint64_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_int64( *arr, idx, *out )

Returns a signed 64-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_int64( const struct ndarray *arr, const int64_t idx, int64_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] int64_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_uint32( *arr, idx, *out )

Returns an unsigned 32-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_uint32( const struct ndarray *arr, const int64_t idx, uint32_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] uint32_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_int32( *arr, idx, *out )

Returns a signed 32-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_int32( const struct ndarray *arr, const int64_t idx, int32_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] int32_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_uint16( *arr, idx, *out )

Returns an unsigned 16-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_uint16( const struct ndarray *arr, const int64_t idx, uint16_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] uint16_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_int16( *arr, idx, *out )

Returns a signed 16-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_int16( const struct ndarray *arr, const int64_t idx, int16_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] int16_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_uint8( *arr, idx, *out )

Returns an unsigned 8-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_uint8( const struct ndarray *arr, const int64_t idx, uint8_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] uint8_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_int8( *arr, idx, *out )

Returns a signed 8-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_int8( const struct ndarray *arr, const int64_t idx, int8_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] int8_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_complex128( *arr, idx, *out )

Returns a double-precision complex floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_complex128( const struct ndarray *arr, const int64_t idx, stdlib_complex128_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] stdlib_complex128_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_complex64( *arr, idx, *out )

Returns a single-precision complex floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_complex64( const struct ndarray *arr, const int64_t idx, stdlib_complex64_t *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] stdlib_complex64_t * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_bool( *arr, idx, *out )

Returns a boolean ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iget_bool( const struct ndarray *arr, const int64_t idx, bool *out );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• out: [out] bool * output address.

Notes:

• The function does not verify that the output address type matches the underlying input ndarray data type and assumes that you know what you are doing.
• The function returns -1 if unable to get an element and 0 otherwise.
• For zero-dimensional arrays, the function returns the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iget_ptr( *arr, idx )

Returns a pointer in the underlying byte array for an ndarray data element located at a specified linear index.

uint8_t * stdlib_ndarray_iget_ptr( const struct ndarray *arr, const int64_t idx );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.

For zero-dimensional arrays, the function returns a pointer to the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset( *arr, idx, *v )

Sets an ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset( const struct ndarray *arr, const int64_t idx, const void *v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] void* value to set.

Notes:

• The function returns -1 if unable to set an element and 0 otherwise.
• The function requires a pointer to a data value v in order to provide a generic API supporting ndarrays having different data types.
• The function has no way of determining whether v actually points to a memory address compatible with the underlying input ndarray data type. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_float64( *arr, idx, v )

Sets a double-precision floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_float64( const struct ndarray *arr, const int64_t idx, const double v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] double value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_float32( *arr, idx, v )

Sets a single-precision floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_float32( const struct ndarray *arr, const int64_t idx, const float v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] float value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_uint64( *arr, idx, v )

Sets an unsigned 64-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_uint64( const struct ndarray *arr, const int64_t idx, const uint64_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] uint64_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_int64( *arr, idx, v )

Sets a signed 64-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_int64( const struct ndarray *arr, const int64_t idx, const int64_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] int64_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_uint32( *arr, idx, v )

Sets an unsigned 32-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_uint32( const struct ndarray *arr, const int64_t idx, const uint32_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] uint32_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_int32( *arr, idx, v )

Sets a signed 32-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_int32( const struct ndarray *arr, const int64_t idx, const int32_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] int32_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_uint16( *arr, idx, v )

Sets an unsigned 16-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_uint16( const struct ndarray *arr, const int64_t idx, const uint16_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] uint16_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_int16( *arr, idx, v )

Sets a signed 16-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_int16( const struct ndarray *arr, const int64_t idx, const int16_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] int16_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_uint8( *arr, idx, v )

Sets an unsigned 8-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_uint8( const struct ndarray *arr, const int64_t idx, const uint8_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] uint8_t value to set.

Notes:

• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_int8( *arr, idx, v )

Sets a signed 8-bit integer ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_int8( const struct ndarray *arr, const int64_t idx, const int8_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] int8_t value to set.

Notes:

• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_complex128( *arr, idx, v )

Sets a double-precision complex floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_complex128( const struct ndarray *arr, const int64_t idx, const stdlib_complex128_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] stdlib_complex128_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_complex64( *arr, idx, v )

Sets a single-precision complex floating-point ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_complex64( const struct ndarray *arr, const int64_t idx, const stdlib_complex64_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] stdlib_complex64_t value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_iset_bool( *arr, idx, v )

Sets a boolean ndarray data element located at a specified linear index.

int8_t stdlib_ndarray_iset_bool( const struct ndarray *arr, const int64_t idx, const bool v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] int64_t linear view index.
• v: [in] bool value to set.

Notes:

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• For zero-dimensional arrays, the function sets the first (and only) indexed element, regardless of the value of idx.

stdlib_ndarray_set( *arr, *sub, *v )

Sets an ndarray data element.

int8_t stdlib_ndarray_set( const struct ndarray *arr, const int64_t *sub, const void *v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] void* value to set.

Notes

• The function returns -1 if unable to set an element and 0 otherwise.
• The function requires a pointer to a data value v in order to provide a generic API supporting ndarrays having different data types.
• The function has no way of determining whether v actually points to a memory address compatible with the underlying input ndarray data type. Accordingly, accessing unowned memory is possible, and this function assumes you know what you are doing.

stdlib_ndarray_set_float64( *arr, *sub, v )

Sets a double-precision floating-point ndarray data element.

int8_t stdlib_ndarray_set_float64( const struct ndarray *arr, const int64_t *sub, const double v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] double value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_float32( *arr, *sub, v )

Sets a single-precision floating-point ndarray data element.

int8_t stdlib_ndarray_set_float32( const struct ndarray *arr, const int64_t *sub, const float v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] float value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_uint64( *arr, *sub, v )

Sets an unsigned 64-bit integer ndarray data element.

int8_t stdlib_ndarray_set_uint64( const struct ndarray *arr, const int64_t *sub, const uint64_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] uint64_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_int64( *arr, *sub, v )

Sets a signed 64-bit integer ndarray data element.

int8_t stdlib_ndarray_set_int64( const struct ndarray *arr, const int64_t *sub, const int64_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] int64_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_uint32( *arr, *sub, v )

Sets an unsigned 32-bit integer ndarray data element.

int8_t stdlib_ndarray_set_uint32( const struct ndarray *arr, const int64_t *sub, const uint32_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] uint32_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_int32( *arr, *sub, v )

Sets a signed 32-bit integer ndarray data element.

int8_t stdlib_ndarray_set_int32( const struct ndarray *arr, const int64_t *sub, const int32_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] int32_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_uint16( *arr, *sub, v )

Sets an unsigned 16-bit integer ndarray data element.

int8_t stdlib_ndarray_set_uint16( const struct ndarray *arr, const int64_t *sub, const uint16_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] uint16_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_int16( *arr, *sub, v )

Sets a signed 16-bit integer ndarray data element.

int8_t stdlib_ndarray_set_int16( const struct ndarray *arr, const int64_t *sub, const int16_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] int16_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_uint8( *arr, *sub, v )

Sets an unsigned 8-bit integer ndarray data element.

int8_t stdlib_ndarray_set_uint8( const struct ndarray *arr, const int64_t *sub, const uint8_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] uint8_t value to set.

Notes

• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_int8( *arr, *sub, v )

Sets a signed 8-bit integer ndarray data element.

int8_t stdlib_ndarray_set_int8( const struct ndarray *arr, const int64_t *sub, const int8_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] int8_t value to set.

Notes

• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_complex128( *arr, *sub, v )

Sets a double-precision complex floating-point ndarray data element.

int8_t stdlib_ndarray_set_complex128( const struct ndarray *arr, const int64_t *sub, const stdlib_complex128_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] stdlib_complex128_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_complex64( *arr, *sub, v )

Sets a single-precision complex floating-point ndarray data element.

int8_t stdlib_ndarray_set_complex64( const struct ndarray *arr, const int64_t *sub, const stdlib_complex64_t v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] stdlib_complex64_t value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_bool( *arr, *sub, v )

Sets a boolean ndarray data element.

int8_t stdlib_ndarray_set_bool( const struct ndarray *arr, const int64_t *sub, const bool v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• sub: [in] int64_t* ndarray subscripts.
• v: [in] bool value to set.

Notes

• The function does not verify that the type of v matches the underlying input ndarray data type, and, thus, overwriting unowned memory is possible. The function assumes that you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.

stdlib_ndarray_set_ptr_value( *arr, *idx, *v )

Sets an ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_value( const struct ndarray *arr, uint8_t *idx, const void *v );

The function accepts the following arguments:

• arr: [in] struct ndarray* input ndarray.
• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] void* value to set.

Notes:

• The function does not perform bounds checking, and, thus, the function does not prevent you from overwriting unowned memory. Accordingly, the function assumes you know what you are doing.
• The function returns -1 if unable to set an element and 0 otherwise.
• The function requires a pointer to a data value v in order to provide a generic API supporting ndarrays having different data types.

stdlib_ndarray_set_ptr_float64( *idx, v )

Sets a double-precision floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_float64( uint8_t *idx, const double v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] double value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_float32( *idx, v )

Sets a single-precision floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_float32( uint8_t *idx, const float v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] float value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_uint64( *idx, v )

Sets an unsigned 64-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_uint64( uint8_t *idx, const uint64_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] uint64_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_int64( *idx, v )

Sets a signed 64-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_int64( uint8_t *idx, const int64_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] int64_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_uint32( *idx, v )

Sets an unsigned 32-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_uint32( uint8_t *idx, const uint32_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] uint32_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_int32( *idx, v )

Sets a signed 32-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_int32( uint8_t *idx, const int32_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] int32_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_uint16( *idx, v )

Sets an unsigned 16-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_uint16( uint8_t *idx, const uint16_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] uint16_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_int16( *idx, v )

Sets a signed 16-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_int16( uint8_t *idx, const int16_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] int16_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_uint8( *idx, v )

Sets an unsigned 8-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_uint8( uint8_t *idx, const uint8_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] uint8_t value to set.

Notes:

• The function always returns 0.

stdlib_ndarray_set_ptr_int8( *idx, v )

Sets a signed 8-bit integer ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_int8( uint8_t *idx, const int8_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] int8_t value to set.

Notes:

• The function always returns 0.

stdlib_ndarray_set_ptr_complex128( *idx, v )

Sets a double-precision complex floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_complex128( uint8_t *idx, const stdlib_complex128_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] stdlib_complex128_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_complex64( *idx, v )

Sets a single-precision complex floating-point ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_complex64( uint8_t *idx, const stdlib_complex64_t v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] stdlib_complex64_t value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.

stdlib_ndarray_set_ptr_bool( *idx, v )

Sets a boolean ndarray data element specified by a byte array pointer.

int8_t stdlib_ndarray_set_ptr_bool( uint8_t *idx, const bool v );

The function accepts the following arguments:

• idx: [in] uint8_t* byte array pointer to an ndarray data element.
• v: [in] bool value to set.

Notes:

• The function has no way of determining whether idx actually points to a compatible memory address. Accordingly, overwriting unowned memory is possible, and this function assumes you know what you are doing.
• The function always returns 0.