Usage

1#include "stdlib/ndarray/ctor.h"

ndarray

Structure holding ndarray data.

1#include "stdlib/ndarray/dtypes.h"
2#include "stdlib/ndarray/index_modes.h"
3#include "stdlib/ndarray/orders.h"
4#include "stdlib/ndarray/base/bytes_per_element.h"
5#include <stdint.h>
6
7struct ndarray {
8    // Underlying data type:
9    int16_t dtype;
10
11    // Pointer to the underlying byte array:
12    uint8_t *data;
13
14    // Number of array dimensions:
15    int64_t ndims;
16
17    // Array shape (dimensions):
18    int64_t *shape;
19
20    // Array strides (in bytes) specifying how to iterate over a strided array:
21    int64_t *strides;
22
23    // Byte offset which specifies the location at which to start iterating over array elements:
24    int64_t offset;
25
26    // Array order (either row-major (C-style) or column-major (Fortran-style)):
27    int8_t order;
28
29    // Mode specifying how to handle indices which exceed array dimensions:
30    int8_t imode;
31
32    // Number of subscript modes:
33    int64_t nsubmodes;
34
35    // Mode(s) specifying how to handle subscripts which exceed array dimensions on a per dimension basis:
36    int8_t *submodes;
37
38    // Number of array elements:
39    int64_t length;
40
41    // Size in bytes:
42    int64_t byteLength;
43
44    // Number of bytes per element (i.e., item size):
45    int64_t BYTES_PER_ELEMENT;
46
47    // Bit mask providing information regarding the memory layout of the array (e.g., see macros):
48    int64_t flags;
49};

STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG

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

1#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.

1#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.

1#include "stdlib/ndarray/ctor.h"
2#include "stdlib/ndarray/dtypes.h"
3#include "stdlib/ndarray/index_modes.h"
4#include "stdlib/ndarray/orders.h"
5#include "stdlib/ndarray/base/bytes_per_element.h"
6#include <stdlib.h>
7#include <stdio.h>
8#include <stdint.h>
9
10// Specify the underlying data type:
11enum STDLIB_NDARRAY_DTYPE dtype = STDLIB_NDARRAY_FLOAT64;
12
13// Create an underlying byte array:
14uint8_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 };
15
16// Specify the number of array dimensions:
17int64_t ndims = 1;
18
19// Specify the array shape:
20int64_t shape[] = { 3 }; // vector consisting of 3 doubles
21
22// Specify the array strides:
23int64_t strides[] = { STDLIB_NDARRAY_FLOAT64_BYTES_PER_ELEMENT };
24
25// Specify the byte offset:
26int64_t offset = 0;
27
28// Specify the array order (note: this does not matter for a 1-dimensional array):
29enum STDLIB_NDARRAY_ORDER order = STDLIB_NDARRAY_ROW_MAJOR;
30
31// Specify the index mode:
32enum STDLIB_NDARRAY_INDEX_MODE imode = STDLIB_NDARRAY_INDEX_ERROR;
33
34// Specify the subscript index modes:
35int8_t submodes[] = { STDLIB_NDARRAY_INDEX_ERROR };
36int64_t nsubmodes = 1;
37
38// Create an ndarray:
39struct ndarray *x = stdlib_ndarray_allocate( dtype, buffer, ndims, shape, strides, offset, order, imode, nsubmodes, submodes );
40if ( x == NULL ) {
41    fprintf( stderr, "Error allocating memory.\n" );
42    exit( 1 );
43}
44
45// Free allocated memory:
46stdlib_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).

1struct 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).

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the ndarray size:
18int64_t N = stdlib_ndarray_bytelength( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t stdlib_ndarray_bytelength( const struct ndarray *arr );

stdlib_ndarray_data( *arr )

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

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the underlying byte array:
18uint8_t *data = stdlib_ndarray_data( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1uint8_t * stdlib_ndarray_data( const struct ndarray *arr );

stdlib_ndarray_dimension( *arr, i )

Returns an ndarray dimension.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve a dimension:
18int64_t dim = stdlib_ndarray_dimension( x, 0 );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_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.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Disables specified ndarray flags:
18int8_t status = stdlib_ndarray_disable_flags( x, STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG );
19
20// ...
21
22// Free allocated memory:
23stdlib_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.

1int8_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.

1#include "stdlib/ndarray/ctor.h"
2#include "stdlib/ndarray/dtypes.h"
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the dtype:
18enum STDLIB_NDARRAY_DTYPE dtype = stdlib_ndarray_dtype( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int16_t stdlib_ndarray_dtype( const struct ndarray *arr );

stdlib_ndarray_enable_flags( *arr, flags )

Enables specified ndarray flags.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Enables specified ndarray flags:
18int8_t status = stdlib_ndarray_enable_flags( x, STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG );
19
20// ...
21
22// Free allocated memory:
23stdlib_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.

1int8_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.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the ndarray flags:
18int64_t flags = stdlib_ndarray_flags( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t stdlib_ndarray_flags( const struct ndarray *arr );

stdlib_ndarray_free( *arr )

Frees an ndarray's allocated memory.

1#include "stdlib/ndarray/ctor.h"
2#include <stdlib.h>
3#include <stdio.h>
4
5// ...
6
7// Create an ndarray:
8struct ndarray *x = stdlib_ndarray_allocate( ... );
9if ( x == NULL ) {
10    fprintf( stderr, "Error allocating memory.\n" );
11    exit( 1 );
12}
13
14// ...
15
16// Free allocated memory:
17stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1void stdlib_ndarray_free( struct ndarray *arr );

stdlib_ndarray_has_flags( *arr, flags )

Tests whether an ndarray has specified flags enabled.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Test whether an ndarray is row-major contiguous:
18int8_t out = stdlib_ndarray_flags( x, STDLIB_NDARRAY_ROW_MAJOR_CONTIGUOUS_FLAG );
19
20// ...
21
22// Free allocated memory:
23stdlib_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.

1int8_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.

1#include "stdlib/ndarray/ctor.h"
2#include "stdlib/ndarray/index_modes.h"
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the index mode:
18enum STDLIB_NDARRAY_INDEX_MODE imode = stdlib_ndarray_index_mode( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int8_t stdlib_ndarray_index_mode( const struct ndarray *arr );

stdlib_ndarray_length( *arr )

Returns the number of elements in an ndarray.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the number of elements:
18int64_t N = stdlib_ndarray_length( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t stdlib_ndarray_length( const struct ndarray *arr );

stdlib_ndarray_ndims( *arr )

Returns the number of ndarray dimensions.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the number of dimensions:
18int64_t ndims = stdlib_ndarray_ndims( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t stdlib_ndarray_ndims( const struct ndarray *arr );

stdlib_ndarray_nsubmodes( *arr )

Returns the number of ndarray subscript modes.

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the number of index modes:
18int64_t n = stdlib_ndarray_nsubmodes( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t stdlib_ndarray_nsubmodes( const struct ndarray *arr );

stdlib_ndarray_offset( *arr )

Returns an ndarray index offset (in bytes).

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the index offset:
18int64_t offset = stdlib_ndarray_offset( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t stdlib_ndarray_offset( const struct ndarray *arr );

stdlib_ndarray_order( *arr )

Returns the order of an ndarray.

1#include "stdlib/ndarray/ctor.h"
2#include "stdlib/ndarray/orders.h"
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the order:
18enum STDLIB_NDARRAY_ORDER order = stdlib_ndarray_order( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int8_t stdlib_ndarray_order( const struct ndarray *arr );

stdlib_ndarray_shape( *arr )

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

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the shape:
18int64_t *shape = stdlib_ndarray_shape( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t * stdlib_ndarray_shape( const struct ndarray *arr );

stdlib_ndarray_stride( *arr, i )

Returns an ndarray stride (in bytes).

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve a stride:
18int64_t s = stdlib_ndarray_stride( x, 0 );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_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).

1#include "stdlib/ndarray/ctor.h"
2#include <stdint.h>
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the strides:
18int64_t *strides = stdlib_ndarray_strides( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int64_t * stdlib_ndarray_strides( const struct ndarray *arr );

stdlib_ndarray_submode( *arr, i )

Returns an ndarray subscript mode.

1#include "stdlib/ndarray/ctor.h"
2#include "stdlib/ndarray/index_modes.h"
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve an index mode:
18enum STDLIB_NDARRAY_INDEX_MODE mode = stdlib_ndarray_submode( x, 0 );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int8_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.

1#include "stdlib/ndarray/ctor.h"
2#include "stdlib/ndarray/index_modes.h"
3#include <stdlib.h>
4#include <stdio.h>
5
6// ...
7
8// Create an ndarray:
9struct ndarray *x = stdlib_ndarray_allocate( ... );
10if ( x == NULL ) {
11    fprintf( stderr, "Error allocating memory.\n" );
12    exit( 1 );
13}
14
15// ...
16
17// Retrieve the index subscript modes:
18int8_t *modes = stdlib_ndarray_submodes( x );
19
20// ...
21
22// Free allocated memory:
23stdlib_ndarray_free( x );

The function accepts the following arguments:

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

1int8_t * stdlib_ndarray_submodes( const struct ndarray *arr );

stdlib_ndarray_get( *arr, *sub, *out )

Returns an ndarray data element.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1uint8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.

1int8_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.