Struct readable::Float

pub struct Float(_, _);

Human readable float.

Takes a floating point number as input and returns a ready-to-print!() Float.

The default From implementation will print 3 decimal numbers.

This can be changed by using different functions when initially creating the Float, or converting an existing Float, for example:

let f2 = Float::new_2_point(3.0);
let f6 = Float::new_6_point(3.0);
let f9 = Float::new_9_point(f2.to_f64());

println!("{}\n{}\n{}", f2, f6, f9);

// 3.00
// 3.000000
// 3.000000000

Exceptions

| Exceptions | String Output | |—————————————––|—————––| | f64::NAN | NaN | f64::INFINITY & f64::NEG_INFINITY | ∞

To disable checks for these, (you are sure you don’t have NaN’s), enable the ignore_nan_inf feature flag.

Examples

| Input | Output | |––––––––––|—————––| | 0.0 | 0.000 | 1234.571 | 1,234.571 | 1234.571 | 1,234.571000 | 99.123 (percent) | 99.12% | 0.001 (percent) | 0%

Implementations

impl Float

pub fn zero() -> Self

Returns a Self with the f64 value of 0.0.

The String is set to 0.000.

pub fn unknown() -> Self

Returns a Self with the f64 value of f64::NAN.

The String is set to ???.

pub fn nan() -> Self

Returns a Self with the f64 value of f64::NAN.

The String is set to NaN.

pub fn inf() -> Self

Returns a Self with the f64 value of f64::INFINITY.

The String is set to ∞.

pub fn percent(f: f64) -> Self

Truncates to 2 floating point and appends a %.

Anything lower than 0.01 is rounded down to 0.00.

Examples

Input	String Output
0.0	0.00%
0.001	0.00%
0.01	0.01%
0.1	0.10%
1.0	1.00%
50.0	50.00%
100.0	100.00%
150.0	150.00%
1000.0	1,000.00%
250000.0	250,000.00%

pub fn as_str(&self) -> &str

Return a borrowed str without consuming Self.

pub fn to_f64(&self) -> f64

Returns the inner f64.

pub fn into_string(self) -> String

Consumes [Self], returning the inner String.

pub fn into_raw(self) -> (f64, String)

Consumes Self, returning the inner f64 and String.

pub fn new_0_point(f: f64) -> Self

Same as Self::from but with no floating point on the inner String.

The inner f64 stays the same as the input.

This does not round up or down, it completely ignores the floating point.

Examples

Input	String Output
0.0	0
50.123	50
100.1	100

pub fn new_1_point(f: f64) -> Self

Create a new Self but with 1 floating point.

pub fn new_2_point(f: f64) -> Self

Create a new Self but with 2 floating point.

pub fn new_4_point(f: f64) -> Self

Create a new Self but with 4 floating point.

pub fn new_5_point(f: f64) -> Self

Create a new Self but with 5 floating point.

pub fn new_6_point(f: f64) -> Self

Create a new Self but with 6 floating point.

pub fn new_7_point(f: f64) -> Self

Create a new Self but with 7 floating point.

pub fn new_8_point(f: f64) -> Self

Create a new Self but with 8 floating point.

pub fn new_9_point(f: f64) -> Self

Create a new Self but with 9 floating point.

pub fn new_10_point(f: f64) -> Self

Create a new Self but with 10 floating point.

pub fn new_11_point(f: f64) -> Self

Create a new Self but with 11 floating point.

pub fn new_12_point(f: f64) -> Self

Create a new Self but with 12 floating point.

pub fn new_13_point(f: f64) -> Self

Create a new Self but with 13 floating point.

pub fn new_14_point(f: f64) -> Self

Create a new Self but with 14 floating point.

pub fn percent_0_point(f: f64) -> Self

Same as Self::percent but with no floating point on the inner String.

The inner f64 stays the same as the input.

This does not round up or down, it completely ignores the floating point.

Examples

Input	String Output
0.0	0%
50.123	50%
100.1	100%

pub fn percent_1_point(f: f64) -> Self

Same as Self::percent but with 1 floating point.

pub fn percent_2_point(f: f64) -> Self

Same as Self::percent but with 2 floating point.

pub fn percent_4_point(f: f64) -> Self

Same as Self::percent but with 4 floating point.

Trait Implementations

impl Clone for Float

fn clone(&self) -> Float

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Float

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Float

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Float

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

Formats the value using the given formatter.

impl From<f32> for Float

fn from(number: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Float

fn from(number: f64) -> Self

Converts to this type from the input type.

impl From<u16> for Float

fn from(number: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Float

fn from(number: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Float

fn from(number: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Float

fn from(number: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Float

fn from(number: usize) -> Self

Converts to this type from the input type.

impl PartialEq<&str> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Float> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Float> for f64

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Float> for str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<f64> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<str> for Float

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<Float> for Float

fn partial_cmp(&self, other: &Float) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Float

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Float