convolve-nd 0.1.0

A small library to perform convolution operations on arrays of upto 3 dimensions using arbitrarily-sized separable kernels
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

use ndarray::{Array1, Array2, Array3};
use crate::array::Aggregate;

#[derive(Copy, Clone)]
pub enum RescaleRange {
    Custom(f32, f32),
    Max,
}

impl RescaleRange {
    fn min(self) -> f32 {
        match self {
            RescaleRange::Custom(min, _) => min,
            RescaleRange::Max => 0.
        }
    }

    fn max(self) -> f32 {
        match self {
            RescaleRange::Custom(_, max) => max,
            RescaleRange::Max => 1.
        }
    }
}

pub trait Rescale {
    fn min(&self) -> f32;
    fn max(&self) -> f32;
    fn rescale(&mut self, range: RescaleRange);
    fn rescale_value(min: f32, max: f32, value: f32, range: RescaleRange) -> f32 {
        let (new_min, new_max) = (range.min(), range.max());
        let new_range = new_max - new_min;

        new_min + ((value - min) * new_range / (max - min))
    }
}

macro_rules! impl_rescale {
    ($ty:ty) => {
        impl Rescale for $ty {
            fn min(&self) -> f32 {
                Aggregate::min(self)
            }

            fn max(&self) -> f32 {
                Aggregate::max(self)
            }

            fn rescale(&mut self, range: RescaleRange) {
                let min = Rescale::min(self);
                let max = Rescale::max(self);

                for item in self.iter_mut() {
                    *item = Self::rescale_value(min, max, *item, range);
                }
            }
        }
    };
}

impl_rescale!(Array1<f32>);
impl_rescale!(Array2<f32>);
impl_rescale!(Array3<f32>);