package nuod:mdarray
Source

⌘K
Ctrl+K
or
/

    Index

    Types (1)
    Constants (3)
    Variables (0)

    This section is empty.

    Procedures (319)

    Types

    MdArray ¶
    Source

    MdArray :: struct($T: typeid, $Nd := ) {
	… // See source for fields
}
     

    A structure that represents a multi-dimensional array. it stores all data in a singular slice. The dimensionality of the array is decided based on the shape field. To traverse the array an array of strides is precomputed based on the shape of the array.

    This structure does not now allows own the data in its buffer. If that's the case, then it's is called a view. Views may have shapes and strides that don't corresbond to the buffer length, typically because the view narrows the array or the shape of the arry has been permutated. How these fields are managed should not concern the user, as they are handled internally by Nuod.

    CAUTION: do not create instances of this structure manually. Used the make_mdarray procedure instead. It ensures that the array is valid and can be traversed correctly.

    Related Procedures With Parameters
    Related Procedures With Returns

    Constants

    N_TASKS ¶
    Source

    N_TASKS :: N_THREADS + 1

    N_THREADS ¶
    Source

    N_THREADS :: #config(N_THREADS, 4)

    THREAD_THR ¶
    Source

    THREAD_THR :: #config(THREAD_THR, 1_000_000)

    Variables

    This section is empty.

    Procedures

    add_arrays ¶
    Source

    add_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise addition operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    add_arrays_scalar ¶
    Source

    add_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise addition operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    add_scalar_array ¶
    Source

    add_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise addition operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    all ¶
    Source

    all :: proc(mdarray: MdArray($T=bool, $Nd), location := #caller_location) -> (accum: bool, ok: bool) #optional_ok {…}
     

    Verify that all elements in a boolean array are set to true.

    Inputs:
    mdarray: a multidimensional boolean array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: a boolean representing that all elements are set to true. ok: an optional boolean for error handling.

    all_close_default ¶
    Source

    all_close_default :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), location := #caller_location) -> (result: bool, ok: bool) #optional_ok {…}
     

    Verify that all the elements in two different arrays are close to each other based on the defualt tolerances.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    all_close_with_args ¶
    Source

    all_close_with_args :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), rtol: f64, atol: f64, location := #caller_location) -> (result: bool, ok: bool) #optional_ok {…}
     

    Verify that all the elements in two different arrays are close to each other based on custom tolerance values provided by the user.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. rtol: the relative tolerance. atol: the absolute tolerance. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    all_reduce_avg ¶
    Source

    all_reduce_avg :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to their average value.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    all_reduce_map ¶
    Source

    all_reduce_map :: proc(mdarray: MdArray($T, $Nd), f: proc($T, $T, .. ..$T) -> $T, initial: $T, .. args: ..$T, location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to a singular value according to a binary operator.

    Inputs:
    mdarray: a multidimensional array. f: a binary procedure with arguments. initial: the initial value to reduce over. args: the aguments to be provided to the binary operator f. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    all_reduce_max ¶
    Source

    all_reduce_max :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to their maximum value.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    all_reduce_min ¶
    Source

    all_reduce_min :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to their minimum value.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    all_reduce_prod_no_init ¶
    Source

    all_reduce_prod_no_init :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to their produce. takes no initial value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    Related Procedure Groups

    all_reduce_prod_with_init ¶
    Source

    all_reduce_prod_with_init :: proc(mdarray: MdArray($T, $Nd), initial: $T, location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to their produce. takes an initial value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. initial: the initial value to reduce over. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    Related Procedure Groups

    all_reduce_sum_no_init ¶
    Source

    all_reduce_sum_no_init :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to their sum value. takes no initial value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    Related Procedure Groups

    all_reduce_sum_with_init ¶
    Source

    all_reduce_sum_with_init :: proc(mdarray: MdArray($T, $Nd), initial: $T, location := #caller_location) -> (accum: $T, ok: bool) #optional_ok {…}
     

    Reduce all elements in an array to their sum value. takes an initial value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. initial: the initial value to reduce over. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced final scalar value. ok: an optional boolean for error handling.

    Related Procedure Groups

    any ¶
    Source

    any :: proc(mdarray: MdArray($T=bool, $Nd), location := #caller_location) -> (accum: bool, ok: bool) #optional_ok {…}
     

    Verify that at least one element in a boolean array are set to true.

    Inputs:
    mdarray: a multidimensional boolean array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: a boolean representing that any element is set to true. ok: an optional boolean for error handling.

    atan2_arrays ¶
    Source

    atan2_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise arctan2 operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    atan2_arrays_scalar ¶
    Source

    atan2_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise atan2 operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    atan2_scalar_array ¶
    Source

    atan2_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise atan2 operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_and_arrays ¶
    Source

    bitwise_and_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise and operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_and_arrays_scalar ¶
    Source

    bitwise_and_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise and operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_and_scalar_array ¶
    Source

    bitwise_and_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise and operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_andnot_arrays ¶
    Source

    bitwise_andnot_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise 'and not' operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_andnot_arrays_scalar ¶
    Source

    bitwise_andnot_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise 'and not' operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_andnot_scalar_array ¶
    Source

    bitwise_andnot_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise 'and not' operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_or_arrays ¶
    Source

    bitwise_or_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise or operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_or_arrays_scalar ¶
    Source

    bitwise_or_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise or operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_or_scalar_array ¶
    Source

    bitwise_or_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise or operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_xor_arrays ¶
    Source

    bitwise_xor_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise exclusive or operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_xor_arrays_scalar ¶
    Source

    bitwise_xor_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise exclusive or operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    bitwise_xor_scalar_array ¶
    Source

    bitwise_xor_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise exclusive or operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    broadcast_map ¶
    Source

    broadcast_map :: proc(
	a:         MdArray($T, $Nd), 
	b:         MdArray($T, $Nd), 
	f:         proc($T, $T, .. ..$S) -> $R, 
	.. args:   ..$S, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform custom binary operations on two arrays with broadcastable shapes (e.g. a.shape=(2, 1, 4) and b.shape=(2, 3, 1) => result.shape= (2, 3, 4)). This avoids any intermidate allocations that result from broadcasting arrays a and b before applying the binary operator.

    Inputs:
    a: a multidimensional array broadcastable to the shape of a. b: a multidimensional array broadcastable to the shape of b. f: a binary operator with arguments. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    broadcast_shape ¶
    Source

    broadcast_shape :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), location := #caller_location) -> (result: [0]untyped integer, ok: bool) #optional_ok {…}
     

    reconsile find the broadcasted shape of two copatible arrays. (e.g. a.shape=(2, 1, 4) and b.shape=(2, 3, 1) => result= (2, 3, 4)).

    Inputs:
    a: a multidimensional array broadcastable to the shape of a. b: a multidimensional array broadcastable to the shape of b. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant shape. ok: an optional boolean for error handling.

    broadcast_to ¶
    Source

    broadcast_to :: proc(mdarray: MdArray($T, $Nd), shape: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Broadcasts an array by repeating elements across dimensions of size 1 based on a provided shape value. For instance, this procedure can broadcast an array of shape (2, 1, 4) to (2, 4, 4), by repeating all elements 4 times across the second dimension.

    NOTE: It is possible to broadcast to a shape with higher dimensions, given that the lower dimensions in the provided shape are still compatible (e.g. (2, 4) -> (2, 2, 4)).

    Inputs:
    mdarray: the source multidimensional array. shape: the broadcasted shape. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant broadcasted array. ok: an optional boolean for error handling.

    cast_array ¶
    Source

    cast_array :: proc(source: MdArray($T, $Nd), $to_type: typeid, allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T=typeid, $Nd), ok: bool) #optional_ok {…}
     

    Casts the internal type of the array to a different type.

    Inputs:
    source: the source multidimensional array. to_type: the destination type. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant casted copy. ok: an optional boolean for error handling.

    cflatten ¶
    Source

    cflatten :: flatten_copy
     

    Create a flattened (collapse dimensions into one) copy of an array.

    Inputs:
    Nd: the number of dimensions before the expansion. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant reshaped copy. ok: an optional boolean for error handling.

    compute_strides ¶
    Source

    compute_strides :: proc(shape: [0]untyped integer) -> (strides: [0]untyped integer) {…}

    concat ¶
    Source

    concat :: proc(mdarrays: []MdArray($T, $Nd), axis: untyped integer = 0, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Concatenate several arrays together along a certain axis. All dimensions must be identical except for the dimension along which concatenation occurs.

    Inputs:
    mdarrays: a slice that contains the arrays to concatenate. axis: the axis to concatenate along. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant concatenated array. ok: an optional boolean for error handling.

    copy_array ¶
    Source

    copy_array :: proc(source: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Make a copy of an array.

    Inputs:
    source: the source multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant copy. ok: an optional boolean for error handling.

    cpermute_dims ¶
    Source

    cpermute_dims :: permute_dims_copy
     

    Create a permuted copy of the provided array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant copy. ok: an optional boolean for error handling.

    Related Procedure Groups

    creshape ¶
    Source

    creshape :: reshape_copy
     

    Create a copy of an array with a differnt shape.

    Inputs:
    mdarray: the source multidimensional array. shape: the shape of the destination array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: The resultant reshaped copy. ok: an optional boolean for error handling.

    cswap_axes ¶
    Source

    cswap_axes :: swap_axes_copy
     

    Create a permuted copy of the provided array by swapping two axes.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant copy. ok: an optional boolean for error handling.

    dim_reduce_avg ¶
    Source

    dim_reduce_avg :: proc($Nd := , mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their average value.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    dim_reduce_map ¶
    Source

    dim_reduce_map :: proc(
	$Nd := , 
	mdarray:   MdArray($T, $Nd), 
	axis:      untyped integer, 
	f:         proc($T, $T, .. ..$T) -> $T, 
	initial:   $T, 
	.. args:   ..$T, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension according a custom binary operator.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. f: a binary procedure with arguments. initial: the initial value to reduce over. args: the aguments to be provided to the binary operator f. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the reduced reduced array. ok: an optional boolean for error handling.

    dim_reduce_max ¶
    Source

    dim_reduce_max :: proc($Nd := , mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their maximum value.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    dim_reduce_min ¶
    Source

    dim_reduce_min :: proc($Nd := , mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their minimum value.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    dim_reduce_prod_no_init ¶
    Source

    dim_reduce_prod_no_init :: proc($Nd := , mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their produce. Takes no inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    dim_reduce_prod_with_init ¶
    Source

    dim_reduce_prod_with_init :: proc(
	$Nd := , 
	mdarray:   MdArray($T, $Nd), 
	axis:      untyped integer, 
	initial:   $T, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their sum value. Takes an inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. initial: the initail value to reduce over. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    dim_reduce_sum_no_init ¶
    Source

    dim_reduce_sum_no_init :: proc($Nd := , mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their sum value. Takes no inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    dim_reduce_sum_with_init ¶
    Source

    dim_reduce_sum_with_init :: proc(
	$Nd := , 
	mdarray:   MdArray($T, $Nd), 
	axis:      untyped integer, 
	initial:   $T, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their sum value. Takes an inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. initial: the initail value to reduce over. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    div_arrays ¶
    Source

    div_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise division operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    div_arrays_scalar ¶
    Source

    div_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise division operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    div_scalar_array ¶
    Source

    div_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise division operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    element_wise_map ¶
    Source

    element_wise_map :: proc(
	a:              MdArray($T, $Nd), 
	b:              MdArray($T, $Nd), 
	f:              proc($T, $T, .. ..$S) -> $R, 
	.. args:        ..$S, 
	allocator := context.allocator, 
	location := #caller_location, 
	force_threaded: bool = false, 
) -> (result: MdArray($T, $Nd), ok: bool) {…}
     

    Perform a custom element-wise binary operation on two different arrays.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. f: a binary procedure with arguments. args: arguments to be passed to the passed procedure. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure. force_threaded(experimental): force this procedure to use threading, it will be ignored if the size of the arrays is smaller than the number of configured threads.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    eprint ¶
    Source

    eprint :: proc(mdarray: MdArray($T, $Nd)) {…}

    eprintln ¶
    Source

    eprintln :: proc(mdarray: MdArray($T, $Nd)) {…}

    equal_arrays ¶
    Source

    equal_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise equal operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    equal_arrays_scalar ¶
    Source

    equal_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise equal operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    equal_scalar_array ¶
    Source

    equal_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise equal operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    expand_dim_copy ¶
    Source

    expand_dim_copy :: proc($Nd := , mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a view of an array with an additional dimension. The dimension is specified based on the axis value.

    Inputs:
    Nd: the number of dimensions before the expansion. mdarray: the source multidimensional array. axis: the position in the shape, where the additional dimension is placed. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant reshaped copy. ok: an optional boolean for error handling.

    expand_dim_view ¶
    Source

    expand_dim_view :: proc($Nd := , mdarray: MdArray($T, $Nd), axis: untyped integer, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a view of an array with an additional dimension. The dimension is specified based on the axis value.

    Inputs:
    Nd: the number of dimensions before the expansion. mdarray: the source multidimensional array. axis: the position in the shape, where the additional dimension is placed. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: The resultant reshaped view. ok: an optional boolean for error handling.

    extract_linear_array ¶
    Source

    extract_linear_array :: proc(mdarray: MdArray($T, $Nd), result: []$T, idx: untyped integer, axis: untyped integer, location := #caller_location) -> (ok: bool) {…}
     

    Extract a contingent slice a long a certain axis based on the argument "idx" which indexes the elements of the axis dimension.

    Inputs:
    mdarray: a multidimensional array. result: the output slice to copy values to. idx: the index of the axis dimension sigments. axis: the selected axis dimension. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    eye ¶
    Source

    eye :: proc(
	$T:         typeid, 
	n_rows:    u64, 
	n_cols:    u64 = 0, 
	diag_idx:  untyped integer = 0, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (mdarray: MdArray($T=typeid, $Nd=2), ok: bool) #optional_ok {…}
     

    Create a matrix(an array with two dimensions) with ones at its diagonal and zeros otherwise. the position of the diagonal can be shifted based on the value of diag_idx (supports negative values).

    Inputs:
    T: the type of created array. n_rows: number of rows. n_cols: number of columns. diag_idx: position of the diagonal line. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant eye matrix. ok: an optional boolean for error handling.

    fills ¶
    Source

    fills :: proc(value: $T, shape: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a multi-dimensional array based on the provided shape, whose elements are filled with the provided value.

    NOTE: the internal type of the array corresponds to the type of the provided value.

    Inputs:
    value: the value based on which the array will be filled shape: the shape of the multi-dimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: a multidimsional array filled with the provided value. ok: an optional boolean for error handling.

    fills_like ¶
    Source

    fills_like :: proc(value: $T, source: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a multi-dimensional array with an identical shape to another array, whose elements are filled with the provided value.

    Inputs:
    value: the value based on which the array will be filled source: the array based on which the shape of the created array is decided. Its internal type doesn't matter. The created array will follow the type of the provided value instead. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: a multidimsional array filled with the provided value. ok: an optional boolean for error handling.

    flatten_copy ¶
    Source

    flatten_copy :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd=1), ok: bool) #optional_ok {…}
     

    Create a flattened (collapse dimensions into one) copy of an array.

    Inputs:
    Nd: the number of dimensions before the expansion. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant reshaped copy. ok: an optional boolean for error handling.

    flatten_view ¶
    Source

    flatten_view :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (result: MdArray($T, $Nd=1), ok: bool) #optional_ok {…}
     

    Create a flattened (collapse dimensions into one) view of an array.

    Inputs:
    Nd: the number of dimensions before the expansion. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant reshaped view. ok: an optional boolean for error handling.

    fprint ¶
    Source

    fprint :: proc(handle: os.Handle, mdarray: MdArray($T, $Nd)) {…}

    fprintln ¶
    Source

    fprintln :: proc(handle: os.Handle, mdarray: MdArray($T, $Nd)) {…}

    free_mdarray ¶
    Source

    free_mdarray :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> runtime.Allocator_Error {…}
     

    Frees the internal memory of the array. The provided array will become empty. You sould no longer use a freed array.

    NOTE: This procedure will skip a view array. A warning will be logged as a reminder.

    Inputs:
    mdarray: a multidimsional array of any internal type. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    allocation error value. .None implies that no error has occured.

    from_range ¶
    Source

    from_range :: proc(
	$T:         typeid, 
	end:       untyped integer, 
	begin:     untyped integer = 0, 
	step:      untyped integer = 1, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (mdarray: MdArray($T=typeid, $Nd=1), ok: bool) #optional_ok {…}
     

    Create a vector(an array with one dimension), based on range specified by the begin, step and end values provided.

    Inputs:
    T: the type of created array. end: the last value in the range (non-exclusive). begin: the first value in the range. step: the size of the step taken between values within the range. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant range vector. ok: an optional boolean for error handling.

    from_slice ¶
    Source

    from_slice :: proc(sl: []$T, shape: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a multi-dimensional array from an Odin slice. The size of the array and the shape provided have to be compatible. In other words the total size of the array should be equal to the multiple of all dimensions in the shape.

    NOTE: this procedure will create a copy of the provided slice. It does not create a view.

    Inputs:
    sl: the slice from which the array will be created. shape: the shape of the multi-dimensional array. Must be compatible with the size of the slice. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: a multidimsional array with same type as the provided slice. ok: an optional boolean for error handling.

    gcd_arrays ¶
    Source

    gcd_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greatest common denominator operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    gcd_arrays_scalar ¶
    Source

    gcd_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greatest common denominator operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    gcd_scalar_array ¶
    Source

    gcd_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greatest common denominator operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    get ¶
    Source

    get :: proc(mdarray: MdArray($T, $Nd), pos: [0]untyped integer, location := #caller_location) -> (val: $T, ok: bool) #optional_ok {…}
     

    get a copy to the element at provided position.

    Inputs:
    mdarray: a multidimensional array. pos: the position at which the element is placed. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    val: a copy to the selected element. ok: an optional boolean for error handling.

    get_default_tol ¶
    Source

    get_default_tol :: proc "contextless" ($T: typeid) -> (rtol, atol: f64, ok: bool) {…}
     

    Get the default tolerance values set by Nuod

    Inputs:
    T: first multidimensional array.

    Returns:
    rtol: the default relative tolerance. atol: the default absolute tolerance. ok: an optional boolean for error handling.

    get_linear ¶
    Source

    get_linear :: proc(mdarray: MdArray($T, $Nd), idx: untyped integer, location := #caller_location) -> (val: $T) {…}
     

    get a copy to the element at the linear index.

    Inputs:
    mdarray: a multidimensional array. idx: the linear index of an element. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    val: a copy to the selected element.

    get_linear_ref ¶
    Source

    get_linear_ref :: proc(mdarray: MdArray($T, $Nd), idx: untyped integer, location := #caller_location) -> (val: ^$T) {…}
     

    get a reference to the element at the linear index.

    Inputs:
    mdarray: a multidimensional array. idx: the linear index of an element. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    val: a reference to the selected element.

    get_reduced_pos ¶
    Source

    get_reduced_pos :: proc(shape: [0]untyped integer, idx: untyped integer, axis: untyped integer) -> (pos: [0]untyped integer) {…}
     

    Reduce a one of the dimensions in the provided arrays to 1 and find the corresponding position, based on a linear index.

    Inputs:
    shape: shape to reduce. idx: the linear buffer index. axis: the dimension to be reduced.

    Returns:
    pos: computed position.

    get_ref ¶
    Source

    get_ref :: proc(mdarray: MdArray($T, $Nd), pos: [0]untyped integer, location := #caller_location) -> (val: ^$T, ok: bool) #optional_ok {…}
     

    get a reference to the element at provided position.

    Inputs:
    mdarray: a multidimensional array. pos: the position at which the element is placed. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    val: a reference to the selected element. ok: an optional boolean for error handling.

    get_type ¶
    Source

    get_type :: proc(mdarray: MdArray($T, $Nd)) -> typeid {…}
     

    Retrives the internal type of the array.

    Inputs:
    mdarray: a multidimsional array of any internal type.

    Returns:
    the array's internal type.

    greater_arrays ¶
    Source

    greater_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greater than operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    greater_arrays_scalar ¶
    Source

    greater_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greater than operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    greater_equal_arrays ¶
    Source

    greater_equal_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greater than or equal operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    greater_equal_arrays_scalar ¶
    Source

    greater_equal_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greater than or equal operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    greater_equal_scalar_array ¶
    Source

    greater_equal_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greater than or equal operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    greater_scalar_array ¶
    Source

    greater_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise greater than operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    heaviside_arrays ¶
    Source

    heaviside_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise Heaviside step operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    heaviside_arrays_scalar ¶
    Source

    heaviside_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise Heaviside step operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    heaviside_scalar_array ¶
    Source

    heaviside_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise Heaviside step operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    hstack ¶
    Source

    hstack :: proc(mdarrays: []MdArray($T, $Nd=1), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd=1), ok: bool) #optional_ok {…}
     

    Stack several vector arrays horizontally.

    Inputs:
    mdarrays: a slice that contains the arrays to stack. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant stack array. ok: an optional boolean for error handling.

    hypot_arrays ¶
    Source

    hypot_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the element-wise hypotenuse operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    hypot_arrays_scalar ¶
    Source

    hypot_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the element-wise hypotenuse operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    hypot_scalar_array ¶
    Source

    hypot_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Find the element-wise hypotenuse operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    i_abs ¶
    Source

    i_abs :: inplace_abs
     

    Apply the absolute operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_acos ¶
    Source

    i_acos :: inplace_acos
     

    Apply the arccosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_acosh ¶
    Source

    i_acosh :: inplace_acosh
     

    Apply the hyperpolic arccosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_asin ¶
    Source

    i_asin :: inplace_asin
     

    Apply the arcsine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_asinh ¶
    Source

    i_asinh :: inplace_asinh
     

    Apply the hyperpolic arcsine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_atan ¶
    Source

    i_atan :: inplace_atan
     

    Apply the arctan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_atanh ¶
    Source

    i_atanh :: inplace_atanh
     

    Apply the hyperpolic arctan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_bitwise_comp ¶
    Source

    i_bitwise_comp :: inplace_bitwise_comp
     

    Apply the bitwise complement operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_cbrt ¶
    Source

    i_cbrt :: inplace_cbrt
     

    Apply the cube root operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_conj ¶
    Source

    i_conj :: inplace_conj
     

    Apply the conjugate operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_cos ¶
    Source

    i_cos :: inplace_cos
     

    Apply the cosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_cosh ¶
    Source

    i_cosh :: inplace_cosh
     

    Apply the hyperpolic cosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_deg2rad ¶
    Source

    i_deg2rad :: inplace_radians
     

    Convert all elements in the array from degrees to radian in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_degrees ¶
    Source

    i_degrees :: inplace_degrees
     

    Convert all elements in the array from radian to degress in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_degs ¶
    Source

    i_degs :: inplace_degrees
     

    Convert all elements in the array from radian to degress in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_exp ¶
    Source

    i_exp :: inplace_exp
     

    Apply the exponential operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_exp2 ¶
    Source

    i_exp2 :: inplace_exp2
     

    Apply the exponential operator (base of 2) to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_ln ¶
    Source

    i_ln :: inplace_ln
     

    Apply the natural logarithm operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_log10 ¶
    Source

    i_log10 :: inplace_log10
     

    Apply the logarithm operator (base of 10) to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_log1p ¶
    Source

    i_log1p :: inplace_log1p
     

    Apply the natural logarithm operator with one plus to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_log2 ¶
    Source

    i_log2 :: inplace_log2
     

    Apply the logarithm operator (base of 2) to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_neg ¶
    Source

    i_neg :: inplace_neg
     

    Apply the negating operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_rad2deg ¶
    Source

    i_rad2deg :: inplace_degrees
     

    Convert all elements in the array from radian to degress in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_radians ¶
    Source

    i_radians :: inplace_radians
     

    Convert all elements in the array from degrees to radian in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_rads ¶
    Source

    i_rads :: inplace_radians
     

    Convert all elements in the array from degrees to radian in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_reciprocal ¶
    Source

    i_reciprocal :: inplace_reciprocal
     

    Apply the reciprocal operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_sign ¶
    Source

    i_sign :: inplace_sign
     

    Apply the sign operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_sin ¶
    Source

    i_sin :: inplace_sin
     

    Apply the sine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_sinc ¶
    Source

    i_sinc :: inplace_sinc
     

    Apply the sine cardinal operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_sinh ¶
    Source

    i_sinh :: inplace_sinh
     

    Apply the hyperpolic sine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_sq ¶
    Source

    i_sq :: inplace_sq
     

    Apply the square operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_sqrt ¶
    Source

    i_sqrt :: inplace_sqrt
     

    Apply the square root operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_tan ¶
    Source

    i_tan :: inplace_tan
     

    Apply the tan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    i_tanh ¶
    Source

    i_tanh :: inplace_tanh
     

    Apply the hyperpolic tan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    identity ¶
    Source

    identity :: proc($T: typeid, n: u64, allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T=typeid, $Nd=2), ok: bool) #optional_ok {…}
     

    Create a square identity matrix(an array with two dimensions).

    Inputs:
    T: the type of created array. n: the number of rows or columns in the matrix. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant identity matrix. ok: an optional boolean for error handling.

    inplace_abs ¶
    Source

    inplace_abs :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the absolute operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_acos ¶
    Source

    inplace_acos :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the arccosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_acosh ¶
    Source

    inplace_acosh :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the hyperpolic arccosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_asin ¶
    Source

    inplace_asin :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the arcsine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_asinh ¶
    Source

    inplace_asinh :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the hyperpolic arcsine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_atan ¶
    Source

    inplace_atan :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the arctan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_atanh ¶
    Source

    inplace_atanh :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the hyperpolic arctan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_bitwise_comp ¶
    Source

    inplace_bitwise_comp :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the bitwise complement operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_cbrt ¶
    Source

    inplace_cbrt :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the cube root operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_conj ¶
    Source

    inplace_conj :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the conjugate operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_cos ¶
    Source

    inplace_cos :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the cosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_cosh ¶
    Source

    inplace_cosh :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the hyperpolic cosine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_degrees ¶
    Source

    inplace_degrees :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Convert all elements in the array from radian to degress in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_exp ¶
    Source

    inplace_exp :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the exponential operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_exp2 ¶
    Source

    inplace_exp2 :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the exponential operator (base of 2) to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_ln ¶
    Source

    inplace_ln :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the natural logarithm operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_log10 ¶
    Source

    inplace_log10 :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the logarithm operator (base of 10) to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_log1p ¶
    Source

    inplace_log1p :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the natural logarithm operator with one plus to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_log2 ¶
    Source

    inplace_log2 :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the logarithm operator (base of 2) to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_neg ¶
    Source

    inplace_neg :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the negating operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_radians ¶
    Source

    inplace_radians :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Convert all elements in the array from degrees to radian in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_reciprocal ¶
    Source

    inplace_reciprocal :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the reciprocal operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_sign ¶
    Source

    inplace_sign :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the sign operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_sin ¶
    Source

    inplace_sin :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the sine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_sinc ¶
    Source

    inplace_sinc :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the sine cardinal operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_sinh ¶
    Source

    inplace_sinh :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the hyperpolic sine operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_sq ¶
    Source

    inplace_sq :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the square operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_sqrt ¶
    Source

    inplace_sqrt :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the square root operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_tan ¶
    Source

    inplace_tan :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the tan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_tanh ¶
    Source

    inplace_tanh :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (ok: bool) {…}
     

    Apply the hyperpolic tan operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    inplace_unary_map ¶
    Source

    inplace_unary_map :: proc(mdarray: MdArray($T, $Nd), f: proc(^$T), location := #caller_location, force_threaded: bool = false) -> (ok: bool) {…}
     

    Apply a custom unary operator to all elements in the array in place.

    Inputs:
    mdarray: a multidimensional array. f: a unary procedure. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    is_close_default ¶
    Source

    is_close_default :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Verify in an element-wise manner that the elements in two different arrays are close to each other based on the defualt tolerances.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    is_close_with_args ¶
    Source

    is_close_with_args :: proc(
	a:         MdArray($T, $Nd), 
	b:         MdArray($T, $Nd), 
	rtol:      f64, 
	atol:      f64, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Verify in an element-wise manner that the elements in two different arrays are close to each other based on custom tolerance values provided by the user.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. rtol: the relative tolerance. atol: the absolute tolerance. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    is_empty ¶
    Source

    is_empty :: is_none

    is_none ¶
    Source

    is_none :: proc(mdarray: MdArray($T, $Nd)) -> bool {…}

    keepdim_reduce_avg ¶
    Source

    keepdim_reduce_avg :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their average value while keeping the dimension.

    Inputs:
    mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    keepdim_reduce_map ¶
    Source

    keepdim_reduce_map :: proc(
	$Nd := , 
	mdarray:   MdArray($T, $Nd), 
	axis:      untyped integer, 
	f:         proc($T, $T, .. ..$T) -> $T, 
	initial:   $T, 
	.. args:   ..$T, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension according a custom binary operator. Insures the reduce dimension is not discarded.

    Inputs:
    Nd: the inital number of dimension for the provided array. mdarray: a multidimensional array. axis: the axis along which reduction occurs. f: a binary procedure with arguments. initial: the initial value to reduce over. args: the aguments to be provided to the binary operator f. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the reduced reduced array. ok: an optional boolean for error handling.

    keepdim_reduce_max ¶
    Source

    keepdim_reduce_max :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their maximum value while keeping the dimension.

    Inputs:
    mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    keepdim_reduce_min ¶
    Source

    keepdim_reduce_min :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their minimum value while keeping the dimension.

    Inputs:
    mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    keepdim_reduce_prod_no_init ¶
    Source

    keepdim_reduce_prod_no_init :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their produce while keeping the dimension. Takes no inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    keepdim_reduce_prod_with_init ¶
    Source

    keepdim_reduce_prod_with_init :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, initial: $T, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their product while keeping the dimension. Takes an inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. axis: the axis along which reduction occurs. initial: the initial value to reduce over. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the reduced reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    keepdim_reduce_sum_no_init ¶
    Source

    keepdim_reduce_sum_no_init :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their sum while keeping the dimension. Takes no inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. axis: the axis along which reduction occurs. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    accum: the reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    keepdim_reduce_sum_with_init ¶
    Source

    keepdim_reduce_sum_with_init :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, initial: $T, allocator := context.allocator, location := #caller_location) -> (accum: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Reduce all elements along a certain dimension to their sum while keeping the dimension. Takes an inital value.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    mdarray: a multidimensional array. axis: the axis along which reduction occurs. initial: the initial value to reduce over. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the reduced reduced array. ok: an optional boolean for error handling.

    Related Procedure Groups

    lcm_arrays ¶
    Source

    lcm_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise least common multiple operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    lcm_arrays_scalar ¶
    Source

    lcm_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise least common multiple operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    lcm_scalar_array ¶
    Source

    lcm_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise least common multiple operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    left_shift_arrays ¶
    Source

    left_shift_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise left shift operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    left_shift_arrays_scalar ¶
    Source

    left_shift_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise left shift operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    left_shift_scalar_array ¶
    Source

    left_shift_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise left shift operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    less_arrays ¶
    Source

    less_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise less than operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    less_arrays_scalar ¶
    Source

    less_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise less than operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    less_equal_arrays ¶
    Source

    less_equal_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise less than or equal operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    less_equal_arrays_scalar ¶
    Source

    less_equal_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise less than or equal operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    less_equal_scalar_array ¶
    Source

    less_equal_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise less than or equal operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    less_scalar_array ¶
    Source

    less_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise less than operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    linspace ¶
    Source

    linspace :: proc(
	$T:         typeid, 
	begin:     typeid, 
	end:       typeid, 
	n:         untyped integer, 
	endpoint:  bool = true, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (mdarray: MdArray($T=typeid, $Nd=1), ok: bool) #optional_ok {…}
     

    Create a vector(an array with one dimension) that hosts a linear space of size n.

    NOTE: this procedure is restricted to only float and complex values.

    Inputs:
    T: the type of created array. begin: the first value in the space. end: the last value in the space. n: the size fo the linear space. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant vector array. ok: an optional boolean for error handling.

    logaddexp_arrays ¶
    Source

    logaddexp_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logarithmic sum of exponentials operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logaddexp_arrays_scalar ¶
    Source

    logaddexp_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logarithmic sum of exponentials operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logaddexp_scalar_array ¶
    Source

    logaddexp_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logarithmic sum of exponentials operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logical_and_arrays ¶
    Source

    logical_and_arrays :: proc(a: MdArray($T=bool, $Nd), b: MdArray($T=bool, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logical and operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logical_and_arrays_scalar ¶
    Source

    logical_and_arrays_scalar :: proc(a: MdArray($T=bool, $Nd), b: bool, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logical and operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logical_and_scalar_array ¶
    Source

    logical_and_scalar_array :: proc(a: bool, b: MdArray($T=bool, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logical and operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logical_or_arrays ¶
    Source

    logical_or_arrays :: proc(a: MdArray($T=bool, $Nd), b: MdArray($T=bool, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logical or operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logical_or_arrays_scalar ¶
    Source

    logical_or_arrays_scalar :: proc(a: MdArray($T=bool, $Nd), b: bool, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logical or operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logical_or_scalar_array ¶
    Source

    logical_or_scalar_array :: proc(a: bool, b: MdArray($T=bool, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise logical or operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    logspace ¶
    Source

    logspace :: proc(
	$T:         typeid, 
	begin:     typeid, 
	end:       typeid, 
	n:         untyped integer, 
	base:      f64 = 10.0, 
	endpoint:  bool = true, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (mdarray: MdArray($T=typeid, $Nd=1), ok: bool) #optional_ok {…}
     

    Create a vector(an array with one dimension) that hosts a logrithmic space of size n.

    NOTE: this procedure is restricted to only float values.

    Inputs:
    T: the type of created array. begin: the first value in the space. end: the last value in the space. n: the size fo the linear space. base: base of logirthmic space (defaults to 10) allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant vector array. ok: an optional boolean for error handling.

    make_mdarray ¶
    Source

    make_mdarray :: proc($T: typeid, shape: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T=typeid, $Nd), ok: bool) #optional_ok {…}
     

    Properly creates an instance of a multi-dimensional array based on the provided type and shape. The values are not assigned and will therefore follow the zero-value of the provided type.

    Inputs:
    T: the type of the array to be created. shape: an Odin array that holds the shape of the created multi-dimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The created multi-dimensional array. ok: an optional boolean for error handling.

    max_arrays ¶
    Source

    max_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise maximum operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    max_arrays_scalar ¶
    Source

    max_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise maximum operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    max_scalar_array ¶
    Source

    max_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise maximum operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    min_arrays ¶
    Source

    min_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise minimum operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    min_arrays_scalar ¶
    Source

    min_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise minimum operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    min_scalar_array ¶
    Source

    min_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise minimum operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    mod_arrays ¶
    Source

    mod_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise modulus operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    mod_arrays_scalar ¶
    Source

    mod_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise modulus operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    mod_scalar_array ¶
    Source

    mod_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise modulus operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    mul_arrays ¶
    Source

    mul_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise multiplication operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    mul_arrays_scalar ¶
    Source

    mul_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise multiplication operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    mul_scalar_array ¶
    Source

    mul_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise multiplication operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    narrow ¶
    Source

    narrow :: proc(mdarray: MdArray($T, $Nd), axis: untyped integer, begin: untyped integer = 0, end: untyped integer = -1, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    find a narrow view of an array by reducing the size of a specific dimension.

    Inputs:
    mdarray: a multidimensional array. axis: the axis dimension to narrow along. begin: the start of the narrowed view. end: the end of the narrowed view. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant view. ok: an optional boolean for error handling.

    ndim ¶
    Source

    ndim :: proc(mdarray: MdArray($T, $Nd)) -> untyped integer {…}
     

    Retrives the number of dimensions of the array.

    Inputs:
    mdarray: a multidimsional array of any internal type.

    Returns:
    number of dimensions.

    not_equal_arrays ¶
    Source

    not_equal_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise not equal operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    not_equal_arrays_scalar ¶
    Source

    not_equal_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise not equal operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    not_equal_scalar_array ¶
    Source

    not_equal_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T=bool, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise not equal operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    o_abs ¶
    Source

    o_abs :: outplace_abs
     

    Apply the absolute operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_acos ¶
    Source

    o_acos :: outplace_acos
     

    Apply the arccosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_acosh ¶
    Source

    o_acosh :: outplace_acosh
     

    Apply the hyperpolic arccosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_asin ¶
    Source

    o_asin :: outplace_asin
     

    Apply the arcsine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_asinh ¶
    Source

    o_asinh :: outplace_asinh
     

    Apply the hyperpolic arcsine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_atan ¶
    Source

    o_atan :: outplace_atan
     

    Apply the arctan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_atanh ¶
    Source

    o_atanh :: outplace_atanh
     

    Apply the hyperpolic arctan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_bitwise_comp ¶
    Source

    o_bitwise_comp :: outplace_bitwise_comp
     

    Apply the bitwise complement operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_cbrt ¶
    Source

    o_cbrt :: outplace_cbrt
     

    Apply the cube root operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_conj ¶
    Source

    o_conj :: outplace_conj
     

    Apply the conjugate operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_cos ¶
    Source

    o_cos :: outplace_cos
     

    Apply the cosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_cosh ¶
    Source

    o_cosh :: outplace_cosh
     

    Apply the hyperpolic cosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_deg2rad ¶
    Source

    o_deg2rad :: outplace_radians
     

    Convert all elements in the array from degrees to radian out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_degrees ¶
    Source

    o_degrees :: outplace_degrees
     

    Convert all elements in the array from radian to degress out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_degs ¶
    Source

    o_degs :: outplace_degrees
     

    Convert all elements in the array from radian to degress out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_exp ¶
    Source

    o_exp :: outplace_exp
     

    Apply the exponential operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_exp2 ¶
    Source

    o_exp2 :: outplace_exp2
     

    Apply the exponential operator (base of 2) to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_ln ¶
    Source

    o_ln :: outplace_ln
     

    Apply the natural logarithm operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_log10 ¶
    Source

    o_log10 :: outplace_log10
     

    Apply the logarithm operator (base of 10) to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_log1p ¶
    Source

    o_log1p :: outplace_log1p
     

    Apply the natural logarithm operator with one plus to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_log2 ¶
    Source

    o_log2 :: outplace_log2
     

    Apply the logarithm operator (base of 2) to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_neg ¶
    Source

    o_neg :: outplace_neg
     

    Apply the negating operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_rad2deg ¶
    Source

    o_rad2deg :: outplace_degrees
     

    Convert all elements in the array from radian to degress out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_radians ¶
    Source

    o_radians :: outplace_radians
     

    Convert all elements in the array from degrees to radian out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_rads ¶
    Source

    o_rads :: outplace_radians
     

    Convert all elements in the array from degrees to radian out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_reciprocal ¶
    Source

    o_reciprocal :: outplace_reciprocal
     

    Apply the reciprocal operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_sign ¶
    Source

    o_sign :: outplace_sign
     

    Apply the sign operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_sin ¶
    Source

    o_sin :: outplace_sin
     

    Apply the sine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_sinc ¶
    Source

    o_sinc :: outplace_sinc
     

    Apply the sine cardinal operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_sinh ¶
    Source

    o_sinh :: outplace_sinh
     

    Apply the hyperpolic sine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_sq ¶
    Source

    o_sq :: outplace_sq
     

    Apply the square operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_sqrt ¶
    Source

    o_sqrt :: outplace_sqrt
     

    Apply the square root operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_tan ¶
    Source

    o_tan :: outplace_tan
     

    Apply the tan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    o_tanh ¶
    Source

    o_tanh :: outplace_tanh
     

    Apply the hyperpolic tan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    ones ¶
    Source

    ones :: proc($T: typeid, shape: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T=typeid, $Nd), ok: bool) #optional_ok {…}
     

    Create a multi-dimensional array based on the provided shape, whose elements are all ones.

    Inputs:
    T: the type of created array. shape: the shape of the multi-dimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: a multidimsional array filled with ones. ok: an optional boolean for error handling.

    ones_like ¶
    Source

    ones_like :: proc($T: typeid, source: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T=typeid, $Nd), ok: bool) #optional_ok {…}
     

    Create a multi-dimensional array with an identical shape to another array, whose elements are all with ones.

    Inputs:
    T: the type of created array. source: the array based on which the shape of the created array is decided. Its internal type doesn't matter. The created array will follow the type above. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: a multidimsional array filled with ones. ok: an optional boolean for error handling.

    outplace_abs ¶
    Source

    outplace_abs :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the absolute operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_acos ¶
    Source

    outplace_acos :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the arccosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_acosh ¶
    Source

    outplace_acosh :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the hyperpolic arccosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_asin ¶
    Source

    outplace_asin :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the arcsine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_asinh ¶
    Source

    outplace_asinh :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the hyperpolic arcsine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_atan ¶
    Source

    outplace_atan :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the arctan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_atanh ¶
    Source

    outplace_atanh :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the hyperpolic arctan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_bitwise_comp ¶
    Source

    outplace_bitwise_comp :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the bitwise complement operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_cbrt ¶
    Source

    outplace_cbrt :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the cube root operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_conj ¶
    Source

    outplace_conj :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the conjugate operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_cos ¶
    Source

    outplace_cos :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the cosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_cosh ¶
    Source

    outplace_cosh :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the hyperpolic cosine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_degrees ¶
    Source

    outplace_degrees :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Convert all elements in the array from radian to degress out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_exp ¶
    Source

    outplace_exp :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the exponential operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_exp2 ¶
    Source

    outplace_exp2 :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the exponential operator (base of 2) to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_ln ¶
    Source

    outplace_ln :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the natural logarithm operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_log10 ¶
    Source

    outplace_log10 :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the logarithm operator (base of 10) to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_log1p ¶
    Source

    outplace_log1p :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the natural logarithm operator with one plus to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_log2 ¶
    Source

    outplace_log2 :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the logarithm operator (base of 2) to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_neg ¶
    Source

    outplace_neg :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the negating operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_radians ¶
    Source

    outplace_radians :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Convert all elements in the array from degrees to radian out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_reciprocal ¶
    Source

    outplace_reciprocal :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the reciprocal operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_sign ¶
    Source

    outplace_sign :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the sign operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_sin ¶
    Source

    outplace_sin :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the sine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_sinc ¶
    Source

    outplace_sinc :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the sine cardinal operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_sinh ¶
    Source

    outplace_sinh :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the hyperpolic sine operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_sq ¶
    Source

    outplace_sq :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the square operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_sqrt ¶
    Source

    outplace_sqrt :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the square root operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_tan ¶
    Source

    outplace_tan :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the tan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_tanh ¶
    Source

    outplace_tanh :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply the hyperpolic tan operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    outplace_unary_map ¶
    Source

    outplace_unary_map :: proc(mdarray: MdArray($T, $Nd), f: proc(^$T), allocator := context.allocator, location := #caller_location, force_threaded: bool = false) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Apply a custom unary operator to all elements in the array out of place.

    Inputs:
    mdarray: a multidimensional array. f: a unary procedure. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    permute_default_copy ¶
    Source

    permute_default_copy :: proc(mdarray: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a permuted copy of the provided array. This will use the default permutation of reversing the order of the dimensions.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant copy. ok: an optional boolean for error handling.

    Related Procedure Groups

    permute_default_view ¶
    Source

    permute_default_view :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a permuted view of the provided array. This will use the default permutation of reversing the order of the dimensions.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant view. ok: an optional boolean for error handling.

    Related Procedure Groups

    permute_dims_copy ¶
    Source

    permute_dims_copy :: proc(mdarray: MdArray($T, $Nd), indices: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a permuted copy of the provided array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant copy. ok: an optional boolean for error handling.

    Related Procedure Groups

    permute_dims_view ¶
    Source

    permute_dims_view :: proc(mdarray: MdArray($T, $Nd), indices: [0]untyped integer, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a permuted view of the provided array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant view. ok: an optional boolean for error handling.

    Related Procedure Groups

    placein_linear_array ¶
    Source

    placein_linear_array :: proc(mdarray: MdArray($T, $Nd), arr: []$T, idx: untyped integer, axis: untyped integer, location := #caller_location) -> (ok: bool) {…}
     

    place a contingent slice a long a certain axis based on the argument "idx" which indexes the elements of the axis dimension.

    Inputs:
    mdarray: a multidimensional array. arr: the input slice to place a copy of into mdarray. idx: the index of the axis dimension sigments. axis: the selected axis dimension. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    ok: an optional boolean for error handling.

    print ¶
    Source

    print :: proc(mdarray: MdArray($T, $Nd)) {…}

    println ¶
    Source

    println :: proc(mdarray: MdArray($T, $Nd)) {…}

    ravel ¶
    Source

    ravel :: proc(mdarray: MdArray($T, $Nd)) -> []$T {…}

    reshape_copy ¶
    Source

    reshape_copy :: proc(mdarray: MdArray($T, $Nd), shape: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a copy of an array with a differnt shape.

    Inputs:
    mdarray: the source multidimensional array. shape: the shape of the destination array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: The resultant reshaped copy. ok: an optional boolean for error handling.

    reshape_view ¶
    Source

    reshape_view :: proc(mdarray: MdArray($T, $Nd), shape: [0]untyped integer, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a view of an array with a differnt shape.

    Inputs:
    mdarray: the source multidimensional array. shape: the shape of the destination array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: The resultant reshaped view. ok: an optional boolean for error handling.

    reshaped_range ¶
    Source

    reshaped_range :: proc(
	$T:         typeid, 
	shape:     [0]untyped integer, 
	begin:     untyped integer = 0, 
	step:      untyped integer = 1, 
	allocator := context.allocator, 
	location := #caller_location, 
) -> (mdarray: MdArray($T=typeid, $Nd), ok: bool) #optional_ok {…}
     

    Create a multidimensional array reshaped from a range of values specified by the begin and step values provided.

    NOTE: the end value is unnecessary in this function, since it is inferred from the shape.

    Inputs:
    T: the type of created array. shape: the shape of the resultant array. begin: the first value in the range. step: the size of the step taken between values within the range. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: The resultant multidimensional array. ok: an optional boolean for error handling.

    right_shift_arrays ¶
    Source

    right_shift_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise right shift operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    right_shift_arrays_scalar ¶
    Source

    right_shift_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise right shift operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    right_shift_scalar_array ¶
    Source

    right_shift_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise bitwise right shift operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    scalar_map ¶
    Source

    scalar_map :: proc(
	a:              MdArray($T, $Nd), 
	b:              $T, 
	f:              proc($T, $T, .. ..$S) -> $R, 
	.. args:        ..$S, 
	flip:           bool = false, 
	allocator := context.allocator, 
	location := #caller_location, 
	force_threaded: bool = false, 
) -> (result: MdArray($T, $Nd), ok: bool) {…}
     

    Perform a custom element-wise binary operation on an arrays and a scalar.

    Inputs:
    a: a multidimensional array. b: a scalar value. f: a binary procedure with arguments. args: arguments to be passed to the passed procedure. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure. force_threaded(experimental): force this procedure to use threading, it will be ignored if the size of the arrays is smaller than the number of configured threads.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    size ¶
    Source

    size :: proc(mdarray: MdArray($T, $Nd)) -> untyped integer {…}
     

    Retrives the total number of elements in the array. If the array is a view, it will only retrive the number of viewed elements only.

    Inputs:
    mdarray: a multidimsional array of any internal type.

    Returns:
    number of elements.

    slice_view ¶
    Source

    slice_view :: proc($Nd := , mdarray: MdArray($T, $Nd), index: untyped integer, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a view of a singular subarray base on the index of the first dimension.

    Inputs:
    mdarray: a multidimensional array. axis: the axis dimension to narrow along. begin: the start of the narrowed view. end: the end of the narrowed view. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant view. ok: an optional boolean for error handling.

    stack ¶
    Source

    stack :: proc($Nd := , mdarrays: []MdArray($T, $Nd), axis: untyped integer = 0, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Stack several arrays of similar dimensions along a certain axis/dimension.

    Inputs:
    Nd: the number of dimensions of the original arrays. mdarrays: a slice that contains the arrays to stack. axis: the axis along with the arrays are stacked. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant stack array. ok: an optional boolean for error handling.

    subtract_arrays ¶
    Source

    subtract_arrays :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise subtraction operation on two different arrays.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: first multidimensional array. b: second multidimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    subtract_arrays_scalar ¶
    Source

    subtract_arrays_scalar :: proc(a: MdArray($T, $Nd), b: $T, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise subtraction operation on an arrays and a scalar.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    subtract_scalar_array ¶
    Source

    subtract_scalar_array :: proc(a: $T, b: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Perform an element-wise subtraction operation on a scalar and an array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    a: a multidimensional array. b: a scalar value. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant array. ok: an optional boolean for error handling.

    Related Procedure Groups

    swap ¶
    Source

    swap :: proc(a: ^$T, b: ^$S) {…}

    swap_axes_copy ¶
    Source

    swap_axes_copy :: proc(mdarray: MdArray($T, $Nd), axis1: untyped integer, axis2: untyped integer, allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a permuted copy of the provided array by swapping two axes.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant copy. ok: an optional boolean for error handling.

    swap_axes_view ¶
    Source

    swap_axes_view :: proc(mdarray: MdArray($T, $Nd), axis1: untyped integer, axis2: untyped integer, location := #caller_location) -> (result: MdArray($T, $Nd), ok: bool) #optional_ok {…}
     

    Create a permuted view of the provided array by swapping two axes.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant view. ok: an optional boolean for error handling.

    validate_axes ¶
    Source

    validate_axes :: proc($Nd := , axes: [0]untyped integer, location := #caller_location) -> bool {…}

    validate_axis ¶
    Source

    validate_axis :: proc(ndims: untyped integer, axis: untyped integer, location := #caller_location) -> bool {…}

    validate_initialized ¶
    Source

    validate_initialized :: proc(mdarray: MdArray($T, $Nd), location := #caller_location) -> bool {…}

    validate_pos_within_shape ¶
    Source

    validate_pos_within_shape :: proc(pos: [0]untyped integer, shape: [0]untyped integer, location := #caller_location) -> bool {…}

    validate_positive_shape ¶
    Source

    validate_positive_shape :: proc(shape: [0]untyped integer, location := #caller_location) -> bool {…}

    validate_shape_and_get_size ¶
    Source

    validate_shape_and_get_size :: proc(shape: [0]untyped integer, location := #caller_location) -> (size: untyped integer, ok: bool) {…}

    validate_shape_match ¶
    Source

    validate_shape_match :: proc(a: MdArray($T, $Nd), b: MdArray($T, $Nd), location := #caller_location) -> bool {…}

    vflatten ¶
    Source

    vflatten :: flatten_view
     

    Create a flattened (collapse dimensions into one) view of an array.

    Inputs:
    Nd: the number of dimensions before the expansion. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant reshaped view. ok: an optional boolean for error handling.

    vpermute_dims ¶
    Source

    vpermute_dims :: permute_dims_view
     

    Create a permuted view of the provided array.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant view. ok: an optional boolean for error handling.

    Related Procedure Groups

    vreshape ¶
    Source

    vreshape :: reshape_view
     

    Create a view of an array with a differnt shape.

    Inputs:
    mdarray: the source multidimensional array. shape: the shape of the destination array. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: The resultant reshaped view. ok: an optional boolean for error handling.

    vstack ¶
    Source

    vstack :: proc(mdarrays: []MdArray($T, $Nd=1), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd=2), ok: bool) #optional_ok {…}
     

    Stack several vector arrays vertically.

    Inputs:
    mdarrays: a slice that contains the arrays to stack. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant stack array. ok: an optional boolean for error handling.

    vswap_axes ¶
    Source

    vswap_axes :: swap_axes_view
     

    Create a permuted view of the provided array by swapping two axes.

    NOTE: Use of this procedure is discourged. Please use the procedure group instead.

    Inputs:
    value: the value based on which the array will be filled indices: the permutation indices. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant view. ok: an optional boolean for error handling.

    where_cond ¶
    Source

    where_cond :: proc(mdarray: MdArray($T, $Nd), where_array: MdArray($T=bool, $Nd), allocator := context.allocator, location := #caller_location) -> (result: MdArray($T, $Nd=1), ok: bool) #optional_ok {…}
     

    Returns a vector of all elements that corresponed to the true values in the provided boolean array.

    Inputs:
    mdarray: a multidimensional array. where_array: a multidimensional boolean array according to which the elements of mdarray are selected. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    result: the resultant vector. ok: an optional boolean for error handling.

    zeros ¶
    Source

    zeros :: proc($T: typeid, shape: [0]untyped integer, allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T=typeid, $Nd), ok: bool) #optional_ok {…}
     

    Create a multi-dimensional array based on the provided shape, whose elements are all zero.

    Inputs:
    T: the type of created array. shape: the shape of the multi-dimensional array. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: a multidimsional array filled with zeros. ok: an optional boolean for error handling.

    zeros_like ¶
    Source

    zeros_like :: proc($T: typeid, source: MdArray($T, $Nd), allocator := context.allocator, location := #caller_location) -> (mdarray: MdArray($T=typeid, $Nd), ok: bool) #optional_ok {…}
     

    Create a multi-dimensional array with an identical shape to another array, whose elements are all with zeros.

    Inputs:
    T: the type of created array. source: the array based on which the shape of the created array is decided. Its internal type doesn't matter. The created array will follow the type above. allocator: the allocator used internally. location: a debugging variable used to trace the location of the calling procedure.

    Returns:
    mdarray: a multidimsional array filled with zeros. ok: an optional boolean for error handling.

    Procedure Groups

    add ¶
    Source

    all_close ¶
    Source

    all_close :: proc{
	all_close_default,
	all_close_with_args,
}

    all_reduce_prod ¶
    Source

    all_reduce_prod :: proc{
	all_reduce_prod_no_init,
	all_reduce_prod_with_init,
}

    all_reduce_sum ¶
    Source

    all_reduce_sum :: proc{
	all_reduce_sum_no_init,
	all_reduce_sum_with_init,
}

    atan2 ¶
    Source

    bitwise_and ¶
    Source

    bitwise_andnot ¶
    Source

    bitwise_or ¶
    Source

    bitwise_xor ¶
    Source

    ctranspose ¶
    Source

    ctranspose :: proc{
	permute_dims_copy,
	permute_default_copy,
}

    dim_reduce_prod ¶
    Source

    dim_reduce_prod :: proc{
	dim_reduce_prod_no_init,
	dim_reduce_prod_with_init,
}

    dim_reduce_sum ¶
    Source

    dim_reduce_sum :: proc{
	dim_reduce_sum_no_init,
	dim_reduce_sum_with_init,
}

    div ¶
    Source

    equal ¶
    Source

    gcd ¶
    Source

    greater ¶
    Source

    greater_equal ¶
    Source

    heaviside ¶
    Source

    hypot ¶
    Source

    is_close ¶
    Source

    is_close :: proc{
	is_close_default,
	is_close_with_args,
}

    keepdim_reduce_prod ¶
    Source

    keepdim_reduce_sum ¶
    Source

    lcm ¶
    Source

    left_shift ¶
    Source

    less ¶
    Source

    less_equal ¶
    Source

    logaddexp ¶
    Source

    logical_and ¶
    Source

    logical_or ¶
    Source

    maximum ¶
    Source

    minimum ¶
    Source

    mod ¶
    Source

    mul ¶
    Source

    not_equal ¶
    Source

    right_shift ¶
    Source

    subtract ¶
    Source

    transpose_copy ¶
    Source

    transpose_copy :: proc{
	permute_dims_copy,
	permute_default_copy,
}

    transpose_view ¶
    Source

    transpose_view :: proc{
	permute_dims_view,
	permute_default_view,
}

    vtranspose ¶
    Source

    vtranspose :: proc{
	permute_dims_view,
	permute_default_view,
}

    Source Files

    Generation Information

    Generated with odin version dev-2025-11 (vendor "odin") Linux_amd64 @ 2025-11-15 02:28:15.950599215 +0000 UTC