注意

由于转向使用 fpdec.rs，此软件包的开发已停止。

基于 const generics 的固定点 Decimal 类型实现提供了一些优势

• 紧凑的内存表示（16 字节），
• 非常好的性能。

将小数位数作为常量类型参数提供，为编译器提供了额外的优化机会。例如，在实现 Add trait 时

impl<const P: u8, const Q: u8> Add<Decimal<Q>> for Decimal<P>
where
    PrecLimitCheck<{ P <= MAX_PREC }>: True,
    PrecLimitCheck<{ Q <= MAX_PREC }>: True,
    PrecLimitCheck<{ const_max_u8(P, Q) <= MAX_PREC }>: True,
{
    type Output = Decimal<{ const_max_u8(P, Q) }>;

    fn add(self, other: Decimal<Q>) -> Self::Output {
        match P.cmp(&Q) {
            Ordering::Equal => Self::Output {
                coeff: Add::add(self.coeff, other.coeff),
            },
            Ordering::Greater => Self::Output {
                coeff: Add::add(
                    self.coeff,
                    mul_pow_ten(other.coeff, P - Q),
                ),
            },
            Ordering::Less => Self::Output {
                coeff: Add::add(
                    mul_pow_ten(self.coeff, Q - P),
                    other.coeff,
                ),
            },
        }
    }
}

对于 P 和 Q 的每种组合，编译器可以将 match 语句的代码减少到只有一个情况。

两个 Decimal 的乘法被简化为两个整数（i128）的乘法，因为结果的小数位数在编译时已经确定

impl<const P: u8, const Q: u8> Mul<Decimal<Q>> for Decimal<P>
where
    PrecLimitCheck<{ P <= MAX_PREC }>: True,
    PrecLimitCheck<{ Q <= MAX_PREC }>: True,
    PrecLimitCheck<{ (const_sum_u8(P, Q)) <= MAX_PREC }>: True,
{
    type Output = Decimal<{ const_sum_u8(P, Q) }>;

    #[inline(always)]
    fn mul(self, other: Decimal<Q>) -> Self::Output {
        Self::Output {
            coeff: self.coeff * other.coeff,
        }
    }
}

但也有一些严重的缺点

• 泛型函数的变体数量众多，导致二进制代码文件很大。
• 因为每个 Decimal

  是不同的类型，所以存在一些不寻常的不对称性。例如，两个 Decimal

  的乘法不会得到一个 Decimal

  。即 Decimal

  不像其他数值类型那样满足 Mul。

• 依赖于夜间功能。

总的来说，使用 const generics 得到的性能提升并不足以抵消缺点。

软件包 fpdec.rs 与此软件包有相同的目标。它并不提供相同的性能，但避免了上述缺点。

----------

这个crate致力于提供 Decimal 固定点算术的快速实现。

它针对典型的商业应用，处理表示数量、货币等数值，而不是针对科学计算，对于科学计算，浮点数学的精度在大多数情况下是足够的。

目标

• 对十进制数的“精确”表示（没有像二进制浮点数那样的偏差）
• 没有隐藏的舍入误差（如浮点数学固有的那样）
• 非常快的操作（通过映射到整数操作）
• 可表示的十进制数的范围足以满足典型的商业应用

在二进制级别，十进制数字被表示为一个系数（以i128值存储）以及一个类型参数，指定小数位数。也就是说，整个实现基于“const generics”，需要支持此功能的Rust版本。

状态

实验性（工作中）

入门

将rust-fixed-point-decimal添加到您的Cargo.toml

[dependencies]
rust-fixed-point-decimal = "0.1"

注意

由于“const generics”的实现尚不完整，您必须在main.rs或lib.rs文件的开头放置以下内容

#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

用法

可以以不同的方式创建Decimal数字。

最简单的方法是使用过程宏Dec

# use rust_fixed_point_decimal::Dec;
let d = Dec!(-17.5);
assert_eq!(d.to_string(), "-17.5");

或者，您可以将整数、浮点数或字符串转换为Decimal

# use rust_fixed_point_decimal::Decimal;
let d = Decimal::<2>::from(297_i32);
assert_eq!(d.to_string(), "297.00");

# #![allow(incomplete_features)]
# #![feature(generic_const_exprs)]
# use rust_fixed_point_decimal::{Decimal, DecimalError};
# use std::convert::TryFrom;
let d = Decimal::<5>::try_from(83.0025)?;
assert_eq!(d.to_string(), "83.00250");
# Ok::<(), DecimalError>(())

# #![allow(incomplete_features)]
# #![feature(generic_const_exprs)]
# use rust_fixed_point_decimal::{Decimal, ParseDecimalError};
# use std::str::FromStr;
let d = Decimal::<4>::from_str("38.207")?;
assert_eq!(d.to_string(), "38.2070");
# Ok::<(), ParseDecimalError>(())

可以使用一元减号操作符反转Decimal的符号，并且可以将Decimal实例与其他类型为Decimal的实例或所有整数的基本类型（除了u128和除了u8之外，这会导致编译器错误）进行比较

# #![allow(incomplete_features)]
# #![feature(generic_const_exprs)]
# use rust_fixed_point_decimal::{Dec, Decimal};
let x = Dec!(129.24);
let y = -x;
assert_eq!(y.to_string(), "-129.24");
assert!(-129_i64 > y);
let z = -y;
assert_eq!(x, z);
let z = Dec!(0.00097);
assert!(x > z);
assert!(y <= z);
assert!(z != 7_u32);
assert!(7_u32 == Dec!(7.00));

Decimal支持所有五个二进制数值运算符 +, -, *, /, 和 %，可以用于两个Decimal之间，或者用于一个Decimal和一个基本整数（除了u128）

# #![allow(incomplete_features)]
# #![feature(generic_const_exprs)]
# use rust_fixed_point_decimal::{Dec, Decimal};
let x = Dec!(17.5);
let y = Dec!(6.40);
let z = x + y;
assert_eq!(z.to_string(), "23.90");
let z = x - y;
assert_eq!(z.to_string(), "11.10");
let z = x * y;
assert_eq!(z.to_string(), "112.000");
let z = x / y;
assert_eq!(z.to_string(), "2.734375000");
let z = x % y;
assert_eq!(z.to_string(), "4.70");

# #![allow(incomplete_features)]
# #![feature(generic_const_exprs)]
# use rust_fixed_point_decimal::{Dec, Decimal};
let x = Dec!(17.5);
let y = -5_i64;
let z = x + y;
assert_eq!(z.to_string(), "12.5");
let z = x - y;
assert_eq!(z.to_string(), "22.5");
let z = y * x;
assert_eq!(z.to_string(), "-87.5");
let z = x / y;
assert_eq!(z.to_string(), "-3.500000000");
let z = x % y;
assert_eq!(z.to_string(), "2.5");

所有这些二进制数值运算符在结果不能按照上述约束表示为Decimal时都会panic。此外，还有实现运算符“checked”变体的函数，它们在panic时返回Option::None

对于乘法和除法，还有返回结果四舍五入到目标类型指定的小数位数的函数

# #![allow(incomplete_features)]
# #![feature(generic_const_exprs)]
# use rust_fixed_point_decimal::{Dec, Decimal, DivRounded, MulRounded};
let x = Dec!(17.5);
let y = Dec!(6.47);
let z: Decimal<1> = x.mul_rounded(y);
assert_eq!(z.to_string(), "113.2");
let z: Decimal<3> = x.div_rounded(y);
assert_eq!(z.to_string(), "2.705");