extensor 0.1.1

the main extensor crate for building arbitrary valent tensors and more.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use core::ops::AddAssign;

use super::*;

pub mod macros;

pub struct Tensor<const M: usize, const N: usize, F>
where
    [(); M * N]:,
{
    /// This set up makes the first index into `coefficients` the "rows" and
    /// second the "columns"
    coefficients: V<M, V<N, F>>,
}

impl<const M: usize, const N: usize, F> Default for Tensor<M, N, F>
where
    [(); M * N]:,
    F: Default + Copy,
{
    fn default() -> Self {
        let coefficients = V::<M, V<N, F>>::default();
        Tensor { coefficients }
    }
}

impl<const M: usize, const N: usize, F> Tensor<M, N, F>
where
    [(); M * N]:,
    F: Mul<Output = F> + Default + Copy,
{
    pub fn tensor_product<const P: usize>(v: [V<M, F>; P], w: [V<N, F>; P]) -> Tensor<M, N, F> {
        let mut tensor = Tensor::default();

        for p in 0..P {
            for i in 0..M {
                for j in 0..N {
                    tensor.coefficients.0[i].0[j] = v[p].0[i] * w[p].0[j];
                }
            }
        }
        tensor
    }
}

impl<const M: usize, const N: usize, F> Add for Tensor<M, N, F>
where
    [(); M * N]:,
    F: Add<Output = F> + Copy + Default,
{
    type Output = Self;
    fn add(self, other: Tensor<M, N, F>) -> Self::Output {
        let mut tensor = Tensor::default();
        for i in 0..M {
            for j in 0..N {
                tensor.coefficients.0[i].0[j] =
                    self.coefficients.0[i].0[j] + other.coefficients.0[i].0[j];
            }
        }
        tensor
    }
}

impl<const M: usize, const N: usize, F> Mul<F> for Tensor<M, N, F>
where
    [(); M * N]:,
    F: Mul<Output = F> + Default + Copy,
{
    type Output = Self;
    fn mul(self, scalar: F) -> Self::Output {
        let mut tensor = Tensor::default();
        for i in 0..M {
            for j in 0..N {
                tensor.coefficients.0[i].0[j] = self.coefficients.0[i].0[j] * scalar;
            }
        }
        tensor
    }
}

/// Below are more features of tensor that we can define for free!

impl<const M: usize, const N: usize, F> Tensor<M, N, F>
where
    [(); M * N]:,
    F: Add<Output = F> + Mul<Output = F> + AddAssign + Default + Copy,
{
    pub fn bilinear_map(&self, v: V<M, F>, w: V<N, F>) -> F {
        let mut sum = F::default();
        for i in 0..M {
            for j in 0..N {
                sum += v.0[j] * self.coefficients.0[i].0[j] * w.0[i];
            }
        }
        sum
    }

    /// Here, for each choice of `w`, we get a distinct linear functional on `V`
    /// that utilizes the tensor product.
    #[allow(non_snake_case)]
    pub fn get_functional_on_V(&self, w: V<N, F>) -> impl Fn(V<M, F>) -> F + '_ {
        move |v| self.bilinear_map(v, w)
    }

    /// Here, for each choice of `v`, we get a distinct linear functional on `W`
    /// that utilizes the tensor product.
    #[allow(non_snake_case)]
    pub fn get_functional_on_W(&self, v: V<M, F>) -> impl Fn(V<N, F>) -> F + '_ {
        move |w| self.bilinear_map(v, w)
    }

    /// Matrix multiplication acting from the left :)
    #[allow(non_snake_case)]
    pub fn linear_map_V_to_W(&self, v: V<M, F>) -> V<N, F> {
        let mut w = V([F::default(); N]);
        for j in 0..N {
            for i in 0..M {
                w.0[j] += self.coefficients.0[i].0[j] * v.0[j];
            }
        }
        w
    }

    /// Matrix multiplication acting from the right :)
    #[allow(non_snake_case)]
    pub fn linear_map_W_to_V(&self, w: V<N, F>) -> V<M, F> {
        let mut v = V([F::default(); M]);
        for j in 0..N {
            for i in 0..M {
                v.0[j] += self.coefficients.0[i].0[j] * w.0[i];
            }
        }
        v
    }
}

/// This implementation makes `Tensor` an "Algebra" :)
/// In other words, we can multiply M x N matrices with N x P matrices to get an
/// M x P matrix.
impl<const M: usize, const N: usize, const P: usize, F> Mul<Tensor<N, P, F>> for Tensor<M, N, F>
where
    [(); M * N]:,
    [(); N * P]:,
    F: Add<Output = F> + AddAssign + Mul<Output = F> + Default + Copy,
{
    type Output = Self;
    fn mul(self, other: Tensor<N, P, F>) -> Self::Output {
        let mut product = Tensor::default();
        for i in 0..N {
            for k in 0..P {
                for j in 0..M {
                    product.coefficients.0[j].0[k] +=
                        self.coefficients.0[i].0[j] * other.coefficients.0[j].0[k];
                }
            }
        }
        product
    }
}