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

pub fn and_gate(a: bool, b: bool) -> bool {
    a && b
}
pub fn or_gate(a: bool, b: bool) -> bool {
    a || b
}
pub fn not_gate(a: bool) -> bool {
    !a
}
pub fn nand_gate(a: bool, b: bool) -> bool {
    !(a && b)
}
pub fn nor_gate(a: bool, b: bool) -> bool {
    !(a || b)
}
pub fn xor_gate(a: bool, b: bool) -> bool {
    a ^ b
}
pub fn xnor_gate(a: bool, b: bool) -> bool {
    !(a ^ b)
}

pub fn half_adder(a: bool, b: bool) -> (bool, bool) {
    (a ^ b, a && b)
}

pub fn full_adder(a: bool, b: bool, cin: bool) -> (bool, bool) {
    let (s1, c1) = half_adder(a, b);
    let (sum, c2) = half_adder(s1, cin);
    (sum, c1 || c2)
}

pub fn ripple_carry_adder(a: &[bool], b: &[bool]) -> (Vec<bool>, bool) {
    let n = a.len();
    let mut sum = vec![false; n];
    let mut carry = false;
    for i in 0..n {
        let (s, c) = full_adder(a[i], b[i], carry);
        sum[i] = s;
        carry = c;
    }
    (sum, carry)
}

pub fn multiplexer_2to1(a: bool, b: bool, sel: bool) -> bool {
    if sel { b } else { a }
}

pub fn demultiplexer_1to2(input: bool, sel: bool) -> (bool, bool) {
    if sel { (false, input) } else { (input, false) }
}

pub fn decoder_2to4(a: bool, b: bool) -> [bool; 4] {
    let mut out = [false; 4];
    let idx = (b as usize) * 2 + a as usize;
    out[idx] = true;
    out
}

pub fn encoder_4to2(inputs: &[bool; 4]) -> (bool, bool) {
    for i in (0..4).rev() {
        if inputs[i] {
            return (i & 1 != 0, i & 2 != 0);
        }
    }
    (false, false)
}

pub fn sr_latch(s: bool, r: bool, q_prev: bool) -> bool {
    if s && !r {
        true
    } else if !s && r {
        false
    } else {
        q_prev
    }
}

pub fn d_flip_flop(d: bool, _: bool) -> bool {
    d
}

pub fn jk_flip_flop(j: bool, k: bool, q_prev: bool) -> bool {
    match (j, k) {
        (false, false) => q_prev,
        (false, true) => false,
        (true, false) => true,
        (true, true) => !q_prev,
    }
}

pub fn binary_to_gray(binary: u32) -> u32 {
    binary ^ (binary >> 1)
}

pub fn gray_to_binary(gray: u32) -> u32 {
    let mut binary = gray;
    let mut mask = gray >> 1;
    while mask != 0 {
        binary ^= mask;
        mask >>= 1;
    }
    binary
}

pub fn ones_complement(val: u32, bits: u32) -> u32 {
    val ^ ((1 << bits) - 1)
}

pub fn twos_complement(val: u32, bits: u32) -> u32 {
    (ones_complement(val, bits)).wrapping_add(1) & ((1 << bits) - 1)
}