Type Alias fixed_decimal::SignedFixedDecimal

source ·
pub type SignedFixedDecimal = Signed<UnsignedFixedDecimal>;
Expand description

A Type containing a UnsignedFixedDecimal and a Sign to represent a signed decimal number.

Supports a mantissa of non-zero digits and a number of leading and trailing zeros, as well as an optional sign; used for formatting and plural selection.

§Data Types

The following types can be converted to a SignedFixedDecimal:

  • Integers, signed and unsigned
  • Strings representing an arbitrary-precision decimal
  • Floating point values (using the ryu feature)

To create a SignedFixedDecimal with fractional digits, you have several options:

§Examples

use fixed_decimal::SignedFixedDecimal;

let mut dec = SignedFixedDecimal::from(250);
assert_eq!("250", dec.to_string());

dec.multiply_pow10(-2);
assert_eq!("2.50", dec.to_string());

Aliased Type§

struct SignedFixedDecimal {
    pub sign: Sign,
    pub absolute: UnsignedFixedDecimal,
}

Fields§

§sign: Sign§absolute: UnsignedFixedDecimal

Implementations§

source§

impl SignedFixedDecimal

source

pub fn new(sign: Sign, absolute: UnsignedFixedDecimal) -> Self

source

pub fn try_from_str(s: &str) -> Result<Self, ParseError>

source

pub fn try_from_utf8(input_str: &[u8]) -> Result<Self, ParseError>

source

pub fn apply_sign_display(&mut self, sign_display: SignDisplay)

Sets the sign of this number according to the given sign display strategy.

§Examples
use fixed_decimal::SignedFixedDecimal;
use fixed_decimal::SignDisplay::*;

let mut dec = SignedFixedDecimal::from(1729);
assert_eq!("1729", dec.to_string());
dec.apply_sign_display(Always);
assert_eq!("+1729", dec.to_string());
source

pub fn with_sign_display(self, sign_display: SignDisplay) -> Self

Returns this number with its sign set according to the given sign display strategy.

§Examples
use fixed_decimal::SignedFixedDecimal;
use fixed_decimal::SignDisplay::*;

assert_eq!(
    "+1729",
    SignedFixedDecimal::from(1729)
        .with_sign_display(ExceptZero)
        .to_string()
);
source§

impl SignedFixedDecimal

source

pub fn try_from_f64( float: f64, precision: FloatPrecision, ) -> Result<Self, LimitError>

Constructs a SignedFixedDecimal from an f64.

Since f64 values do not carry a notion of their precision, the second argument to this function specifies the type of precision associated with the f64. For more information, see FloatPrecision.

This function uses ryu, which is an efficient double-to-string algorithm, but other implementations may yield higher performance; for more details, see icu4x#166.

This function can be made available with the "ryu" Cargo feature.

use fixed_decimal::{SignedFixedDecimal, FloatPrecision};
use writeable::assert_writeable_eq;

let decimal =
    SignedFixedDecimal::try_from_f64(-5.1, FloatPrecision::Magnitude(-2))
        .expect("Finite quantity with limited precision");
assert_writeable_eq!(decimal, "-5.10");

let decimal =
    SignedFixedDecimal::try_from_f64(0.012345678, FloatPrecision::RoundTrip)
        .expect("Finite quantity");
assert_writeable_eq!(decimal, "0.012345678");

let decimal =
    SignedFixedDecimal::try_from_f64(12345678000., FloatPrecision::Integer)
        .expect("Finite, integer-valued quantity");
assert_writeable_eq!(decimal, "12345678000");

Negative zero is supported.

use fixed_decimal::{SignedFixedDecimal, FloatPrecision};
use writeable::assert_writeable_eq;

// IEEE 754 for floating point defines the sign bit separate
// from the mantissa and exponent, allowing for -0.
let negative_zero =
    SignedFixedDecimal::try_from_f64(-0.0, FloatPrecision::Integer)
        .expect("Negative zero");
assert_writeable_eq!(negative_zero, "-0");
source§

impl SignedFixedDecimal

All the rounding and rounding related logic is implmented in this implmentation block.

source

pub fn round(&mut self, position: i16)

Rounds this number at a particular digit position.

This uses half to even rounding, which rounds to the nearest integer and resolves ties by selecting the nearest even integer to the original value.

§Examples
use fixed_decimal::SignedFixedDecimal;

let mut dec = SignedFixedDecimal::from_str("-1.5").unwrap();
dec.round(0);
assert_eq!("-2", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.4").unwrap();
dec.round(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.5").unwrap();
dec.round(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.6").unwrap();
dec.round(0);
assert_eq!("1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("1.5").unwrap();
dec.round(0);
assert_eq!("2", dec.to_string());
source

pub fn rounded(self, position: i16) -> Self

Returns this number rounded at a particular digit position.

This uses half to even rounding by default, which rounds to the nearest integer and resolves ties by selecting the nearest even integer to the original value.

§Examples
use fixed_decimal::SignedFixedDecimal;

let mut dec = SignedFixedDecimal::from_str("-1.5").unwrap();
assert_eq!("-2", dec.rounded(0).to_string());
let mut dec = SignedFixedDecimal::from_str("0.4").unwrap();
assert_eq!("0", dec.rounded(0).to_string());
let mut dec = SignedFixedDecimal::from_str("0.5").unwrap();
assert_eq!("0", dec.rounded(0).to_string());
let mut dec = SignedFixedDecimal::from_str("0.6").unwrap();
assert_eq!("1", dec.rounded(0).to_string());
let mut dec = SignedFixedDecimal::from_str("1.5").unwrap();
assert_eq!("2", dec.rounded(0).to_string());
source

pub fn ceil(&mut self, position: i16)

Rounds this number towards positive infinity at a particular digit position.

§Examples
use fixed_decimal::SignedFixedDecimal;

let mut dec = SignedFixedDecimal::from_str("-1.5").unwrap();
dec.ceil(0);
assert_eq!("-1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.4").unwrap();
dec.ceil(0);
assert_eq!("1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.5").unwrap();
dec.ceil(0);
assert_eq!("1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.6").unwrap();
dec.ceil(0);
assert_eq!("1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("1.5").unwrap();
dec.ceil(0);
assert_eq!("2", dec.to_string());
source

pub fn ceiled(self, position: i16) -> Self

Returns this number rounded towards positive infinity at a particular digit position.

§Examples
use fixed_decimal::SignedFixedDecimal;

let dec = SignedFixedDecimal::from_str("-1.5").unwrap();
assert_eq!("-1", dec.ceiled(0).to_string());
let dec = SignedFixedDecimal::from_str("0.4").unwrap();
assert_eq!("1", dec.ceiled(0).to_string());
let dec = SignedFixedDecimal::from_str("0.5").unwrap();
assert_eq!("1", dec.ceiled(0).to_string());
let dec = SignedFixedDecimal::from_str("0.6").unwrap();
assert_eq!("1", dec.ceiled(0).to_string());
let dec = SignedFixedDecimal::from_str("1.5").unwrap();
assert_eq!("2", dec.ceiled(0).to_string());
source

pub fn expand(&mut self, position: i16)

Rounds this number away from zero at a particular digit position.

§Examples
use fixed_decimal::SignedFixedDecimal;

let mut dec = SignedFixedDecimal::from_str("-1.5").unwrap();
dec.expand(0);
assert_eq!("-2", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.4").unwrap();
dec.expand(0);
assert_eq!("1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.5").unwrap();
dec.expand(0);
assert_eq!("1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.6").unwrap();
dec.expand(0);
assert_eq!("1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("1.5").unwrap();
dec.expand(0);
assert_eq!("2", dec.to_string());
source

pub fn expanded(self, position: i16) -> Self

Returns this number rounded away from zero at a particular digit position.

§Examples
use fixed_decimal::SignedFixedDecimal;

let dec = SignedFixedDecimal::from_str("-1.5").unwrap();
assert_eq!("-2", dec.expanded(0).to_string());
let dec = SignedFixedDecimal::from_str("0.4").unwrap();
assert_eq!("1", dec.expanded(0).to_string());
let dec = SignedFixedDecimal::from_str("0.5").unwrap();
assert_eq!("1", dec.expanded(0).to_string());
let dec = SignedFixedDecimal::from_str("0.6").unwrap();
assert_eq!("1", dec.expanded(0).to_string());
let dec = SignedFixedDecimal::from_str("1.5").unwrap();
assert_eq!("2", dec.expanded(0).to_string());
source

pub fn floor(&mut self, position: i16)

Rounds this number towards negative infinity at a particular digit position.

§Examples
use fixed_decimal::SignedFixedDecimal;

let mut dec = SignedFixedDecimal::from_str("-1.5").unwrap();
dec.floor(0);
assert_eq!("-2", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.4").unwrap();
dec.floor(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.5").unwrap();
dec.floor(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.6").unwrap();
dec.floor(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("1.5").unwrap();
dec.floor(0);
assert_eq!("1", dec.to_string());
source

pub fn floored(self, position: i16) -> Self

Returns this number rounded towards negative infinity at a particular digit position.

§Examples
use fixed_decimal::SignedFixedDecimal;

let dec = SignedFixedDecimal::from_str("-1.5").unwrap();
assert_eq!("-2", dec.floored(0).to_string());
let dec = SignedFixedDecimal::from_str("0.4").unwrap();
assert_eq!("0", dec.floored(0).to_string());
let dec = SignedFixedDecimal::from_str("0.5").unwrap();
assert_eq!("0", dec.floored(0).to_string());
let dec = SignedFixedDecimal::from_str("0.6").unwrap();
assert_eq!("0", dec.floored(0).to_string());
let dec = SignedFixedDecimal::from_str("1.5").unwrap();
assert_eq!("1", dec.floored(0).to_string());
source

pub fn trunc(&mut self, position: i16)

Rounds this number towards zero at a particular digit position.

Also see UnsignedFixedDecimal::pad_end().

§Examples
use fixed_decimal::SignedFixedDecimal;

let mut dec = SignedFixedDecimal::from_str("-1.5").unwrap();
dec.trunc(0);
assert_eq!("-1", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.4").unwrap();
dec.trunc(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.5").unwrap();
dec.trunc(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("0.6").unwrap();
dec.trunc(0);
assert_eq!("0", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("1.5").unwrap();
dec.trunc(0);
assert_eq!("1", dec.to_string());
source

pub fn trunced(self, position: i16) -> Self

Returns this number rounded towards zero at a particular digit position.

Also see UnsignedFixedDecimal::padded_end().

§Examples
use fixed_decimal::SignedFixedDecimal;

let dec = SignedFixedDecimal::from_str("-1.5").unwrap();
assert_eq!("-1", dec.trunced(0).to_string());
let dec = SignedFixedDecimal::from_str("0.4").unwrap();
assert_eq!("0", dec.trunced(0).to_string());
let dec = SignedFixedDecimal::from_str("0.5").unwrap();
assert_eq!("0", dec.trunced(0).to_string());
let dec = SignedFixedDecimal::from_str("0.6").unwrap();
assert_eq!("0", dec.trunced(0).to_string());
let dec = SignedFixedDecimal::from_str("1.5").unwrap();
assert_eq!("1", dec.trunced(0).to_string());
source

pub fn round_with_mode(&mut self, position: i16, mode: SignedRoundingMode)

Rounds this number at a particular digit position, using the specified rounding mode.

§Examples
use fixed_decimal::{SignedFixedDecimal, SignedRoundingMode, UnsignedRoundingMode};

let mut dec = SignedFixedDecimal::from_str("-3.5").unwrap();
dec.round_with_mode(0, SignedRoundingMode::Floor);
assert_eq!("-4", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("-3.5").unwrap();
dec.round_with_mode(0, SignedRoundingMode::Ceil);
assert_eq!("-3", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("5.455").unwrap();
dec.round_with_mode(-2, SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfExpand));
assert_eq!("5.46", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("-7.235").unwrap();
dec.round_with_mode(-2, SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfTrunc));
assert_eq!("-7.23", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("9.75").unwrap();
dec.round_with_mode(-1, SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfEven));
assert_eq!("9.8", dec.to_string());
source

pub fn rounded_with_mode(self, position: i16, mode: SignedRoundingMode) -> Self

Returns this number rounded at a particular digit position, using the specified rounding mode.

§Examples
use fixed_decimal::{SignedFixedDecimal, SignedRoundingMode, UnsignedRoundingMode};

let mut dec = SignedFixedDecimal::from_str("-3.5").unwrap();
assert_eq!(
    "-4",
    dec.rounded_with_mode(0, SignedRoundingMode::Floor).to_string()
);
let mut dec = SignedFixedDecimal::from_str("-3.5").unwrap();
assert_eq!(
    "-3",
    dec.rounded_with_mode(0, SignedRoundingMode::Ceil).to_string()
);
let mut dec = SignedFixedDecimal::from_str("5.455").unwrap();
assert_eq!(
    "5.46",
    dec.rounded_with_mode(-2, SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfExpand))
        .to_string()
);
let mut dec = SignedFixedDecimal::from_str("-7.235").unwrap();
assert_eq!(
    "-7.23",
    dec.rounded_with_mode(-2, SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfTrunc))
        .to_string()
);
let mut dec = SignedFixedDecimal::from_str("9.75").unwrap();
assert_eq!(
    "9.8",
    dec.rounded_with_mode(-1, SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfEven))
        .to_string()
);
source

pub fn round_with_mode_and_increment( &mut self, position: i16, mode: SignedRoundingMode, increment: RoundingIncrement, )

Rounds this number at a particular digit position and increment, using the specified rounding mode.

§Examples
use fixed_decimal::{SignedFixedDecimal, RoundingIncrement, SignedRoundingMode, UnsignedRoundingMode};

let mut dec = SignedFixedDecimal::from_str("-3.5").unwrap();
dec.round_with_mode_and_increment(
    0,
    SignedRoundingMode::Floor,
    RoundingIncrement::MultiplesOf1,
);
assert_eq!("-4", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("-3.59").unwrap();
dec.round_with_mode_and_increment(
    -1,
    SignedRoundingMode::Ceil,
    RoundingIncrement::MultiplesOf2,
);
assert_eq!("-3.4", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("5.455").unwrap();
dec.round_with_mode_and_increment(
    -2,
    SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfExpand),
    RoundingIncrement::MultiplesOf5,
);
assert_eq!("5.45", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("-7.235").unwrap();
dec.round_with_mode_and_increment(
    -2,
    SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfTrunc),
    RoundingIncrement::MultiplesOf25,
);
assert_eq!("-7.25", dec.to_string());
let mut dec = SignedFixedDecimal::from_str("9.75").unwrap();
dec.round_with_mode_and_increment(
    -1,
    SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfEven),
    RoundingIncrement::MultiplesOf5,
);
assert_eq!("10.0", dec.to_string());
source

pub fn rounded_with_mode_and_increment( self, position: i16, mode: SignedRoundingMode, increment: RoundingIncrement, ) -> Self

Returns this number rounded at a particular digit position and increment, using the specified rounding mode.

§Examples
use fixed_decimal::{SignedFixedDecimal, RoundingIncrement, SignedRoundingMode, UnsignedRoundingMode};

let mut dec = SignedFixedDecimal::from_str("-3.5").unwrap();
assert_eq!(
    "-4",
    dec.rounded_with_mode_and_increment(
        0,
        SignedRoundingMode::Floor,
        RoundingIncrement::MultiplesOf1
    )
    .to_string()
);
let mut dec = SignedFixedDecimal::from_str("-3.59").unwrap();
assert_eq!(
    "-3.4",
    dec.rounded_with_mode_and_increment(
        -1,
        SignedRoundingMode::Ceil,
        RoundingIncrement::MultiplesOf2
    )
    .to_string()
);
let mut dec = SignedFixedDecimal::from_str("5.455").unwrap();
assert_eq!(
    "5.45",
    dec.rounded_with_mode_and_increment(
        -2,
        SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfExpand),
        RoundingIncrement::MultiplesOf5
    )
    .to_string()
);
let mut dec = SignedFixedDecimal::from_str("-7.235").unwrap();
assert_eq!(
    "-7.25",
    dec.rounded_with_mode_and_increment(
        -2,
        SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfTrunc),
        RoundingIncrement::MultiplesOf25
    )
    .to_string()
);
let mut dec = SignedFixedDecimal::from_str("9.75").unwrap();
assert_eq!(
    "10.0",
    dec.rounded_with_mode_and_increment(
        -1,
        SignedRoundingMode::Unsigned(UnsignedRoundingMode::HalfEven),
        RoundingIncrement::MultiplesOf5
    )
    .to_string()
);
source§

impl SignedFixedDecimal

source

pub fn to_string(&self) -> String

Converts the given value to a String.

Under the hood, this uses an efficient [Writeable] implementation. However, in order to avoid allocating a string, it is more efficient to use [Writeable] directly.

Methods from Deref<Target = UnsignedFixedDecimal>§

source

pub fn digit_at(&self, magnitude: i16) -> u8

Gets the digit at the specified order of magnitude. Returns 0 if the magnitude is out of range of the currently visible digits.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let dec = UnsignedFixedDecimal::from(945u32);
assert_eq!(0, dec.digit_at(-1));
assert_eq!(5, dec.digit_at(0));
assert_eq!(4, dec.digit_at(1));
assert_eq!(9, dec.digit_at(2));
assert_eq!(0, dec.digit_at(3));
source

pub fn magnitude_range(&self) -> RangeInclusive<i16>

Gets the visible range of digit magnitudes, in ascending order of magnitude. Call .rev() on the return value to get the range in descending order. Magnitude 0 is always included, even if the number has leading or trailing zeros.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let dec: UnsignedFixedDecimal = "012.340".parse().expect("valid syntax");
assert_eq!(-3..=2, dec.magnitude_range());
source

pub fn nonzero_magnitude_start(&self) -> i16

Gets the magnitude of the largest nonzero digit. If the number is zero, 0 is returned.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let dec: UnsignedFixedDecimal = "012.340".parse().expect("valid syntax");
assert_eq!(1, dec.nonzero_magnitude_start());

assert_eq!(0, UnsignedFixedDecimal::from(0u32).nonzero_magnitude_start());
source

pub fn nonzero_magnitude_end(&self) -> i16

Gets the magnitude of the smallest nonzero digit. If the number is zero, 0 is returned.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let dec: UnsignedFixedDecimal = "012.340".parse().expect("valid syntax");
assert_eq!(-2, dec.nonzero_magnitude_end());

assert_eq!(0, UnsignedFixedDecimal::from(0u32).nonzero_magnitude_end());
source

pub fn is_zero(&self) -> bool

Returns whether the number has a numeric value of zero.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let dec: UnsignedFixedDecimal = "000.000".parse().expect("valid syntax");
assert!(dec.is_zero());
source

pub fn multiply_pow10(&mut self, delta: i16)

Shift the digits of this number by a power of 10.

Leading or trailing zeros may be added to keep the digit at magnitude 0 (the last digit before the decimal separator) visible.

NOTE: if the operation causes overflow, the number will be set to zero.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from(42u32);
assert_eq!("42", dec.to_string());

dec.multiply_pow10(3);
assert_eq!("42000", dec.to_string());
source

pub fn trim_start(&mut self)

Removes the leading zeroes of this number.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from(123400u32)
    .multiplied_pow10(-4)
    .padded_start(4);
assert_eq!("0012.3400", dec.to_string());

dec.trim_start();
assert_eq!("12.3400", dec.to_string());

There is no effect if the most significant digit has magnitude less than zero

let mut dec = UnsignedFixedDecimal::from(22u32).multiplied_pow10(-4);
assert_eq!("0.0022", dec.to_string());

dec.trim_start();
assert_eq!("0.0022", dec.to_string());
source

pub fn trim_end(&mut self)

Removes the trailing zeros of this number.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from(123400u32)
    .multiplied_pow10(-4)
    .padded_start(4);
assert_eq!("0012.3400", dec.to_string());

dec.trim_end();
assert_eq!("0012.34", dec.to_string());

There is no effect if the least significant digit has magnitude more than zero:

let mut dec = UnsignedFixedDecimal::from(2200u32);
assert_eq!("2200", dec.to_string());

dec.trim_end();
assert_eq!("2200", dec.to_string());
source

pub fn trim_end_if_integer(&mut self)

Removes the trailing zeros of this number, but only if the number is an integer

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from(12340000u32)
    .multiplied_pow10(-2);
assert_eq!("123400.00", dec.to_string());

dec.trim_end_if_integer();
assert_eq!("123400", dec.to_string());

// No effect on trailing zeros in the integer:
dec.trim_end_if_integer();
assert_eq!("123400", dec.to_string());

// No effect if there are nonzero fractional digits:
dec.multiply_pow10(-4);
dec.pad_start(4);
assert_eq!("0012.3400", dec.to_string());

dec.trim_end_if_integer();
assert_eq!("0012.3400", dec.to_string());
source

pub fn pad_start(&mut self, position: i16)

Pads this number with leading zeros on a particular position.

Negative position numbers have no effect.

Also see UnsignedFixedDecimal::set_max_position().

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from(42u32);
assert_eq!("42", dec.to_string());

dec.pad_start(4);
assert_eq!("0042", dec.to_string());

dec.pad_start(3);
assert_eq!("042", dec.to_string());

dec.pad_start(2);
assert_eq!("42", dec.to_string());

dec.pad_start(1);
assert_eq!("42", dec.to_string());
source

pub fn pad_end(&mut self, position: i16)

Pads this number with trailing zeros on a particular (non-positive) position. Will truncate trailing zeros if necessary, but will not truncate other digits.

Positive position numbers have no effect.

Also see UnsignedFixedDecimal::trunc().

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from_str("123.456").unwrap();
assert_eq!("123.456", dec.to_string());

dec.pad_end(-2);
assert_eq!("123.456", dec.to_string());

dec.pad_end(-6);
assert_eq!("123.456000", dec.to_string());

let mut dec = UnsignedFixedDecimal::from_str("123.000").unwrap();
dec.pad_end(0);
assert_eq!("123", dec.to_string());
source

pub fn set_max_position(&mut self, position: i16)

Truncates the leading significant digits of this number to a particular position, deleting digits if necessary.

Also see UnsignedFixedDecimal::pad_start().

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from(4235970u32).multiplied_pow10(-3);
assert_eq!("4235.970", dec.to_string());

dec.set_max_position(5);
assert_eq!("04235.970", dec.to_string());

dec.set_max_position(2);
assert_eq!("35.970", dec.to_string());

dec.set_max_position(1);
assert_eq!("5.970", dec.to_string());

dec.set_max_position(0);
assert_eq!("0.970", dec.to_string());

dec.set_max_position(-1);
assert_eq!("0.070", dec.to_string());

dec.set_max_position(-2);
assert_eq!("0.000", dec.to_string());

dec.set_max_position(-4);
assert_eq!("0.0000", dec.to_string());
source

pub fn round(&mut self, position: i16)

Rounds this number at a particular digit position.

This uses half to even rounding, which rounds to the nearest integer and resolves ties by selecting the nearest even integer to the original value.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from_str("0.4").unwrap();
dec.round(0);
assert_eq!("0", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("0.5").unwrap();
dec.round(0);
assert_eq!("0", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("0.6").unwrap();
dec.round(0);
assert_eq!("1", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("1.5").unwrap();
dec.round(0);
assert_eq!("2", dec.to_string());
source

pub fn expand(&mut self, position: i16)

Rounds this number away from zero at a particular digit position.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from_str("0.4").unwrap();
dec.expand(0);
assert_eq!("1", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("0.5").unwrap();
dec.expand(0);
assert_eq!("1", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("0.6").unwrap();
dec.expand(0);
assert_eq!("1", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("1.5").unwrap();
dec.expand(0);
assert_eq!("2", dec.to_string());
source

pub fn trunc(&mut self, position: i16)

Rounds this number towards zero at a particular digit position.

Also see UnsignedFixedDecimal::pad_end().

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut dec = UnsignedFixedDecimal::from_str("0.4").unwrap();
dec.trunc(0);
assert_eq!("0", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("0.5").unwrap();
dec.trunc(0);
assert_eq!("0", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("0.6").unwrap();
dec.trunc(0);
assert_eq!("0", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("1.5").unwrap();
dec.trunc(0);
assert_eq!("1", dec.to_string());
source

pub fn round_with_mode(&mut self, position: i16, mode: UnsignedRoundingMode)

Rounds this number at a particular digit position, using the specified rounding mode.

§Examples
use fixed_decimal::{UnsignedFixedDecimal, UnsignedRoundingMode};

let mut dec = UnsignedFixedDecimal::from_str("5.455").unwrap();
dec.round_with_mode(-2, UnsignedRoundingMode::HalfExpand);
assert_eq!("5.46", dec.to_string());
let mut dec = UnsignedFixedDecimal::from_str("9.75").unwrap();
dec.round_with_mode(-1, UnsignedRoundingMode::HalfEven);
assert_eq!("9.8", dec.to_string());
source

pub fn round_with_mode_and_increment( &mut self, position: i16, mode: UnsignedRoundingMode, increment: RoundingIncrement, )

Rounds this number at a particular digit position and increment, using the specified rounding mode.

§Examples
use fixed_decimal::{UnsignedFixedDecimal, RoundingIncrement, UnsignedRoundingMode};

let mut dec = UnsignedFixedDecimal::from_str("5.455").unwrap();
dec.round_with_mode_and_increment(
    -2,
    UnsignedRoundingMode::HalfExpand,
    RoundingIncrement::MultiplesOf5,
);
assert_eq!("5.45", dec.to_string());

let mut dec = UnsignedFixedDecimal::from_str("9.75").unwrap();
dec.round_with_mode_and_increment(
    -1,
    UnsignedRoundingMode::HalfEven,
    RoundingIncrement::MultiplesOf5,
);
assert_eq!("10.0", dec.to_string());
source

pub fn concatenate_end( &mut self, other: UnsignedFixedDecimal, ) -> Result<(), UnsignedFixedDecimal>

Concatenate another UnsignedFixedDecimal into the end of this UnsignedFixedDecimal.

All nonzero digits in other must have lower magnitude than nonzero digits in self. If the two decimals represent overlapping ranges of magnitudes, an Err is returned, passing ownership of other back to the caller.

The magnitude range of self will be increased if other covers a larger range.

§Examples
use fixed_decimal::UnsignedFixedDecimal;

let mut integer = UnsignedFixedDecimal::from(123u32);
let fraction = UnsignedFixedDecimal::from(456u32).multiplied_pow10(-3);

integer.concatenate_end(fraction);

assert_eq!("123.456", integer.to_string());
source

pub fn to_string(&self) -> String

Converts the given value to a String.

Under the hood, this uses an efficient [Writeable] implementation. However, in order to avoid allocating a string, it is more efficient to use [Writeable] directly.

Trait Implementations§

source§

impl Deref for SignedFixedDecimal

source§

type Target = UnsignedFixedDecimal

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for SignedFixedDecimal

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl Display for SignedFixedDecimal

This trait is implemented for compatibility with fmt!. To create a string, [Writeable::write_to_string] is usually more efficient.

source§

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

Formats the value using the given formatter. Read more
source§

impl From<FixedInteger> for SignedFixedDecimal

source§

fn from(value: FixedInteger) -> Self

Converts to this type from the input type.
source§

impl From<i128> for SignedFixedDecimal

source§

fn from(value: i128) -> Self

Converts to this type from the input type.
source§

impl From<i16> for SignedFixedDecimal

source§

fn from(value: i16) -> Self

Converts to this type from the input type.
source§

impl From<i32> for SignedFixedDecimal

source§

fn from(value: i32) -> Self

Converts to this type from the input type.
source§

impl From<i64> for SignedFixedDecimal

source§

fn from(value: i64) -> Self

Converts to this type from the input type.
source§

impl From<i8> for SignedFixedDecimal

source§

fn from(value: i8) -> Self

Converts to this type from the input type.
source§

impl From<isize> for SignedFixedDecimal

source§

fn from(value: isize) -> Self

Converts to this type from the input type.
source§

impl From<u128> for SignedFixedDecimal

source§

fn from(value: u128) -> Self

Converts to this type from the input type.
source§

impl From<u16> for SignedFixedDecimal

source§

fn from(value: u16) -> Self

Converts to this type from the input type.
source§

impl From<u32> for SignedFixedDecimal

source§

fn from(value: u32) -> Self

Converts to this type from the input type.
source§

impl From<u64> for SignedFixedDecimal

source§

fn from(value: u64) -> Self

Converts to this type from the input type.
source§

impl From<u8> for SignedFixedDecimal

source§

fn from(value: u8) -> Self

Converts to this type from the input type.
source§

impl From<usize> for SignedFixedDecimal

source§

fn from(value: usize) -> Self

Converts to this type from the input type.
source§

impl FromStr for SignedFixedDecimal

source§

type Err = ParseError

The associated error which can be returned from parsing.
source§

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type. Read more
source§

impl Writeable for SignedFixedDecimal

Render the SignedFixedDecimal as a string of ASCII digits with a possible decimal point.

§Examples

assert_writeable_eq!(SignedFixedDecimal::from(42), "42");
source§

fn write_to<W: Write + ?Sized>(&self, sink: &mut W) -> Result

Writes a string to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to_parts, and discards any Part annotations.
source§

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink. Read more
§

fn write_to_parts<S>(&self, sink: &mut S) -> Result<(), Error>
where S: PartsWrite + ?Sized,

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.
§

fn write_to_string(&self) -> Cow<'_, str>

Creates a new String with the data from this Writeable. Like ToString, but smaller and faster. Read more