Releases

Constructors for randomized arrays. `rand` integration for `ndarray`.

`rblas` bindings for `ndarray`.

An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.

Parallelization for ndarray (using rayon).

Extra iterator adaptors, iterator methods, free functions, and macros.

Graph data structure library. Provides graph types and graph algorithms.

A hash table with consistent order and fast iteration.

A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.

A wrapper type to inhibit drop (destructor).

A wrapper type to inhibit drop (destructor). Implementation crate for nodrop, the untagged unions implementation (which is unstable / requires nightly) as of this writing.

Container / collection literal macros for HashMap, HashSet, BTreeMap, BTreeSet.

General matrix multiplication of f32 and f64 matrices in Rust. Supports matrices with general strides. Uses a microkernel strategy, so that the implementation is easy to parallelize and optimize. `RUSTFLAGS="-C target-cpu=native"` is your friend here.

Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds.

A RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic). Defines the macros `defer!` and `defer_on_unwind!`; the latter only runs if the scope is extited through unwinding on panic.

Safe interface to memchr.

The enum `Either`, with variants `Left` and `Right` and trait implementations including Iterator, Read, Write. Either has methods that are similar to Option and Result. Includes convenience macros `try_left!()` and `try_right!()` to use for short-circuiting logic.

A port of the libtest (unstable Rust) benchmark runner to Rust stable releases. Supports running benchmarks and filtering based on the name. Benchmark execution works exactly the same way and no more (caveat: black_box is still missing!).

Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap's algorithm.

Fast substring search for strings and byte strings. Optional SSE4.2 acceleration (requires nightly and cargo feature flag pcmp) using pcmpestri. Memchr is the only mandatory dependency. The two way algorithm is also used by rust's libstd itself, but here it is exposed both for byte strings, using memchr, and optionally using a SSE4.2 accelerated version.

The package provides bindings to the Basic Linear Algebra Subprograms.

FixedBitSet is a simple bitset collection

Odds and ends — collection miscellania. Extra functionality for slices (`.find()`, `RevSlice`), strings and other things. Debug checked variants of `get_unchecked` and `slice_unchecked`, and extra methods for strings and vectors: `repeat`, `insert_str` and `splice`. Things in odds may move to more appropriate crates if we find them.

A grab-bag of tools for functional programming.

Debug-print any value without trait bounds using specialization (Rust nightly channel)

Very simple drawing/diagramming library with svg output.

A macro to define lambda-like macros inline.

Macro to create a new trait that acts like an alias or “group” of a bunch of traits.

Cast any primitive numeric type to any other using `as` with the AsPrim trait.

Multithreaded Fork of bluss's matrixmultiply crate. General matrix multiplication of f32 and f64 matrices in Rust. Supports matrices with general strides. Uses a microkernel strategy, so that the implementation is easy to parallelize and optimize. `RUSTFLAGS="-C target-cpu=native"` is your friend here.

Efficient numerical loops (sum, dot product) with optional nightly-using special cases and optimizations.