Struct Vector 

pub struct Vector<T, const N: usize>(/* private fields */);

A generic, fixed-size vector with compile-time dimension checking.

The Vector type represents a mathematical vector with N components of type T. It provides common vector operations and integrates with the vector-space trait ecosystem.

Type Parameters

• T: The scalar type of vector components (must implement relevant traits for operations)
• N: The dimension of the vector (must be a compile-time constant)

Examples

Basic usage with f32:

use simple_vectors::Vector;

let v = Vector::new([1.0, 2.0, 3.0]);
assert_eq!(v[0], 1.0);
assert_eq!(v[1], 2.0);
assert_eq!(v[2], 3.0);

Using with integer types:

use simple_vectors::Vector;

let int_vec = Vector::new([1, 2, 3, 4]);
let scaled = int_vec * 2;
assert_eq!(scaled, Vector::new([2, 4, 6, 8]));

Implementations

impl<T, const N: usize> Vector<T, N>

pub const fn new(elements: [T; N]) -> Self

Creates a new vector from the given array of elements.

This is a const function, allowing vector creation in const contexts.

Arguments

• elements - An array of N elements to initialize the vector

Examples

use simple_vectors::Vector;

const V: Vector<i32, 3> = Vector::new([1, 2, 3]);
assert_eq!(V, Vector::new([1, 2, 3]));

Creating a 2D vector:

use simple_vectors::Vector;

let point = Vector::new([10.5, 20.3]);

Trait Implementations

impl<T, const N: usize> Add for Vector<T, N>

where T: Add<Output = T> + Copy,

type Output = Vector<T, N>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<T, const N: usize> AddAssign for Vector<T, N>

where T: AddAssign + Copy,

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Real, const N: usize, const I: usize> Basis<I> for Vector<T, N>

fn unit_basis() -> Self

Creates an unit basis of the vector space.

fn basis_of(magnitude: T) -> Self

Creates a scaled basis of the vector space of the specified magnitude.

fn basis(&self) -> Self::Scalar

Queries a basis of a vector space.

fn basis_mut(&mut self) -> &mut Self::Scalar

Queries a basis of a vector space as a mutable reference.

fn with_basis(self, magnitude: Self::Scalar) -> Self

Creates a new vector with a single basis set to a different value.

impl<T: Clone, const N: usize> Clone for Vector<T, N>

fn clone(&self) -> Vector<T, N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for Vector<T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + Copy, const N: usize> Default for Vector<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Div<T> for Vector<T, N>

where T: Div<Output = T> + Copy,

type Output = Vector<T, N>

The resulting type after applying the / operator.

fn div(self, other: T) -> Self

Performs the / operation.

impl<T, const N: usize> DivAssign<T> for Vector<T, N>

where T: DivAssign + Copy,

fn div_assign(&mut self, other: T)

Performs the /= operation.

impl<T: Real, const N: usize> DotProduct for Vector<T, N>

type Output = <Vector<T, N> as VectorSpace>::Scalar

The output type of the dot product.

fn dot(self, other: Self) -> T

The dot product.

impl<'a, T, const N: usize> From<&'a Vector<T, N>> for &'a [T]

fn from(val: &'a Vector<T, N>) -> Self

Converts to this type from the input type.

impl<'a, T, const N: usize> From<&'a Vector<T, N>> for &'a [T; N]

fn from(val: &'a Vector<T, N>) -> Self

Converts to this type from the input type.

impl<'a, T, const N: usize> From<&'a mut Vector<T, N>> for &'a mut [T]

fn from(val: &'a mut Vector<T, N>) -> Self

Converts to this type from the input type.

impl<'a, T, const N: usize> From<&'a mut Vector<T, N>> for &'a mut [T; N]

fn from(val: &'a mut Vector<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for Vector<T, N>

fn from(elements: [T; N]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Vector<T, N>> for [T; N]

fn from(val: Vector<T, N>) -> Self

Converts to this type from the input type.

impl<T: Hash, const N: usize> Hash for Vector<T, N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I, T, const N: usize> Index<I> for Vector<T, N>

where [T; N]: Index<I>,

type Output = <[T; N] as Index<I>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I, T, const N: usize> IndexMut<I> for Vector<T, N>

where [T; N]: IndexMut<I>,

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: Real, const N: usize> InnerSpace for Vector<T, N>

fn scalar(self, other: Self) -> T

The scalar product.

fn magnitude2(self) -> Self::Scalar

The squared magnitude.

fn magnitude(self) -> Self::Scalar

The magnitude of a vector.

fn normalize(self) -> Self

The normalized vector.

fn angle(self, other: Self) -> Self::Scalar

The angle between two vectors.

fn with_magnitude(self, magnitude: Self::Scalar) -> Self

Sets the magnitude of a vector.

fn with_direction(self, dir: Self) -> Self

Sets the direction of a vector.

fn query_axis(self, dir: Self) -> Self::Scalar

The value of the vector along the specified axis.

fn normalized_project(self, dir: Self) -> Self

Projects a vector onto an already normalized direction vector.

fn project(self, dir: Self) -> Self

Projects a vector onto an arbitraty direction vector.

fn normalized_reject(self, dir: Self) -> Self

Rejects a vector from an already normalized direction vector.

fn reject(self, dir: Self) -> Self

Rejects a vector from an arbitraty direction vector.

fn normalized_reflect(self, dir: Self) -> Self

Reflects a vector from an already normalized direction vector.

fn reflect(self, dir: Self) -> Self

Reflects a vector from an arbitraty direction vector.

impl<T, const N: usize> Mul<T> for Vector<T, N>

where T: Mul<Output = T> + Copy,

type Output = Vector<T, N>

The resulting type after applying the * operator.

fn mul(self, other: T) -> Self

Performs the * operation.

impl<T, const N: usize> Mul for Vector<T, N>

where T: Add<Output = T> + Mul<Output = T> + Zero + Copy,

type Output = T

The resulting type after applying the * operator.

fn mul(self, other: Self) -> T

Performs the * operation.

impl<T, const N: usize> MulAssign<T> for Vector<T, N>

where T: MulAssign + Copy,

fn mul_assign(&mut self, other: T)

Performs the *= operation.

impl<T, const N: usize> Neg for Vector<T, N>

where T: Neg<Output = T> + Copy,

type Output = Vector<T, N>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: PartialEq, const N: usize> PartialEq for Vector<T, N>

fn eq(&self, other: &Vector<T, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, const N: usize> Sub for Vector<T, N>

where T: Sub<Output = T> + Copy,

type Output = Vector<T, N>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<T, const N: usize> SubAssign for Vector<T, N>

where T: SubAssign + Copy,

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: Real, const N: usize> VectorSpace for Vector<T, N>

type Scalar = T

The scalar type of the vector space.

impl<T: Zero + Copy, const N: usize> Zero for Vector<T, N>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Copy, const N: usize> Copy for Vector<T, N>

impl<T: Eq, const N: usize> Eq for Vector<T, N>

impl<T, const N: usize> StructuralPartialEq for Vector<T, N>