illuminator 0.1.3

A simple yet powerful rendering tool
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

use num_traits::Float;
use crate::core::tensor::{Tensor, TensorNum};

pub trait Vector<T: TensorNum, const N: usize> {
    fn sqrnorm(&self) -> T;

    fn norm(&self) -> T;

    fn normalize(&self) -> Tensor<T, N>;

    fn dot(&self, rhs: Tensor<T, N>) -> T;

    fn cross(&self, rhs: Tensor<T, N>) -> Self;
}

impl<T: TensorNum + Float, const N: usize> Vector<T, N> for Tensor<T, N> {
    fn norm(&self) -> T {
        self.sqrnorm().sqrt()
    }

    fn sqrnorm(&self) -> T {
        (0..N).fold(T::zero(), |acc, i| self[i] * self[i] + acc)
    }

    fn normalize(&self) -> Tensor<T, N> {
        *self * (T::one() / self.norm())
    }

    fn dot(&self, rhs: Tensor<T, N>) -> T {
        assert!(
            self.shape.size() == 1 && rhs.shape.size() == 1,
            "Dot Only for 1d tensors"
        );

        (0..N).fold(T::zero(), |acc, i| acc + self.raw[i] * rhs.raw[i])
    }

    fn cross(&self, rhs: Tensor<T, N>) -> Self {
        assert!(
            self.shape.size() == 1 && rhs.shape.size() == 1 && N > 2,
            "Cross Only for 1d tensors"
        );

        let u0 = self[0];
        let u1 = self[1];
        let u2 = self[2];
        let v0 = rhs[0];
        let v1 = rhs[1];
        let v2 = rhs[2];
        let mut arr = [T::zero(); N];
        arr[0] = u1 * v2 - v1 * u2;
        arr[1] = u2 * v0 - v2 * u0;
        arr[2] = u0 * v1 - v0 * u1;
        Self::vec(arr)
    }
}