rpg_stat/
equation.rs

1/*!# Math
2This contains functions to deal with `T` in ways that don't invovle long num::cast().unwrap() operations.
3```
4use rpg_stat::equation::Math;
5let t:i32 = 16;
6assert_eq!(8, Math::half(t));
7assert_eq!(4, Math::quarter(t));
8assert_eq!(12, Math::three_quarters(t));
9assert_eq!(32, Math::double(t));
10let numbers:Vec<i32> = vec![2, 4, 6, 8, 10, 12];
11assert_eq!(7, Math::mean(numbers.clone()));
12assert_eq!(12, Math::sqrt(144));
13
14```
15*/
16use std::fmt;
17use std::fmt::Debug;
18use std::fmt::Display;
19use serde::{Deserialize, Serialize};
20use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign};
21extern crate num;
22
23#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
24pub enum Equation<T:Copy 
25                 + Default
26                 + Display
27                 + AddAssign
28                 + Add<Output = T>
29                 + Div<Output = T>
30                 + DivAssign
31                 + Mul<Output = T>
32                 + MulAssign
33                 + Neg<Output = T>
34                 + Rem<Output = T>
35                 + RemAssign
36                 + Sub<Output = T>
37                 + SubAssign
38                 + std::cmp::PartialOrd
39                 + std::cmp::PartialEq
40                 + num::NumCast> {
41    AddRight(Operation<T>, T),
42    AddLeft(T, Operation<T>),
43    Subtract(T, T),
44    Multiply(T, T),
45    Divide(T, T),
46    Power(T, T),
47}
48impl<T:Copy 
49    + Default
50    + Display
51    + AddAssign
52    + Add<Output = T>
53    + Div<Output = T>
54    + DivAssign
55    + Mul<Output = T>
56    + MulAssign
57    + Neg<Output = T>
58    + Rem<Output = T>
59    + RemAssign
60    + Sub<Output = T>
61    + SubAssign
62    + std::cmp::PartialOrd
63    + std::cmp::PartialEq
64    + num::NumCast> Equation<T> {
65    /// 
66    #[allow(dead_code)]
67    pub fn result(&self) -> T {
68        match *self {
69            Equation::AddRight(op, val) => {
70                op.result() + val
71            },
72            _=> Default::default(),
73        }
74    }
75}
76impl<T:Copy 
77    + Default
78    + Display
79    + AddAssign
80    + Add<Output = T>
81    + Div<Output = T>
82    + DivAssign
83    + Mul<Output = T>
84    + MulAssign
85    + Neg<Output = T>
86    + Rem<Output = T>
87    + RemAssign
88    + Sub<Output = T>
89    + SubAssign
90    + std::cmp::PartialOrd
91    + std::cmp::PartialEq
92    + num::NumCast> fmt::Display for Equation<T> {
93    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
94match *self {
95            Equation::AddRight(op, val) => write!(f, "({}) + {}", op, val),
96            Equation::AddLeft(val, op) => write!(f, "{} + ({})", val, op),
97            _=> write!(f, ""),
98        }
99    }
100}
101#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
102pub enum Operation<T:Copy 
103                 + Default
104                 + Display
105                 + AddAssign
106                 + Add<Output = T>
107                 + Div<Output = T>
108                 + DivAssign
109                 + Mul<Output = T>
110                 + MulAssign
111                 + Neg<Output = T>
112                 + Rem<Output = T>
113                 + RemAssign
114                 + Sub<Output = T>
115                 + SubAssign
116                 + std::cmp::PartialOrd
117                 + std::cmp::PartialEq
118                 + num::NumCast> {
119    Add(T, T),
120    Subtract(T, T),
121    Multiply(T, T),
122    Divide(T, T),
123    Power(T, T),
124    None(T),
125}
126impl<T:Copy 
127    + Default
128    + Display
129    + AddAssign
130    + Add<Output = T>
131    + Div<Output = T>
132    + DivAssign
133    + Mul<Output = T>
134    + MulAssign
135    + Neg<Output = T>
136    + Rem<Output = T>
137    + RemAssign
138    + Sub<Output = T>
139    + SubAssign
140    + std::cmp::PartialOrd
141    + std::cmp::PartialEq
142    + num::NumCast> Default for Operation<T> {
143    fn default() -> Self {
144        Self::None(Default::default())
145    }
146}
147impl<T:Copy 
148    + Default
149    + Display
150    + AddAssign
151    + Add<Output = T>
152    + Div<Output = T>
153    + DivAssign
154    + Mul<Output = T>
155    + MulAssign
156    + Neg<Output = T>
157    + Rem<Output = T>
158    + RemAssign
159    + Sub<Output = T>
160    + SubAssign
161    + std::cmp::PartialOrd
162    + std::cmp::PartialEq
163    + num::NumCast> Operation<T> {
164    /// 
165    #[allow(dead_code)]
166    pub fn result(&self) -> T {
167        match *self {
168            Operation::Add(a, b) => {
169                a + b
170            },
171            Operation::Subtract(a, b) => {
172                a - b
173            },
174            Operation::Multiply(a, b) => {
175                a * b
176            },
177            Operation::Divide(a, b) => {
178                a / b
179            },
180            Operation::Power(a, b) => {
181                let mut result:T = a;
182                let mut iter:T = b;
183                iter -= num::cast(1).unwrap();
184                let nada:T = num::cast(0).unwrap();
185                while iter > nada {
186                    result *= a;
187                    iter -= num::cast(1).unwrap();
188                }
189                result
190            },
191            Operation::None(a) => a,
192        }
193    }
194}
195impl<T:Copy 
196    + Default
197    + Display
198    + AddAssign
199    + Add<Output = T>
200    + Div<Output = T>
201    + DivAssign
202    + Mul<Output = T>
203    + MulAssign
204    + Neg<Output = T>
205    + Rem<Output = T>
206    + RemAssign
207    + Sub<Output = T>
208    + SubAssign
209    + std::cmp::PartialOrd
210    + std::cmp::PartialEq
211    + num::NumCast> fmt::Display for Operation<T> {
212    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
213        let v:String;
214        let first:T;
215        let second:T;
216        match *self {
217            Operation::Add(a, b) => {
218                first = a;
219                second = b;
220                v = String::from("+");
221            },
222            Operation::Subtract(a, b) => {
223                first = a;
224                second = b;
225                v = String::from("-");
226            },
227            Operation::Multiply(a, b) => {
228                first = a;
229                second = b;
230                v = String::from("*");
231            },
232            Operation::Divide(a, b) => {
233                first = a;
234                second = b;
235                v = String::from("/");
236            },
237            Operation::Power(a, b) => {
238                first = a;
239                second = b;
240                v = String::from("^");
241            },
242            Operation::None(a) => {
243                first = a;
244                return write!(f, "{}", first)
245            },
246            //Operation::(a, b) => {first = a;second = b;v = String::from("");},
247            
248
249        }
250        write!(f, "{} {} {}", first, v.as_str(), second)
251    }
252}
253#[allow(unused)]
254pub struct Math <T:Copy 
255                 + Default
256                 + AddAssign
257                 + Add<Output = T>
258                 + Div<Output = T>
259                 + DivAssign
260                 + Mul<Output = T>
261                 + MulAssign
262                 + Neg<Output = T>
263                 + Rem<Output = T>
264                 + RemAssign
265                 + Sub<Output = T>
266                 + SubAssign
267                 + std::cmp::PartialOrd
268                 + std::cmp::PartialEq
269                 + num::NumCast> {
270    pub answer:T,
271    pub question:String,
272}
273impl <T:Copy 
274    + Default
275    + AddAssign
276    + Add<Output = T>
277    + Div<Output = T>
278    + DivAssign
279    + Mul<Output = T>
280    + MulAssign
281    + Neg<Output = T>
282    + Rem<Output = T>
283    + RemAssign
284    + Sub<Output = T>
285    + SubAssign
286    + std::cmp::PartialOrd
287    + std::cmp::PartialEq
288    + num::NumCast> Math<T> {
289    /// `e = m * (c * c)`
290    #[allow(unused)]
291    pub fn e_mc2 (m:T, c:T) -> T {
292        m * (c * c)
293    }
294/*
295
296*/
297    #[allow(unused)]
298    pub fn patterns(begin:T, end:T, number_of_entries:usize) -> Vec<T> {
299        //30% digit one is 1
300        // exponentially less for each number
301        let mut ret_vec:Vec<T> = vec![];
302        /*let mut tracker = begin;
303        for 0..number_of_entries {
304            if value < num::cast(30).unwrap() {
305                
306            }
307        }*/
308        ret_vec
309    }
310/*
311Divide a number to three quarters
312*/
313    #[allow(unused)]
314    pub fn three_quarters(number: T) -> T {
315        let four = num::cast(4).unwrap();
316        let three = num::cast(3).unwrap();
317        (number / four) * three
318    }
319/*
320Divide a number to one quarter
321*/
322    #[allow(unused)]
323    pub fn quarter(number: T) -> T {
324        let four = num::cast(4).unwrap();
325        number / four
326    }
327/*
328Divide a number in half
329*/
330    #[allow(unused)]
331    pub fn half(number: T) -> T {
332        let two = num::cast(2).unwrap();
333        number / two
334    }
335/*
336Double a number
337*/
338    #[allow(unused)]
339    pub fn double(number: T) -> T {
340        let two = num::cast(2).unwrap();
341        number * two
342    }
343/*
344Get one and one half back
345*/
346    #[allow(unused)]
347    pub fn half_extra(number: T) -> T {
348        let two = num::cast(2).unwrap();
349        (number / two) + number
350    }
351/*
352Not sure if this is the best equation to use, but it works...
353*/
354    #[allow(unused)]
355    pub fn sqrt(number: T) -> T {
356        let mut num:T = num::cast::<u32, T>(0).unwrap();
357        let one:T = num::cast::<u32, T>(1).unwrap();
358        while num < number {
359            if num * num == number {
360                return num;
361            }
362            num += one;
363        }
364        T::default()
365    }
366    #[allow(unused)]
367    pub fn population_standard_deviation(numbers:Vec<T>) -> T {
368        Math::sqrt(Math::variance(numbers))
369    }
370
371    #[allow(unused)]
372    pub fn variance(numbers:Vec<T>) -> T {
373        let mean:T = Math::mean(numbers.clone());
374        let mut total:T = T::default();
375        let mut counter:T = T::default();
376        for number in numbers {
377            counter += num::cast(1).unwrap();
378            let result:T = number - mean;
379            total += result * result
380        }
381        total / counter
382    }
383    #[allow(unused)]
384    pub fn mean(numbers:Vec<T>) -> T {
385        let mut total:T = num::cast(0).unwrap();
386        let mut total_count:T = num::cast(0).unwrap();
387        for number in numbers {
388            total += number;
389            total_count += num::cast(1).unwrap();
390        }
391        total / total_count
392    }
393    
394}
rpg_stat/equation.rs

rpg_stat/
equation.rs
