sciforge 0.0.3

A comprehensive scientific computing library in pure Rust with zero dependencies
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

pub fn michaelis_menten(s: f64, vmax: f64, km: f64) -> f64 {
    vmax * s / (km + s)
}

pub fn michaelis_menten_competitive(s: f64, vmax: f64, km: f64, inhibitor: f64, ki: f64) -> f64 {
    let km_app = km * (1.0 + inhibitor / ki);
    vmax * s / (km_app + s)
}

pub fn michaelis_menten_uncompetitive(s: f64, vmax: f64, km: f64, inhibitor: f64, ki: f64) -> f64 {
    let factor = 1.0 + inhibitor / ki;
    vmax * s / (km + factor * s)
}

pub fn michaelis_menten_noncompetitive(s: f64, vmax: f64, km: f64, inhibitor: f64, ki: f64) -> f64 {
    let factor = 1.0 + inhibitor / ki;
    vmax * s / (factor * (km + s))
}

pub fn hill_equation(s: f64, vmax: f64, k: f64, n: f64) -> f64 {
    let sn = s.powf(n);
    vmax * sn / (k.powf(n) + sn)
}

pub fn lineweaver_burk(s: &[f64], v: &[f64]) -> (f64, f64) {
    let n = s.len();
    let mut sum_x = 0.0;
    let mut sum_y = 0.0;
    let mut sum_xy = 0.0;
    let mut sum_xx = 0.0;
    for i in 0..n {
        let x = 1.0 / s[i];
        let y = 1.0 / v[i];
        sum_x += x;
        sum_y += y;
        sum_xy += x * y;
        sum_xx += x * x;
    }
    let nf = n as f64;
    let slope = (nf * sum_xy - sum_x * sum_y) / (nf * sum_xx - sum_x * sum_x);
    let intercept = (sum_y - slope * sum_x) / nf;
    let vmax = 1.0 / intercept;
    let km = slope * vmax;
    (vmax, km)
}

pub fn eadie_hofstee(v: &[f64], s: &[f64]) -> (f64, f64) {
    let n = v.len();
    let mut sum_x = 0.0;
    let mut sum_y = 0.0;
    let mut sum_xy = 0.0;
    let mut sum_xx = 0.0;
    for i in 0..n {
        let x = v[i] / s[i];
        let y = v[i];
        sum_x += x;
        sum_y += y;
        sum_xy += x * y;
        sum_xx += x * x;
    }
    let nf = n as f64;
    let slope = (nf * sum_xy - sum_x * sum_y) / (nf * sum_xx - sum_x * sum_x);
    let intercept = (sum_y - slope * sum_x) / nf;
    let vmax = intercept;
    let km = -slope;
    (vmax, km)
}

pub fn kcat(vmax: f64, e_total: f64) -> f64 {
    vmax / e_total
}

pub fn catalytic_efficiency(kcat_val: f64, km: f64) -> f64 {
    kcat_val / km
}