bin2bcd 0.0.1

Binary-BCD-Binary conversion using double-dabble algorithm
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
121
122
123
124
125

use crate::{BCD_DIGITS_3, BCD_DIGITS_34, BIN_BITS_128, BIN_BITS_8};

///
#[macro_export]
macro_rules! bcd2bin {
  ($bits:expr, $digits:expr, $size:ty, $bcd:tt) => {{
    let mut num: $size = 0;
    let mut u = 0;
    let msb: $size = 1 << $bits - 1;
    for i in 0..$digits {
      if $bcd[i] != 0 {
        break;
      }
      u += 1;
    }
    for _ in 0..$bits {
      num >>= 1;
      let mut k = $digits - 1;
      if ($bcd[k] & 0x1) == 1 {
        num |= msb;
      }
      while k > u {
        if ($bcd[k - 1] & 0x1) > 0 {
          $bcd[k] = ($bcd[k] >> 1) | 0x8;
        } else {
          $bcd[k] >>= 1;
        }
        if $bcd[k] > 7 {
          $bcd[k] -= 3;
        }
        k -= 1;
      }
      $bcd[k] >>= 1;
      if $bcd[k] > 7 {
        $bcd[k] -= 3;
      }
    }
    num
  }};
}

///
pub fn bcd2bin8(bcd: &mut [u8; BCD_DIGITS_3]) -> u8 {
  bcd2bin!(BIN_BITS_8, BCD_DIGITS_3, u8, bcd)
}

///
pub fn bcd2bin128(bcd: &mut [u8; BCD_DIGITS_34]) -> u128 {
  bcd2bin!(BIN_BITS_128, BCD_DIGITS_34, u128, bcd)
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_bin_1_digit() {
    assert_eq!(1, bcd2bin8(&mut [0, 0, 1]));
  }

  #[test]
  fn test_bin_2_digits() {
    assert_eq!(89, bcd2bin8(&mut [0, 8, 9]));
  }

  #[test]
  fn test_bin_3_digits() {
    assert_eq!(255, bcd2bin8(&mut [2, 5, 5]));
  }

  #[test]
  fn test_bin128_1_digit() {
    assert_eq!(
      1,
      bcd2bin128(&mut [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
      ])
    );
  }

  #[test]
  fn test_bin128_8_bcd() {
    assert_eq!(
      89999999,
      bcd2bin128(&mut [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 8, 9, 9, 9, 9, 9, 9, 9,
      ])
    );
  }

  #[test]
  fn test_bin128_16_bcd() {
    assert_eq!(
      8999999999999999,
      bcd2bin128(&mut [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 9, 9, 9, 9, 9,
        9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
      ])
    );
  }

  #[test]
  fn test_bin128_32_bcd() {
    assert_eq!(
      89999999999999999999999999999999,
      bcd2bin128(&mut [
        0, 0, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
        9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
      ])
    );
  }

  #[test]
  fn test_bin128_34_bcd() {
    assert_eq!(
      8999999999999999999999999999999999,
      bcd2bin128(&mut [
        8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
        9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
      ])
    );
  }
}