Struct Value

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

Defines the representation of the value.

Fields

mantissa: f64

Mantissa of the value after scaling.

prefix: Prefix

Prefix indicating the scale.

base: Base

Indicates if the base is 1000 or 1024.

Implementations

impl Value

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

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

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

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

impl Debug for Value

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

Formats the value using the given formatter.

impl Display for Value

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

impl From<&f32> for Value

fn from(x: &f32) -> Self

Converts to this type from the input type.

impl From<&f64> for Value

fn from(x: &f64) -> Self

Converts to this type from the input type.

impl From<&i16> for Value

fn from(x: &i16) -> Self

Converts to this type from the input type.

impl From<&i32> for Value

fn from(x: &i32) -> Self

Converts to this type from the input type.

impl From<&i8> for Value

fn from(x: &i8) -> Self

Converts to this type from the input type.

impl From<&u16> for Value

fn from(x: &u16) -> Self

Converts to this type from the input type.

impl From<&u32> for Value

fn from(x: &u32) -> Self

Converts to this type from the input type.

impl From<&u8> for Value

fn from(x: &u8) -> Self

Converts to this type from the input type.

impl From<Value> for f64

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<f32> for Value

fn from(x: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Value

fn from(x: f64) -> Self

Converts to this type from the input type.

impl From<i16> for Value

fn from(x: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Value

fn from(x: i32) -> Self

Converts to this type from the input type.

impl From<i8> for Value

fn from(x: i8) -> Self

Converts to this type from the input type.

impl From<u16> for Value

fn from(x: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Value

fn from(x: u32) -> Self

Converts to this type from the input type.

impl From<u8> for Value

fn from(x: u8) -> Self

Converts to this type from the input type.

impl PartialEq for Value

fn eq(&self, other: &Value) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Value