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
69
70
71
72
73
74
75
76

//! [![GitHub last commit](https://img.shields.io/github/last-commit/ztry8/vecmate)](https://github.com/ztry8/vecmate/)
//! [![crates.io](https://img.shields.io/crates/v/vecmate)](https://crates.io/crates/vecmate)
//! [![docs.rs](https://img.shields.io/docsrs/vecmate)](https://docs.rs/vecmate)
//! [![License](https://img.shields.io/github/license/ztry8/vecmate)](https://github.com/ztry8/vecmate/blob/main/LICENSE)
//! ## Lightweight, zero-dependency, type-agnostic library for vector math.   
//! ```rust
//! let mut position = consts::f32::ZERO;
//! let target = vec2(10.0, 5.0);
//! let speed = 2.0;
//!
//! let direction = (target - position).normalize();
//! position += direction * speed;
//!
//! println!("Moving towards {target}");
//! println!("New position: {position}");
//! ```

use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};

mod tests;

/// Module for working with two-dimensional vectors
pub mod vec2;

/// Trait that defines that the type is a number
pub trait Number<T>:
    Clone
    + Copy
    + PartialEq
    + Sized
    + Add<Output = T>
    + Sub<Output = T>
    + Mul<Output = T>
    + Div<Output = T>
    + Neg
    + AddAssign
    + SubAssign
    + MulAssign
    + DivAssign
{
}

impl<
    T: Clone
        + Copy
        + PartialEq
        + Sized
        + Add<Output = T>
        + Sub<Output = T>
        + Mul<Output = T>
        + Div<Output = T>
        + Neg
        + AddAssign
        + SubAssign
        + MulAssign
        + DivAssign,
> Number<T> for T
{
}

/// Trait that specifies that the root of a number can be calculated
pub trait Float<T>: Number<T> {
    fn sqrt(self) -> T;
}

impl Float<f32> for f32 {
    fn sqrt(self) -> f32 {
        f32::sqrt(self)
    }
}

impl Float<f64> for f64 {
    fn sqrt(self) -> f64 {
        f64::sqrt(self)
    }
}