scientific 0.5.3

Arbitrary precision scientific number (no_std capable, in pure Rust)
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::types::conversion_error::ConversionError;
use crate::types::owner::Owner;
use crate::types::ptr::Ptr;
use crate::types::sci::Sci;
use crate::types::sign::Sign;
use alloc::vec::Vec;
use core::convert::TryInto;

impl Sci {
  #[allow(clippy::too_many_lines)]
  pub(crate) fn from_bytes(bytes: &[u8]) -> Result<Sci, ConversionError> {
    if bytes.is_empty() {
      return Ok(Sci::ZERO);
    }

    let prefix = bytes[0];
    let is_negative = prefix & 0x80 != 0;
    let prefix = prefix & 0x7f;
    let exponent;
    let pos;

    if prefix < 0x3c {
      exponent = prefix as isize;
      pos = 1;
    } else if prefix >= 0x40 {
      exponent = ((prefix | 0x80) as i8) as isize;
      pos = 1;
    } else if prefix == 0x3c {
      if bytes.len() < 1 + 1 {
        return Err(ConversionError::ParseError);
      }
      exponent = (bytes[1] as i8) as isize;
      pos = 1 + 1;
    } else if prefix == 0x3d {
      if bytes.len() < 1 + 2 {
        return Err(ConversionError::ParseError);
      }
      exponent = i16::from_be_bytes(bytes[1..=2].try_into().unwrap()) as isize;
      pos = 1 + 2;
    } else {
      #[cfg(target_pointer_width = "16")]
      return Err(ConversionError::ExponentTooLargeForThisPlatform);

      #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
      if prefix == 0x3e {
        if bytes.len() < 1 + 4 {
          return Err(ConversionError::ParseError);
        }
        exponent = i32::from_be_bytes(bytes[1..=4].try_into().unwrap()) as isize;
        pos = 1 + 4;
      } else {
        #[cfg(target_pointer_width = "32")]
        return Err(ConversionError::ExponentTooLargeForThisPlatform);

        #[cfg(target_pointer_width = "64")]
        {
          if bytes.len() < 1 + 8 {
            return Err(ConversionError::ParseError);
          }
          exponent = i64::from_be_bytes(bytes[1..=8].try_into().unwrap()) as isize;
          pos = 1 + 8;
        }
      }

      #[cfg(not(any(
        target_pointer_width = "16",
        target_pointer_width = "32",
        target_pointer_width = "64"
      )))]
      compile_error!("This target_pointer_width is not yet supported, please open a issue.")
    }

    let mut owned = Vec::with_capacity(((bytes.len() - pos + 11) * 12) / 5);
    let mut buf = 0;
    let mut buf_len = 0;
    let mut it = bytes[pos..].iter();
    '_loop: loop {
      while buf_len < 10 {
        match it.next() {
          None => break '_loop,
          Some(&v) => {
            buf = (buf << 8) | u16::from(v);
            buf_len += 8;
          }
        }
      }
      buf_len -= 10;
      let v = (buf >> buf_len) & 1023;
      if v >= 1000 {
        return Err(ConversionError::ParseError);
      }
      owned.push((v / 100) as u8);
      owned.push(((v / 10) % 10) as u8);
      owned.push((v % 10) as u8);
    }
    while buf_len >= 4 {
      buf_len -= 4;
      let v = (buf >> buf_len) & 15;
      if v > 10 {
        return Err(ConversionError::ParseError);
      }
      owned.push(v as u8);
    }
    if buf_len > 0 && buf << (16 - buf_len) != 0 {
      return Err(ConversionError::ParseError);
    }
    let mut len = owned.len() as isize;
    let data = Ptr::new(owned.as_slice());
    let mut trailing_zeroes = 0;
    while len > 0 && data[len - 1] == 0 {
      len -= 1;
      trailing_zeroes += 1;
    }
    if len == 0 || *data == 0 || trailing_zeroes != calculate_trailing_zeroes(len) {
      Err(ConversionError::ParseError)
    } else {
      Ok(Sci {
        sign: Sign::new(is_negative),
        data,
        len,
        exponent,
        owner: Owner::new(owned),
      })
    }
  }
}

#[inline]
fn calculate_trailing_zeroes(len: isize) -> isize {
  // Read in bytes_ser in the section "what to do with the remaining digits?"
  // how it's handled on serialization. This is a shortcut to all the required information.
  const TRAILING_ZEROES: u32 =
      // (0 << 0) |  dig=0, buf=0
      (1 << 2) | //  dig=0, buf=2
      (1 << 4) | //  dig=0, buf=4
      // (0 << 6) |  dig=0, buf=6
      (1 << 8) | //  dig=1, buf=0
      // (0 << 10) | dig=1, buf=2
      // (0 << 12) | dig=1, buf=4
      (2 << 14) | // dig=1, buf=6
      // (0 << 16) | dig=2, buf=0
      (2 << 18) | // dig=2, buf=2
      (1 << 20) | // dig=2, buf=4
      (1 << 22)  //  dig=2, buf=6
    ;
  let dig = len % 3;
  let buf = ((len / 3) * 10) % 8;
  ((TRAILING_ZEROES >> (dig * 8 + buf)) & 3) as isize
}