# Crate vectrs[−][src]

# NOTE: this crate was renamed to `vectrix`, please use it under the new name.

See `vectrix`

This crate provides a stack-allocated, constant-size, *n*-dimensional
`Vector<T, N>`

type.

# Constructors

`vector!`

macro

Simply use the `vector!`

macro to construct a new `Vector`

of any size.

let v = vector![1, 3, 3, 7]; // ^ constructs a `Vector<_, 4>`.

### Directly using `new()`

or `From`

A `Vector`

is backed by an array. The simplest way to construct a
`Vector`

is to create it directly from an array or tuple. In both of these
cases the size of the `Vector`

can be easily inferred by the Rust type
system.

From an array:

let v = Vector::new([1, 2, 3, 4]); // ^ Rust automatically infers that the type is `Vector<_, 4>`.

From a tuple:

// ... 1 to 12 element tuples are supported let v = Vector::from((1, 2, 3)); // ^ Rust automatically infers that the type is `Vector<_, 3>`.

### Collecting from an iterator

The other common method of constructing a `Vector`

is to use the
`.collect()`

method on an iterator. When collecting from an iterator,
`.collect()`

will panic if there are not enough elements to fill the
`Vector`

. If there are extra elements they will be ignored.

let heap = vec![1, 2, 3, 4, 5]; let stack: Vector<_, 5> = heap.into_iter().collect(); // ^^^^^^^^^^^^ the type needs to be provided in this case

### Using `from_partial{_with}`

It is common that you do not have enough elements to fill the `Vector`

. So
the `.from_partial()`

and
`.from_partial_with()`

methods are provided.
These can be used to construct a `Vector`

and fill the remaining space
with zeroes or a fill value.

let v = Vector::<_, 3>::from_partial((1, 2)); assert_eq!(v, Vector::new([1, 2, 0])); let v = Vector::<_, 5>::from_partial_with((3, 2, 1), 1); assert_eq!(v, Vector::new([3, 2, 1, 1, 1])); // ^ fill value

# Accessing and mutating data

### Slice representation

A slice view of the underlying data is provided using `Deref`

or
`.as_slice()`

. This means all slice methods are
available including indexing.

let vector = vector![1, 3, 3, 7]; assert_eq!(vector[3], 7);

A mutable slice view of the underlying data is provide using `DerefMut`

or
`.as_mut_slice()`

. This means you can mutate data
using slice indexing.

let mut vector = vector![1, 3, 3, 7];; vector[0] = 2; assert_eq!(vector, vector![2, 3, 3, 7]);

### Component accessor methods

Component accessor methods are available for small vectors using commonly recognized names.

let vector = vector![1, 3, 3, 7]; assert_eq!(vector.x(), 1); assert_eq!(vector.y(), 3); assert_eq!(vector.z(), 3); assert_eq!(vector.w(), 7);

Additionally, you can get mutable access using the `*_mut`

versions.

let mut vector = vector![1, 3, 3, 7]; *vector.y_mut() = 2; *vector.w_mut() = 4; assert_eq!(vector, vector![1, 2, 3, 4]);

## Modules

traits | Abstractions over number types. |

## Macros

vector | Construct a new |

## Structs

IntoIter | An iterator that moves out of a vector. |

Vector | Represents a constant-size, |