Struct no_proto::pointer::dec::NP_Dec

pub struct NP_Dec {
    pub num: i64,
    pub exp: u8,
}

Holds fixed decimal data.

Check out documentation here.

Fields

num: i64

The number being stored, does not include decimal point data

exp: u8

The exponent of this number

Implementations

impl NP_Dec

pub fn to_float(&self) -> f64

Convert an NP_Dec into a native floating point value.

DO NOT use this to perform calculations, only to export/display the value.

use no_proto::pointer::dec::NP_Dec;
     
let my_num = NP_Dec::new(2203, 3); // value is 2.203
 
assert_eq!(my_num.to_float(), 2.203f64);

pub fn shift_exp(&mut self, new_exp: u8) -> NP_Dec

Shift the exponent of this NP_Dec to a new value.

If the new exp value is higher than the old exp value, there may be an overflow of the i64 value.

If the new exp value is lower than the old one, information will likely be lost as decimal precision is being removed from the number.

use no_proto::pointer::dec::NP_Dec;
 
let mut my_num = NP_Dec::new(2203, 3); // value is 2.203
 
my_num.shift_exp(1); // set `exp` to 1 instead of 3.  This will force our value to 2.2
 
assert_eq!(my_num.to_float(), 2.2_f64); // notice we've lost the "03" at the end because of reducing the `exp` value. 
 

pub fn new(num: i64, exp: u8) -> Self

Generate a new NP_Dec value

First argument is the num value, second is the exp or exponent.

use no_proto::pointer::dec::NP_Dec;
 
let x = NP_Dec::new(2, 0); // stores "2.00"
assert_eq!(x.to_float(), 2f64);
 
let x = NP_Dec::new(2, 1); // stores "0.20"
assert_eq!(x.to_float(), 0.2f64);
 
let x = NP_Dec::new(2, 2); // stores "0.02"
assert_eq!(x.to_float(), 0.02f64);
 
let x = NP_Dec::new(5928, 1); // stores "592.8"
assert_eq!(x.to_float(), 592.8f64);
 
let x = NP_Dec::new(59280, 2); // also stores "592.8"
assert_eq!(x.to_float(), 592.8f64);
 
let x = NP_Dec::new(592800, 3); // also stores "592.8"
assert_eq!(x.to_float(), 592.8f64);
 

pub fn match_exp(&self, other: &NP_Dec) -> NP_Dec

Given another NP_Dec value, match the exp value of this NP_Dec to the other one. Returns a copy of the other NP_Dec.

This creates a copy of the other NP_Dec then shifts it's exp value to whatever self is, then returns that copy.

use no_proto::pointer::dec::NP_Dec;
 
let mut my_num = NP_Dec::new(2203, 3); // value is 2.203
 
let other_num = NP_Dec::new(50, 1); // value is 5.0
 
let matched_dec = my_num.match_exp(&other_num);
// `exp` values match now! They're both 3.
assert_eq!(matched_dec.exp, my_num.exp);

pub fn export(&self) -> (i64, u8)

Export NP_Dec to it's component parts.

use no_proto::pointer::dec::NP_Dec;
 
let my_num = NP_Dec::new(2203, 3); // value is 2.203
 
assert_eq!(my_num.export(), (2203i64, 3u8));

Trait Implementations

impl Add<NP_Dec> for NP_Dec

type Output = NP_Dec

The resulting type after applying the + operator.

pub fn add(self, other: NP_Dec) -> Self::Output

Performs the + operation.

impl AddAssign<NP_Dec> for NP_Dec

pub fn add_assign(&mut self, other: NP_Dec)

Performs the += operation.

impl Clone for NP_Dec

pub fn clone(&self) -> NP_Dec

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for NP_Dec

impl Debug for NP_Dec

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

Formats the value using the given formatter.

impl Default for NP_Dec

pub fn default() -> Self

Returns the "default value" for a type.

impl Div<NP_Dec> for NP_Dec

type Output = NP_Dec

The resulting type after applying the / operator.

pub fn div(self, other: NP_Dec) -> Self::Output

Performs the / operation.

impl DivAssign<NP_Dec> for NP_Dec

pub fn div_assign(&mut self, other: NP_Dec)

Performs the /= operation.

impl Into<NP_Dec> for i32

Converts an Int32 into a NP_Dec

use no_proto::pointer::dec::NP_Dec;
 
let x = 101i32;
let y: NP_Dec = x.into();
 
assert_eq!(y.num as i32, x);

pub fn into(self) -> NP_Dec

Performs the conversion.

impl Into<NP_Dec> for i64

Converts an Int64 into a NP_Dec

use no_proto::pointer::dec::NP_Dec;
 
let x = 101i64;
let y: NP_Dec = x.into();
 
assert_eq!(y.num, x);

pub fn into(self) -> NP_Dec

Performs the conversion.

impl Into<NP_Dec> for f64

Converts a Float64 into a NP_Dec

use no_proto::pointer::dec::NP_Dec;
 
let x = 100.238f64;
let y: NP_Dec = x.into();
 
assert_eq!(y.to_float(), x);

pub fn into(self) -> NP_Dec

Performs the conversion.

impl Into<NP_Dec> for f32

Converts a Float32 into a NP_Dec

use no_proto::pointer::dec::NP_Dec;
 
let x = 100.238f32;
let y: NP_Dec = x.into();
 
assert_eq!(y.to_float() as f32, x);

pub fn into(self) -> NP_Dec

Performs the conversion.

impl Into<f32> for NP_Dec

Converts a NP_Dec into a Float32

use no_proto::pointer::dec::NP_Dec;
 
let x = NP_Dec::new(10023, 2);
let y: f32 = x.into();
 
assert_eq!(y, x.to_float() as f32);

pub fn into(self) -> f32

Performs the conversion.

impl Into<f64> for NP_Dec

Converts a NP_Dec into a Float64

use no_proto::pointer::dec::NP_Dec;
 
let x = NP_Dec::new(10023, 2);
let y: f64 = x.into();
 
assert_eq!(y, x.to_float());

pub fn into(self) -> f64

Performs the conversion.

impl Into<i32> for NP_Dec

Converts an NP_Dec into an Int32, rounds to nearest whole number

use no_proto::pointer::dec::NP_Dec;
 
let x = NP_Dec::new(10123, 2);
let y: i32 = x.into();
 
assert_eq!(y, 101i32);

pub fn into(self) -> i32

Performs the conversion.

impl Into<i64> for NP_Dec

Converts an NP_Dec into an Int64, rounds to nearest whole number

use no_proto::pointer::dec::NP_Dec;
 
let x = NP_Dec::new(10123, 2);
let y: i64 = x.into();
 
assert_eq!(y, 101i64);

pub fn into(self) -> i64

Performs the conversion.

impl Mul<NP_Dec> for NP_Dec

type Output = NP_Dec

The resulting type after applying the * operator.

pub fn mul(self, other: NP_Dec) -> Self::Output

Performs the * operation.

impl MulAssign<NP_Dec> for NP_Dec

pub fn mul_assign(&mut self, other: NP_Dec)

Performs the *= operation.

impl NP_Scalar for NP_Dec

impl PartialEq<NP_Dec> for NP_Dec

Check if two NP_Dec are equal or not equal

If the two exp values are not identical, unexpected results may occur due to rounding.

use no_proto::pointer::dec::NP_Dec;
 
let result = NP_Dec::new(202, 1) == NP_Dec::new(202, 1);
assert_eq!(result, true);
 
let result = NP_Dec::new(202, 1) != NP_Dec::new(200, 1);
assert_eq!(result, true);
 
let result = NP_Dec::new(202, 1) == NP_Dec::new(2020, 2);
assert_eq!(result, true);
 
let result = NP_Dec::new(203, 1) != NP_Dec::new(2020, 2);
assert_eq!(result, true);
 

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

This method tests for !=.

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

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

impl PartialOrd<NP_Dec> for NP_Dec

Compare two NP_Dec

If the two exp values are not identical, unexpected results may occur due to rounding.

use no_proto::pointer::dec::NP_Dec;
 
let result = NP_Dec::new(203, 1) > NP_Dec::new(202, 1);
assert_eq!(result, true);
 
let result = NP_Dec::new(202, 1) < NP_Dec::new(203, 1);
assert_eq!(result, true);
 
let result = NP_Dec::new(20201, 2) > NP_Dec::new(202, 0);
assert_eq!(result, true);
 
let result = NP_Dec::new(20201, 2) == NP_Dec::new(2020100, 4);
assert_eq!(result, true);

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

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

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

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

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

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

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

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

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

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

impl Sub<NP_Dec> for NP_Dec

type Output = NP_Dec

The resulting type after applying the - operator.

pub fn sub(self, other: NP_Dec) -> Self::Output

Performs the - operation.

impl SubAssign<NP_Dec> for NP_Dec

pub fn sub_assign(&mut self, other: NP_Dec)

Performs the -= operation.