Struct Scales

pub struct Scales { /* private fields */ }

Scale numbers.

Implementations

impl Scales

pub fn new(base: u16, units: Vec<&'static str>) -> Result<Self, Error>

Create a new scale.

If a unit is longer than the supported length, an error will be returned.

pub fn none() -> Self

Create a scale which is dummy and does not scale.

pub fn short() -> Self

The default scaling method.

Based on a short scale the scaling uses base 1000. The units are meant to be used to denote magnitude of the number, so the empty base is empty.

Example

let mut f = Formatter::default()
            .scales(Scales::short())
            .precision(Precision::Decimals(1));
assert_eq!(f.fmt(12.34e0), "12.3");
assert_eq!(f.fmt(12.34e3), "12.3 K");
assert_eq!(f.fmt(12.34e6), "12.3 M");
assert_eq!(f.fmt(12.34e9), "12.3 B");
assert_eq!(f.fmt(12.34e12), "12.3 T");
assert_eq!(f.fmt(12.34e15), "12.3 P");
assert_eq!(f.fmt(12.34e18), "12.3 E");
assert_eq!(f.fmt(12.34e21), "12.3 Z");
assert_eq!(f.fmt(12.34e24), "12.3 Y");
assert_eq!(f.fmt(12.34e27), "12,339.9 Y");

pub fn metric() -> Self

Create a metric SI scale.

The SI scale steps with base 1000. It is intended for use as a units prefix, so the empty base contains a space.

Example

let mut f = Formatter::new().scales(Scales::metric());
assert_eq!(f.fmt(123456.0), "123.456 k");
assert_eq!(f.fmt(123456789.0), "123.456789 M");

pub fn binary() -> Self

Create a binary scale.

The binary scale steps with base 1024. It is intended for use as a units prefix, so the empty base contains a space.

Example

let mut f = Formatter::new().scales(Scales::binary());
assert_eq!(f.fmt(1024.0 * 1024.0), "1.0 Mi");
assert_eq!(f.fmt(3.14 * 1024.0 * 1024.0), "3.14 Mi");

pub fn base(&self) -> u16

The set base.

pub fn units(&self) -> &[&'static str]

The set units.

pub fn into_inner(self) -> (u16, Vec<&'static str>)

Extract the (base, units).

pub fn scale(&self, num: f64) -> (f64, &'static str)

Scale a number and return the scaled number with the unit.

Trait Implementations

impl Clone for Scales

fn clone(&self) -> Scales

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scales

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

Formats the value using the given formatter.

impl Hash for Scales

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Scales

fn eq(&self, other: &Scales) -> 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 Eq for Scales

impl StructuralPartialEq for Scales