Crate numeric_array

numeric-array

numeric-array is a wrapper around generic-array that adds efficient numeric trait implementations, designed to encourage LLVM to autovectorize expressions into SIMD instructions and perform compile-time evaluation.

All stable core::ops traits are implemented for NumericArray itself, plus the thin NumericConstant type, which is required to differeniate constant values from NumericArray itself.

Additionally, most of num_traits are implemented, including Num itself. So you can even use a whole array as a generic number.

Example:

use num_traits::Float;
use numeric_array::{NumericArray, narr};

fn main() {
    let a = narr![1.0, 2.0, 3.0, 4.0];
    let b = narr![5.0, 6.0, 7.0, 8.0];
    let c = narr![9.0, 1.0, 2.0, 3.0];

    // Compiles to a single vfmadd213ps instruction on my machine
    let d = a.mul_add(b, c);

    assert_eq!(d, narr![14.0, 13.0, 23.0, 35.0]);
}

When used with RUSTFLAGS = "-C opt-level=3 -C target-cpu=native", then Rust and LLVM are smart enough to autovectorize almost all operations into SIMD instructions, or even just evaluate them at compile time. The above example is actually evaluated at compile time, so if you were to view the assembly it would show the result only.

This is ideal for situations where simple component-wise operations are required for arrays.

Re-exports

pub extern crate generic_array;

pub use generic_array::typenum;

Modules

geometry

impls

Implementation notes

simd

Context-sensitive SIMD operations

Macros

narr

Sugar for NumericArray::new(arr![...])

nconstant

Creates a new NumericConstant from the given expression.

Structs

NumericArray

A numeric wrapper for a GenericArray, allowing for easy numerical operations on the whole sequence.

NumericConstant

This is required to allow NumericArray to be operated on by both other NumericArray instances and constants, with generic types, because some type U supercedes NumericArray<U, N>

Traits

ArrayLength

Trait used to define the number of elements in a GenericArray.