aeon-tk 0.3.3

Toolkit for running finite difference simulations with adaptive mesh refinement
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

use crate::element::BasisFunction;

pub trait LinearOperator<const N: usize> {
    fn num_operations(&self) -> usize;
    fn apply(&self, i: usize, basis: &impl BasisFunction<N>) -> f64;
}

pub struct Value<const N: usize>([f64; N]);

impl<const N: usize> Value<N> {
    pub fn new(position: [f64; N]) -> Self {
        Value(position)
    }
}

impl<const N: usize> LinearOperator<N> for Value<N> {
    fn num_operations(&self) -> usize {
        1
    }

    fn apply(&self, _: usize, basis: &impl BasisFunction<N>) -> f64 {
        basis.value(self.0)
    }
}

pub struct Values<'a, const N: usize>(pub &'a [[f64; N]]);

impl<'a, const N: usize> LinearOperator<N> for Values<'a, N> {
    fn num_operations(&self) -> usize {
        self.0.len()
    }

    fn apply(&self, i: usize, basis: &impl BasisFunction<N>) -> f64 {
        basis.value(self.0[i])
    }
}

pub struct ProductValue<const N: usize>([f64; N]);

impl<const N: usize> ProductValue<N> {
    pub fn new(position: [f64; N]) -> Self {
        ProductValue(position)
    }
}

impl<const N: usize> LinearOperator<1> for ProductValue<N> {
    fn num_operations(&self) -> usize {
        N
    }

    fn apply(&self, i: usize, basis: &impl BasisFunction<1>) -> f64 {
        basis.value([self.0[i]])
    }
}