parametrizer 1.2.0

A simple, safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions.
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
110
111
112
113
114
115
116
117
118
119
120
121

use crate::Number;
use super::Term;

///An enum defining the different operations supported by sequence terms
pub enum SequenceOperations
{

    Addition,
    Multiplication

}

///A term which takes in a vector of terms and combines them together with an operator (i.e. +, *)
pub struct SequenceTerm<T: Number>
{

    terms: Vec<Box<dyn Term<T> + Send + Sync>>,
    operation: SequenceOperations

}

impl<T: Number> SequenceTerm<T>
{

    ///Creates a sequence term from the list of terms and the given operation
    ///
    /// # Examples
    ///
    /// ```
    /// use crate::parametrizer::term::constantterm::ConstantTerm;
    /// use crate::parametrizer::term::variableterm::VariableTerm;
    /// use crate::parametrizer::term::sequenceterm::SequenceOperations;
    /// use crate::parametrizer::term::sequenceterm::SequenceTerm;
    /// use crate::parametrizer::term::Term;
    ///
    /// let const1 = Box::new(ConstantTerm::new(13));
    /// let const2 = Box::new(ConstantTerm::new(5));
    /// let variable = Box::new(VariableTerm::new());
    ///
    /// let terms : Vec<Box<dyn Term<i32> + Send + Sync>> = vec![const1, const2, variable];
    ///
    /// let addition = SequenceTerm::new(terms, SequenceOperations::Addition);
    ///
    /// assert_eq!(19, addition.evaluate(1));
    /// assert_eq!(24, addition.evaluate(6));
    /// ```
    ///
    /// ```
    /// use crate::parametrizer::term::constantterm::ConstantTerm;
    /// use crate::parametrizer::term::variableterm::VariableTerm;
    /// use crate::parametrizer::term::sequenceterm::SequenceOperations;
    /// use crate::parametrizer::term::sequenceterm::SequenceTerm;
    /// use crate::parametrizer::term::Term;
    ///
    /// let const1 = Box::new(ConstantTerm::new(13));
    /// let const2 = Box::new(ConstantTerm::new(5));
    /// let variable = Box::new(VariableTerm::new());
    ///
    /// let terms : Vec<Box<dyn Term<i32> + Send + Sync>> = vec![const1, const2, variable];
    ///
    /// let addition = SequenceTerm::new(terms, SequenceOperations::Multiplication);
    ///
    /// assert_eq!(65, addition.evaluate(1));
    /// assert_eq!(390, addition.evaluate(6)); 
    /// ```
    pub fn new(terms: Vec<Box<dyn Term<T> + Send + Sync>>, operation: SequenceOperations) -> SequenceTerm<T>
    {

        return SequenceTerm {terms, operation};

    }

    fn unit(&self) -> T
    {

        match self.operation
        {

            SequenceOperations::Addition => T::zero(),
            SequenceOperations::Multiplication => T::one()

        }

    }

    fn compound(&self, l: T, r: T) -> T
    {

        match self.operation
        {

            SequenceOperations::Addition => l + r,
            SequenceOperations::Multiplication => l * r

        }

    }

}

impl<T: Number> Term<T> for SequenceTerm<T>
{

    ///Adds/multiplies together all of the terms
    fn evaluate(&self, t: T) -> T
    {

        let mut computed = self.unit();

        for term in &self.terms
        {

            computed = self.compound(computed, term.evaluate(t));

        }

        return computed;

    }

}