physsol 0.2.0

Lightweight 2d and 3d physics library
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
77
78
79
80
81
82
83
84
85
86
87
88
89

use num_traits::{Float};
use vec::*;

pub type Wrap<V> = (V, V, V, V);

pub fn wrap<V>(t: V) -> Wrap<V> where V: Clone {
    (t.clone(), t.clone(), t.clone(), t)
}

pub fn wrap_ref<V>(t: &V) -> Wrap<V> where V: Clone {
    (t.clone(), t.clone(), t.clone(), t.clone())
}

pub trait Var<T> where T: Copy + Float {
    fn step(&mut self, dt: T, f: fn(&mut Wrap<&mut T>, T));

    fn step_0(&mut self, dt: T) {
        self.step(dt, |v, dt| {
            *v.3 = *v.0;
            *v.2 = *v.1;
            *v.0 = *v.3 + *v.1*dt*T::from(0.5).unwrap();
        });
    }
    fn step_1(&mut self, dt: T) {
        self.step(dt, |v, dt| {
            *v.2 = *v.2 + *v.1*T::from(2.0).unwrap();
            *v.0 = *v.3 + *v.1*dt*T::from(0.5).unwrap();
        });
    }
    fn step_2(&mut self, dt: T) {
        self.step(dt, |v, dt| {
            *v.2 = *v.2 + *v.1*T::from(2.0).unwrap();
            *v.0 = *v.3 + *v.1*dt;
        });
    }
    fn step_3(&mut self, dt: T) {
        self.step(dt, |v, dt| {
            *v.2 = *v.2 + *v.1;
            *v.0 = *v.3 + *v.2*dt/T::from(6.0).unwrap();
        });
    }
}

impl<'a, T> Var<T> for Wrap<&'a mut T> where T: Copy + Float {
    fn step(&mut self, dt: T, f: fn(&mut Wrap<&mut T>, T)) {
        f(self, dt);
    }
}

impl<T> Var<T> for Wrap<T> where T: Copy + Float {
    fn step(&mut self, dt: T, f: fn(&mut Wrap<&mut T>, T)) {
        f(&mut (&mut self.0, &mut self.1, &mut self.2, &mut self.3), dt);
    }
}

macro_rules! var_vec {
    ($V:ident, $N:expr) => (
        impl<'a, T> Var<T> for Wrap<&'a mut $V<T>> where T: Copy + Float {
            fn step(&mut self, dt: T, f: fn(&mut Wrap<&mut T>, T)) {
                for i in 0..$N {
                    unsafe { (
                        self.0.data.get_unchecked_mut(i),
                        self.1.data.get_unchecked_mut(i),
                        self.2.data.get_unchecked_mut(i),
                        self.3.data.get_unchecked_mut(i),
                    ).step(dt, f) }
                }
            }
        }

        impl<T> Var<T> for Wrap<$V<T>> where T: Copy + Float {
            fn step(&mut self, dt: T, f: fn(&mut Wrap<&mut T>, T)) {
                (&mut self.0, &mut self.1, &mut self.2, &mut self.3).step(dt, f);
            }
        }
    )
}
var_vec!(Vec2, 2);
var_vec!(Vec3, 3);
var_vec!(Vec4, 4);

pub fn solve<F, V, T>(mut fn_step: F, dt: T) 
    where F: FnMut(fn(&mut V, T), T), V: Var<T>, T: Copy + Float
{
    fn_step(|v, dt| v.step_0(dt), dt);
    fn_step(|v, dt| v.step_1(dt), dt);
    fn_step(|v, dt| v.step_2(dt), dt);
    fn_step(|v, dt| v.step_3(dt), dt);
}