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

use scientific::{ConversionError, Scientific};
use std::str::FromStr;

#[test]
fn conversion_error() {
  // FloatIsNotFinite
  assert_eq!(
    Scientific::try_from(f32::NAN),
    Err(ConversionError::FloatIsNotFinite)
  );
  assert_eq!(
    Scientific::try_from(f32::INFINITY),
    Err(ConversionError::FloatIsNotFinite)
  );
  assert_eq!(
    Scientific::try_from(f64::NEG_INFINITY),
    Err(ConversionError::FloatIsNotFinite)
  );
  assert_eq!(
    Scientific::try_from(f64::NAN),
    Err(ConversionError::FloatIsNotFinite)
  );
  assert_eq!(
    Scientific::try_from(f64::INFINITY),
    Err(ConversionError::FloatIsNotFinite)
  );
  assert_eq!(
    Scientific::try_from(f64::NEG_INFINITY),
    Err(ConversionError::FloatIsNotFinite)
  );

  // NumberTooLarge
  assert_eq!(
    i8::try_from(&Scientific::from_str("500").unwrap()),
    Err(ConversionError::NumberTooLarge)
  );
  assert_eq!(
    i8::try_from(&Scientific::from_str("-500").unwrap()),
    Err(ConversionError::NumberTooLarge)
  );
  // NumberTooLarge
  assert_eq!(
    u8::try_from(&Scientific::from_str("500").unwrap()),
    Err(ConversionError::NumberTooLarge)
  );

  // ParseError
  assert_eq!(
    Scientific::from_raw_parts(false, vec![15], 0),
    Err(ConversionError::ParseError)
  );
  assert_eq!(Scientific::from_str(""), Err(ConversionError::ParseError));
  assert_eq!(Scientific::from_str("-"), Err(ConversionError::ParseError));
  assert_eq!(Scientific::from_str("@"), Err(ConversionError::ParseError));
  assert_eq!(Scientific::from_str("5@"), Err(ConversionError::ParseError));
  assert_eq!(Scientific::from_str("5e"), Err(ConversionError::ParseError));
  assert_eq!(
    Scientific::from_str("5e@"),
    Err(ConversionError::ParseError)
  );
  assert_eq!(Scientific::from_str("."), Err(ConversionError::ParseError));

  // NumberIsNegative
  assert_eq!(
    u8::try_from(&Scientific::from_str("-50").unwrap()),
    Err(ConversionError::NumberIsNegative)
  );

  // NumberIsNegative
  assert_eq!(
    u8::try_from(&Scientific::from_str("55.55").unwrap()),
    Err(ConversionError::NumberIsNotAnInteger)
  );
  assert_eq!(
    i8::try_from(&Scientific::from_str("55.55").unwrap()),
    Err(ConversionError::NumberIsNotAnInteger)
  );

  // deserialization error
  for bytes in [
    vec![0x3c],
    vec![0x3d],
    vec![0x3d, 0x00],
    vec![0x3e],
    vec![0x3f],
    vec![0x00, 0xff, 0xc0], // value "1023" (3 digits), "0" (1 digit), 0b00 padding
    vec![0x00, 0xff],       // value "15" (1 digit), "15" (1 digit)
    vec![0x00, 0x1e, 0xc1], // value "123" (3 digits), "0" (1 digit), 0b01 padding
    vec![0x00],             // len==0
    vec![0x00, 0x18, 0xc0], // *data==0: value "099" (3 digits), "0" (1 digit), 0b00 padding
    vec![0x00, 0x7d, 0x00], // trailing zeroes: value "500" (3 digits), "0" (1 digit), 0b00 padding
  ] {
    assert_eq!(
      Scientific::from_bytes(&bytes),
      Err(ConversionError::ParseError)
    );
  }

  // text
  assert_eq!(
    &ConversionError::FloatIsNotFinite.to_string(),
    "Float is not finite"
  );
  assert_eq!(
    &ConversionError::NumberTooLarge.to_string(),
    "Number too large"
  );
  assert_eq!(&ConversionError::ParseError.to_string(), "Parse error");
  assert_eq!(
    &ConversionError::NumberIsNegative.to_string(),
    "Number is negative"
  );
  assert_eq!(
    &ConversionError::NumberIsNotAnInteger.to_string(),
    "Number is not an integer"
  );
  assert_eq!(
    &ConversionError::ExponentTooLargeForThisPlatform.to_string(),
    "Exponent is too large for this platform"
  );
}