Struct si_scale::value::Value[−][src]

pub struct Value {
    pub mantissa: f64,
    pub prefix: Prefix,
    pub base: Base,
}

Expand description

Represents a float value using its mantissa and unit Prefix in a base.

With base = 1000, 1k = 1000, 1M = 1_000_000, 1m = 0.001, 1µ = 0.000_001, etc.

min (incl.)	max (excl.)	magnitude	prefix
..	..	-24	`Prefix::Yocto`
..	..	-21	`Prefix::Zepto`
..	..	-18	`Prefix::Atto`
..	..	-15	`Prefix::Femto`
..	..	-12	`Prefix::Pico`
..	..	-9	`Prefix::Nano`
0.000_001	0.001	-6	`Prefix::Micro`
0.001	1	-3	`Prefix::Milli`
1	1_000	0	`Prefix::Unit`
1000	1_000_000	3	`Prefix::Kilo`
1_000_000	1_000_000_000	6	`Prefix::Mega`
..	..	9	`Prefix::Giga`
..	..	12	`Prefix::Tera`
..	..	15	`Prefix::Peta`
..	..	18	`Prefix::Exa`
..	..	21	`Prefix::Zetta`
..	..	24	`Prefix::Yotta`

The base is usually 1000, but can also be 1024 (bibytes).

With base = 1024, 1ki = 1024, 1Mi = 1024 * 1024, etc.

Example

use std::convert::From;
use si_scale::{base::Base, value::Value, prefix::Prefix};

let actual = Value::from(0.123);
let expected = Value {
    mantissa: 123f64,
    prefix: Prefix::Milli,
    base: Base::B1000,
};
assert_eq!(actual, expected);

Fields

mantissa: f64prefix: Prefixbase: Base

Implementations

[src]

impl Value

[src]

pub fn new<F>(x: F) -> Self where
F: Into<f64>,

Returns a Value for the default base B1000, meaning 1 k = 1000, 1 m = 1e-3, etc.

Example

use si_scale::prelude::{Base, Prefix, Value};

let actual = Value::new(-4.6e-5);
let expected = Value {
    mantissa: -46f64,
    prefix: Prefix::Micro,
    base: Base::B1000,
};
assert_eq!(actual, expected);

Note

As always the case in floating point operations, you may encounter approximate representations. For instance:

use si_scale::prelude::{Base, Prefix, Value};

let actual = Value::new(-4.3e-5);
let expected = Value {
    mantissa: -43.00000000000001f64,
    prefix: Prefix::Micro,
    base: Base::B1000,
};
assert_eq!(actual, expected);

[src]

pub fn new_with<F, C>(x: F, base: Base, prefix_constraint: C) -> Self where
F: Into<f64>,
C: AsRef<Constraint>,

Returns a Value for the provided base.

Example

use si_scale::prelude::{Constraint, Base, Prefix, Value};

// 4 MiB
let actual = Value::new_with(4 * 1024 * 1024, Base::B1024, Constraint::None);
let expected = Value {
    mantissa: 4f64,
    prefix: Prefix::Mega,
    base: Base::B1024,
};
assert_eq!(actual, expected);

[src]

pub fn to_f64(&self) -> f64

Converts self to a f64.

Example

use si_scale::prelude::{Base, Prefix, Value};

let value = Value {
    mantissa: 1.3f64,
    prefix: Prefix::Unit,
    base: Base::B1000,
};
assert_eq!(value.to_f64(), 1.3);

[src]

pub fn signum(&self) -> f64

Returns a number that represents the sign of self.

1.0 if the number is positive, +0.0 or INFINITY
-1.0 if the number is negative, -0.0 or NEG_INFINITY
NAN if the number is NAN

Example

use std::convert::From;
use si_scale::value::Value;

let number = -1.5e3f32;
let value: Value = number.into();

assert_eq!(value.signum(), number.signum() as f64);

Trait Implementations

[src]

impl Debug for Value

[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

[src]

impl Display for Value

[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result

A basic but limited way to display the value; it does not allow mantissa formatting. Consider using the format_value!() macro instead.

Example

use std::convert::From;
use si_scale::prelude::Value;

let value: Value = 5.3e5.into();

let actual = format!("{}", value);
let expected = "530 k".to_string();
assert_eq!(actual, expected);