Struct fixed_vectors::Vector2

pub struct Vector2<T> {
    pub x: T,
    pub y: T,
}

Vector for holding two-dimensional values.

Example

use fixed_vectors::Vector2;
 
let mut vec2 = Vector2::new(1, 2);
vec2 += Vector2::new(1, 2);
 
assert_eq!(vec2.x, 2);
assert_eq!(vec2.y, 4);

Fields

x: T

y: T

Implementations

impl<T> Vector2<T>

pub const fn new(x: T, y: T) -> Self

Constructs a new vector with the specified values for each field.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(0, 0);
 
assert_eq!(vec2.x, 0);
assert_eq!(vec2.y, 0);

pub fn to_array(self) -> [T; 2]

Consumes the vector and returns its values as an array.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(0, 0);
let array = vec2.to_array();
 
assert_eq!(array, [0, 0]);

pub fn map<F, U>(self, f: F) -> Vector2<U>where F: Fn(T) -> U,

Consumes the vector and returns a new vector with the given function applied on each field.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(1, 2)
    .map(|i| i * 2);
 
assert_eq!(vec2, Vector2::new(2, 4));

impl<T: Copy> Vector2<T>

pub const fn from_value(value: T) -> Self

Constructs a vector using the given value as the value for all of its fields.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::from_value(0);
 
assert_eq!(vec2, Vector2::new(0, 0));

impl<T: Add<Output = T> + Copy> Vector2<T>

pub fn add_value(self, value: T) -> Self

Adds the given value to all fields within the vector.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(0, 0).add_value(1);
 
assert_eq!(vec2, Vector2::new(1, 1));

impl<T: Sub<Output = T> + Copy> Vector2<T>

pub fn sub_value(self, value: T) -> Self

Subtracts the given value from all fields within the vector.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(0, 0).sub_value(1);
 
assert_eq!(vec2, Vector2::new(-1, -1));

impl<T: Mul<Output = T> + Copy> Vector2<T>

pub fn mul_value(self, value: T) -> Self

Multiplies the given value across all fields within the vector.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(1, 2).mul_value(2);
 
assert_eq!(vec2, Vector2::new(2, 4));

impl<T: Div<Output = T> + Copy> Vector2<T>

pub fn div_value(self, value: T) -> Self

Divides the given value across all fields within the vector.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(2, 4).div_value(2);
 
assert_eq!(vec2, Vector2::new(1, 2));

impl<T: FloatCore> Vector2<T>

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

Returns the dot product of two vectors.

Example

use fixed_vectors::Vector2;
 
let a = Vector2::new(1.0, 2.0);
let b = Vector2::new(2.0, 4.0);
let dot = a.dot(&b);
 
assert_eq!(dot, 10.0);

pub fn length_squared(&self) -> T

Returns the squared magnitude of vector.

Example

use fixed_vectors::Vector3;
 
let vec3 = Vector3::new(3.33, 2.04, 1.337);
let lsq = vec3.length_squared();
 
assert!(lsq >= 17.0);

pub fn floor(self) -> Self

Applies floor on all fields within the vector, converting each field to the largest integer less than or equal to its value.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(1.6, 2.3).floor();
 
assert_eq!(vec2, Vector2::new(1.0, 2.0));

pub fn ceil(self) -> Self

Applies ceil on all fields within the vector, converting each field to the largest integer greater than or equal to its value.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(1.6, 2.3).ceil();
 
assert_eq!(vec2, Vector2::new(2.0, 3.0));

pub fn round(self) -> Self

Applies round on all fields within the vector, converting each field’s value to its nearest integer.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(1.6, 2.3).round();
 
assert_eq!(vec2, Vector2::new(2.0, 2.0));

pub fn abs(self) -> Self

Applies abs on all fields within the vector, converting each field to their absolute value.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(-2.6, 2.3).abs();
 
assert_eq!(vec2, Vector2::new(2.6, 2.3));

pub fn trunc(self) -> Self

Applies trunc on all fields within the vector, converting each field’s value to their integer parts.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(-2.6, 2.3).trunc();
 
assert_eq!(vec2, Vector2::new(-2.0, 2.0));

pub fn fract(self) -> Self

Applies fract on all fields within the vector, converting each field’s value to their fractional parts.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(-2.5, 2.25).fract();
 
assert_eq!(vec2, Vector2::new(-0.5, 0.25));

pub fn powi(self, n: i32) -> Self

Applies powi on all fields within the vector, raising each field’s value to an integer power.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(2.0, 4.0).powi(2);
 
assert_eq!(vec2, Vector2::new(4.0, 16.0));

pub fn lerp(self, to: Self, weight: T) -> Self

Linearly interpolates between two Vectors by a normalized weight.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(1.0, 2.0).lerp(
    Vector2::new(2.0, 3.0), 1.0
);
 
assert_eq!(vec2, Vector2::new(2.0, 3.0));

impl Vector2<f32>

pub fn sqrt_short(self) -> Self

Consumes the vector and returns it with all of its fields converted to their square-root as a f32.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(64.0, 25.0).sqrt_short();
 
assert_eq!(vec2, Vector2::new(8.0, 5.0));

pub fn length_short(&self) -> f32

Returns the magnitude of the vector as a f32.

Example

use fixed_vectors::Vector3;
 
let vec3 = Vector3::new(1.5, 2.0, 3.33);
let length = vec3.length_short();
 
assert!(length < 4.2);

pub fn normalized_short(self) -> Self

Consumes the vector and returns it as normalized vector of f32s.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(14.3, 7.9).normalized_short();
 
assert!(vec2.x < 1.0);
assert!(vec2.y < 1.0);

impl Vector2<f64>

pub fn sqrt(self) -> Self

Consumes the vector and returns it with all of its fields converted to their square-root as a f64.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(64.0, 25.0).sqrt();
 
assert_eq!(vec2, Vector2::new(8.0, 5.0));

pub fn length(&self) -> f64

Returns the magnitude of the vector as a f64.

Example

use fixed_vectors::Vector3;
 
let vec3 = Vector3::new(1.5, 2.0, 3.33);
let length = vec3.length();
 
assert!(length < 4.2);

pub fn normalized(self) -> Self

Consumes the vector and returns it as normalized vector of f64s.

Example

use fixed_vectors::Vector2;
 
let vec2 = Vector2::new(14.3, 7.9).normalized();
 
assert!(vec2.x < 1.0);
assert!(vec2.y < 1.0);

Trait Implementations

impl<T: Add<Output = T>> Add<Vector2<T>> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: AddAssign> AddAssign<Vector2<T>> for Vector2<T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Clone> Clone for Vector2<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Vector2<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Vector2<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Div<Output = T>> Div<Vector2<T>> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: DivAssign> DivAssign<Vector2<T>> for Vector2<T>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T: Hash> Hash for Vector2<T>

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<T: Mul<Output = T>> Mul<Vector2<T>> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: MulAssign> MulAssign<Vector2<T>> for Vector2<T>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T: Neg<Output = T>> Neg for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq<Vector2<T>> for Vector2<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Rem<Output = T>> Rem<Vector2<T>> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl<T: RemAssign> RemAssign<Vector2<T>> for Vector2<T>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<T: Sub<Output = T>> Sub<Vector2<T>> for Vector2<T>

type Output = Vector2<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: SubAssign> SubAssign<Vector2<T>> for Vector2<T>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: Eq> Eq for Vector2<T>