simplers_optimization 0.5.0

A Rust implementation of the Simple(x) black-box optimization algorithm.
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

use std::rc::Rc;
use num_traits::Float;

/// Represents coordinates in space.
pub type Coordinates<CoordFloat> = Box<[CoordFloat]>;

/// Represents an evaluated coordinates in space.
#[derive(Clone, Debug)]
pub struct Point<CoordFloat: Float, ValueFloat: Float>
{
    pub coordinates: Coordinates<CoordFloat>,
    pub value: ValueFloat
}

impl<CoordFloat: Float, ValueFloat: Float> Point<CoordFloat, ValueFloat>
{
    /// computes the euclidian distance between two sets of coordinate
    pub fn distance(p1: &Coordinates<CoordFloat>, p2: &Coordinates<CoordFloat>) -> ValueFloat
    {
        p1.iter()
          .zip(p2.iter())
          .map(|(&x, &y)| (x - y).powi(2))
          .map(|x| ValueFloat::from(x).expect("Unable to convert from coordinate type to value type."))
          .fold(ValueFloat::zero(), ::std::ops::Add::add) // sum
          .sqrt()
    }

    /// adds the point to the coordinates and returns the coordinates
    fn add_to(&self, coordinates: &[CoordFloat]) -> Coordinates<CoordFloat>
    {
        coordinates.iter().zip(self.coordinates.iter()).map(|(&x, &y)| x + y).collect()
    }

    /// computes the average of the coordinates
    pub fn average_coordinate(points: &[Rc<Point<CoordFloat, ValueFloat>>]) -> Coordinates<CoordFloat>
    {
        let length = CoordFloat::from(points.len()).expect("Unable to convert from usize to value type.");
        let mut points = points.iter();
        let first = points.next().expect("You need at least one coordinate to average!").coordinates.clone();
        let sum = points.fold(first, |acc, x| x.add_to(&acc));
        sum.iter().map(|sum| (*sum) / length).collect()
    }
}