numerical_analysis 0.1.2

A collection of algorithms for numerical analysis.
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

#![cfg_attr(target_arch = "spirv", no_std)]

#[cfg(feature = "std")]
pub use crate::fast_sweeping::fast_sweeping;

#[cfg(feature = "std")]
pub mod differential_operators;
#[cfg(feature = "std")]
pub mod fast_sweeping;
pub mod fourier;
pub mod legendre;
pub mod legendre_roots;
#[cfg(feature = "std")]
pub mod multilinear;
#[cfg(feature = "std")]
pub mod sampler;

use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};

use num_traits::Float;

#[cfg(not(feature = "std"))]
type EvalResult<S> = [S; 0];
#[cfg(feature = "std")]
type EvalResult<S> = Vec<S>;

pub trait RealField:
    Default
    + Add
    + Sub
    + Mul
    + Div
    + AddAssign
    + DivAssign
    + SubAssign
    + MulAssign
    + Float
    + 'static
{
}

impl<S> RealField for S where
    S: Default
        + Add
        + Sub
        + Mul
        + Div
        + AddAssign
        + DivAssign
        + SubAssign
        + MulAssign
        + Float
        + 'static
{
}

pub fn factorial(n: usize) -> usize
{
    match n
    {
        0 => 1,
        1 => 1,
        2 => 2,
        3 => 6,
        4 => 24,
        5 => 120,
        6 => 720,
        7 => 5_040,
        8 => 40_320,
        9 => 362_880,
        10 => 3_628_800,
        11 => 39_916_800,
        12 => 479_001_600,
        #[cfg(target_pointer_width = "64")]
        13 => 6_227_020_800,
        #[cfg(target_pointer_width = "64")]
        14 => 87_178_291_200,
        #[cfg(target_pointer_width = "64")]
        15 => 1_307_674_368_00,
        #[cfg(target_pointer_width = "64")]
        16 => 20_922_789_888_000,
        #[cfg(target_pointer_width = "64")]
        17 => 355_687_428_096_000,
        #[cfg(target_pointer_width = "64")]
        18 => 6_402_373_705_728_000,
        #[cfg(target_pointer_width = "64")]
        19 => 121_645_100_408_832_000,
        #[cfg(target_pointer_width = "64")]
        20 => 2_432_902_008_176_640_000,
        #[cfg(feature = "std")]
        _ => panic!("Integer {}! is too large for 64 bit representations.", n),
        #[cfg(not(feature = "std"))]
        _ => usize::MAX,
    }
}

fn to_index<const K: usize>(tuple: &[usize; K]) -> usize
{
    let mut offset = tuple[0];
    let mut cumulative_sum = offset;
    for i in 1..K
    {
        cumulative_sum += 1 + tuple[i];

        offset += binomial(cumulative_sum, i + 1);
    }

    offset
}

/// N chose K formula.
pub fn binomial(n: usize, k: usize) -> usize
{
    if n < k
    {
        return 0;
    };

    factorial(n) / (factorial(k) * factorial(n - k))
}