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

use crate::{KernelError, PositiveDefiniteKernel};
use opensrdk_symbolic_computation::Expression;
use rayon::prelude::*;
use std::fmt::Debug;

pub trait Convolutable {
    fn parts_len(&self) -> usize;
    fn part(&self, index: usize) -> &Expression;
}

impl Convolutable for Expression {
    fn parts_len(&self) -> usize {
        1
    }

    fn part(&self, _: usize) -> &Expression {
        self
    }
}

#[derive(Clone, Debug)]
pub struct Convolutional<K>
where
    K: PositiveDefiniteKernel,
{
    kernel: K,
}

impl<K> Convolutional<K>
where
    K: PositiveDefiniteKernel,
{
    pub fn new(kernel: K) -> Self {
        Self { kernel }
    }

    pub fn kernel_ref(&self) -> &K {
        &self.kernel
    }
}

impl<K> PositiveDefiniteKernel for Convolutional<K>
where
    K: PositiveDefiniteKernel,
{
    fn params_len(&self) -> usize {
        self.kernel.params_len()
    }

    fn expression(
        &self,
        x: Expression,
        x_prime: Expression,
        params: &[Expression],
    ) -> Result<Expression, KernelError> {
        if params.len() != self.kernel.params_len() {
            return Err(KernelError::ParametersLengthMismatch.into());
        }
        let p = x.parts_len();
        if p != x_prime.parts_len() {
            return Err(KernelError::InvalidArgument.into());
        }

        todo!()

        // let fx = (0..p)
        //     .into_par_iter()
        //     .map(|pi| {
        //         let expression = self
        //             .kernel
        //             .expression(x.part(pi).clone(), x_prime.part(pi).clone(), params)
        //             .unwrap();
        //         expression
        //     })
        //     .sum::<Result<Expression, KernelError>>()?;

        // Ok(fx)
    }
}

// #[cfg(test)]
// mod tests {
//     use crate::*;
//     #[test]
//     fn it_works() {
//         let kernel = Convolutional::new(RBF);

//         let test_value = kernel.value(&[1.0], &vec![0.0, 0.0, 0.0], &vec![0.0, 0.0, 0.0]);

//         match test_value {
//             Err(KernelError::ParametersLengthMismatch) => (),
//             _ => panic!(),
//         };
//     }
// }