Enum Sequence 

#[repr(i32)]
pub enum Sequence<T>
where
    T: Add + Sub + Mul + Div<Output = T> + FromPrimitive + Zero + One + Copy + Clone,
{
    Arithmetic {
        init: T,
        difference: T,
    },
    Geometric {
        init: T,
        ratio: T,
    },
    Natural(bool),
    Odd = 4,
    Even(bool),
    Power(T),
    Triangular = 10,
    Square = 11,
    Cubic = 12,
    Harmonic {
        init: T,
        difference: T,
    },
    Fibonacci = 20,
    Lucas = 21,
    Padova = 22,
    Catalan = 29,
    LookAndSay(usize),
}

Variants

Arithmetic

Arithmetic sequence with initial value and difference

Fields

init: T

difference: T

Geometric

Geometric sequence with initial value and ratio

Fields

init: T

ratio: T

Natural(bool)

Natural sequence (starting from 1 or 0)

Odd = 4

Odd sequence starting from 1

Even(bool)

Even sequence starting from 0 or 1

Power(T)

Power sequence with specified radix

Triangular = 10

Triangular sequence

Square = 11

Square sequence

Cubic = 12

Cubic sequence

Harmonic

Harmonic sequence with initial value and difference

Fields

init: T

difference: T

Fibonacci = 20

Fibonacci sequence

Lucas = 21

Lucas sequence

Padova = 22

Padova sequence

Catalan = 29

Catalan sequence

LookAndSay(usize)

Look-and-say sequence with initial value

Implementations

impl<T> Sequence<T>

where T: Add + Sub + Mul + Div<Output = T> + FromPrimitive + Zero + One + Copy + Clone,

pub fn recursive<F>(n: usize, init: T, f: F) -> Vec<T>

where F: Fn(T) -> T,

Create a recursive sequence with specified size, initial value and customized function to compute next value

pub fn vec(self, n: usize) -> Vec<T>

Create a sequence with specified size

pub fn map<F>(self, n: usize, f: F) -> Vec<T>

where F: Fn(T) -> T,

Derive a new sequence based on specified mapping function with specified size

pub fn fold<F>(self, n: usize, start: i32, end: i32, f: F) -> Vec<T>

where F: Fn(&[Option<T>]) -> T,

Derive a new sequence based on specified folding function with specified size. The folding function accept a slice of optional values, where None indicates out-of-range.