vecmate 0.2.3

Lightweight, zero-dependency, type-agnostic library for vector math.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use crate::{Float, Number};

/// Module with the most common vectors represented as constants
pub mod consts;

/// Module that implements traits
mod impls;

/// This structure representing a two-dimensional vector. Type-agnostic
#[derive(Debug, Clone, Copy)]
pub struct Vec2<T> {
    /// X coordinate
    pub x: T,
    /// Y coordinate
    pub y: T,
}

/// Function to create a new vector, the vector type depends on the argument type (the arguments must be of the same type)
pub fn vec2<T>(x: T, y: T) -> Vec2<T>
where
    T: Number<T>,
{
    Vec2 { x, y }
}

impl<S> Vec2<S>
where
    S: Float<S>,
{
    /// Returns vector's length
    pub fn length(&self) -> S {
        (self.x * self.x + self.y * self.y).sqrt()
    }

    /// Normalize the current vector
    pub fn normalize(&self) -> Self {
        let len = self.length();
        vec2(self.x / len, self.y / len)
    }

    /// Returns distance between two vectors
    pub fn distance(&self, rhs: &Self) -> S {
        let x = self.x - rhs.x;
        let y = self.y - rhs.y;

        (x * x + y * y).sqrt()
    }
}

impl<T> Vec2<T>
where
    T: Number<T>,
{
    /// Returns dot product of two vectors
    pub fn dot(&self, rhs: &Self) -> T {
        (self.x * rhs.x) + (self.y * rhs.y)
    }

    /// Returns cross product of two vectors
    pub fn cross(&self, rhs: &Self) -> T {
        self.x * rhs.y - self.y * rhs.x
    }

    // Returns manhattan distance between two vectors
    // pub fn manhattan_distance(&self, rhs: &Self) -> T {
    //     (self.x - rhs.x)
    // }
}