fibonacci_sequence 0.1.1

A module
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

pub struct FibonacciValue {
    pub index: u8,
    pub fib_value: u128,
}
pub mod lib_fibonacci {
    pub use super::*;
    /// This is one of the best solutions of the fibonacci calculating
    /// # Example
    /// ```
    /// use fibonacci_sequence::lib_fibonacci;
    /// let n:u8 = 2;
    /// let result = lib_fibonacci::kernel(n);
    /// assert_eq!(result.fib_value,2);
    /// ```
    pub fn kernel(mut n: u8) -> FibonacciValue {
        let mut value_before = FibonacciValue {
            index: 0,
            fib_value: 1,
        };
        let mut value_now = FibonacciValue {
            index: 0,
            fib_value: 1,
        };
        let mut exchange = FibonacciValue {
            index: 0,
            fib_value: 1,
        };
        let mut index: u8 = 0;
        n = n - 1;
        while n > index {
            exchange = FibonacciValue {
                index: index,
                fib_value: value_before.fib_value + value_now.fib_value,
            };
            value_before = value_now;
            value_now = exchange;
            index += 1;
        }
        return value_now;
    }
    /// This is the worest solution
    /// This solution will take up too much stack and slow
    /// # Example
    /// ```
    /// use fibonacci_sequence::lib_fibonacci;
    /// let n:u8 = 2;
    /// let result = lib_fibonacci::kernel_recursion(n);
    /// assert_eq!(result.fib_value,2);
    /// 
    /// ```
    pub fn kernel_recursion(n: u8) -> FibonacciValue {
        /* This version of kernel uses recursion so it has low efficiency */
        if n == 0 {
            return FibonacciValue {
                index: 0,
                fib_value: 1,
            };
        }
        if n == 1 {
            return FibonacciValue {
                index: 0,
                fib_value: 1,
            };
        }

        return FibonacciValue {
            index: n,
            fib_value: kernel_recursion(n - 1).fib_value + kernel_recursion(n - 2).fib_value,
        };
    }
    /// 以下是来自百度百科的方法
    fn abs(number: i128) -> i128 {
        if number > 0 {
            return number;
        } else {
            return -number;
        }
    }

    fn involution(mut number: f64, mut times: i8) -> f64 {
        let n: f64 = number;
        while abs(times.into()) > 0 {
            number *= n;
            times -= 1
        }
        if times == 0 {
            return match number {
                0.0 => 0.0,
                _ => 1.0,
            };
        }
        return number;
    }

    pub fn kernel_linear_algebra(n: u8) -> f64 {
        let result: f64 = (involution(1.618035, n.try_into().unwrap())
            - involution(-0.61803399, n.try_into().unwrap()))
            * 0.4472136;
        return result;
    }
}

pub trait Iterator {
    fn next(&mut self) -> FibonacciValue;
} 

impl Iterator for FibonacciValue {
    fn next(&mut self) -> FibonacciValue {
        return lib_fibonacci::kernel(self.index+1);
    }
}