relation 0.1.0

A simple library based on the mathematical concept of financial relations
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

#![no_std]

use num_traits::Signed;

/// A structural representation of a relation
///
/// Takes a relation function and a starter number.
/// Then it can calculate the next value based on the current value
///
/// The concept is based on the Mathematic Recursion and Financial Modelling concept of relations
#[derive(Debug, Copy, Clone)]
pub struct Relation<I, F> {
    current_number: I,
    relation: F,
}

impl<I: Signed + Copy, F: FnOnce(I) -> I + Copy> Relation<I, F> {
    /// Create a new [`Relation`]
    pub fn new(starter: I, relation: F) -> Self {
        Self {
            current_number: starter,
            relation,
        }
    }

    /// Calculates and returns the next number in the sequence
    pub fn calculate_next(&self) -> I {
        (self.relation)(self.current_number)
    }

    /// Calculates the next number in the sequence and updates the struct
    pub fn next(&mut self) {
        self.current_number = self.calculate_next();
    }

    /// Calls [`Relation::next`] `index` times, and then returns the result
    pub fn nth(&mut self, index: usize) -> I {
        for _ in 0..index {
            self.next();
        }

        self.current_number
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_relation() {
        let mut relation = Relation::new(1, |x| x + 1);

        assert_eq!(relation.current_number, 1);

        assert_eq!(relation.calculate_next(), 2);

        relation.next();

        assert_eq!(relation.current_number, 2);

        assert_eq!(relation.nth(100), 102)
    }

    #[test]
    fn test_float_relation() {
        let mut relation = Relation::new(1.0, |x| x + 1.);

        assert_eq!(relation.current_number, 1.);

        assert_eq!(relation.calculate_next(), 2.);

        relation.next();

        assert_eq!(relation.current_number, 2.);

        assert_eq!(relation.nth(100), 102.)
    }

    #[test]
    fn test_division() {
        let mut relation = Relation::new(1., |x| x / 2.);

        assert_eq!(relation.current_number, 1.);

        assert_eq!(relation.calculate_next(), 0.5);

        relation.next();

        assert_eq!(relation.current_number, 0.5);

        assert_eq!(relation.nth(100), 3.944304526105059_e-31);
    }

    #[test]
    fn test_multiplication() {
        let mut relation = Relation::new(1., |x| x * 2.);

        assert_eq!(relation.current_number, 1.);

        assert_eq!(relation.calculate_next(), 2.);

        relation.next();

        assert_eq!(relation.current_number, 2.);

        assert_eq!(relation.nth(100), 2.535301200456459_e30);
    }
}