use std::cmp::Ordering;
use std::ffi::{CStr, CString};
use std::fmt;
use std::marker::PhantomData;
use std::mem::MaybeUninit;
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, RemAssign, Sub, SubAssign};
use std::str::FromStr;
use libc::c_char;
use crate::context::{Class, Context};
#[cfg(feature = "arbitrary-precision")]
use crate::decimal::Decimal;
use crate::decimal32::Decimal32;
use crate::decimal64::Decimal64;
use crate::error::ParseDecimalError;
#[derive(Clone, Copy)]
pub struct Decimal128 {
pub(crate) inner: decnumber_sys::decQuad,
}
impl Decimal128 {
pub fn zero() -> Decimal128 {
Decimal128::default()
}
pub fn from_le_bytes(mut bytes: [u8; 16]) -> Decimal128 {
if cfg!(target_endian = "big") {
bytes.reverse();
}
Decimal128::from_ne_bytes(bytes)
}
pub fn from_be_bytes(mut bytes: [u8; 16]) -> Decimal128 {
if cfg!(target_endian = "little") {
bytes.reverse();
}
Decimal128::from_ne_bytes(bytes)
}
pub fn from_ne_bytes(bytes: [u8; 16]) -> Decimal128 {
Decimal128 {
inner: decnumber_sys::decQuad { bytes },
}
}
pub fn to_le_bytes(&self) -> [u8; 16] {
let mut bytes = self.to_ne_bytes();
if cfg!(target_endian = "big") {
bytes.reverse();
}
bytes
}
pub fn to_be_bytes(&self) -> [u8; 16] {
let mut bytes = self.to_ne_bytes();
if cfg!(target_endian = "little") {
bytes.reverse();
}
bytes
}
pub fn to_ne_bytes(&self) -> [u8; 16] {
self.inner.bytes
}
pub fn class(&self) -> Class {
Class::from_c(unsafe { decnumber_sys::decQuadClass(&self.inner) })
}
pub fn digits(&self) -> u32 {
unsafe { decnumber_sys::decQuadDigits(&self.inner) }
}
pub fn exponent(&self) -> i32 {
unsafe { decnumber_sys::decQuadGetExponent(&self.inner) }
}
pub fn canonical(mut self) -> Decimal128 {
unsafe {
decnumber_sys::decQuadCanonical(&mut self.inner, &self.inner);
}
self
}
pub fn is_canonical(&self) -> bool {
unsafe { decnumber_sys::decQuadIsCanonical(&self.inner) != 0 }
}
pub fn is_finite(&self) -> bool {
unsafe { decnumber_sys::decQuadIsFinite(&self.inner) != 0 }
}
pub fn is_infinite(&self) -> bool {
unsafe { decnumber_sys::decQuadIsInfinite(&self.inner) != 0 }
}
pub fn is_integer(&self) -> bool {
unsafe { decnumber_sys::decQuadIsInteger(&self.inner) != 0 }
}
pub fn is_logical(&self) -> bool {
unsafe { decnumber_sys::decQuadIsInteger(&self.inner) != 0 }
}
pub fn is_nan(&self) -> bool {
unsafe { decnumber_sys::decQuadIsNaN(&self.inner) != 0 }
}
pub fn is_negative(&self) -> bool {
unsafe { decnumber_sys::decQuadIsNegative(&self.inner) != 0 }
}
pub fn is_normal(&self) -> bool {
unsafe { decnumber_sys::decQuadIsNormal(&self.inner) != 0 }
}
pub fn is_positive(&self) -> bool {
unsafe { decnumber_sys::decQuadIsPositive(&self.inner) != 0 }
}
pub fn is_signaling_nan(&self) -> bool {
unsafe { decnumber_sys::decQuadIsSignaling(&self.inner) != 0 }
}
pub fn is_signed(&self) -> bool {
unsafe { decnumber_sys::decQuadIsSigned(&self.inner) != 0 }
}
pub fn is_subnormal(&self) -> bool {
unsafe { decnumber_sys::decQuadIsSubnormal(&self.inner) != 0 }
}
pub fn is_zero(&self) -> bool {
unsafe { decnumber_sys::decQuadIsZero(&self.inner) != 0 }
}
pub fn quantum_matches(&self, rhs: &Decimal128) -> bool {
unsafe { decnumber_sys::decQuadSameQuantum(&self.inner, &rhs.inner) != 0 }
}
pub fn total_cmp(&self, rhs: &Decimal128) -> Ordering {
let mut d = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d = Decimal128 {
inner: unsafe {
decnumber_sys::decQuadCompareTotal(d.as_mut_ptr(), &self.inner, &rhs.inner);
d.assume_init()
},
};
if d.is_positive() {
Ordering::Greater
} else if d.is_negative() {
Ordering::Less
} else {
debug_assert!(d.is_zero());
Ordering::Equal
}
}
}
impl Default for Decimal128 {
fn default() -> Decimal128 {
let mut d = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d = unsafe {
decnumber_sys::decQuadZero(d.as_mut_ptr());
d.assume_init()
};
Decimal128 { inner: d }
}
}
impl fmt::Debug for Decimal128 {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(self, f)
}
}
impl fmt::Display for Decimal128 {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut buf = MaybeUninit::<[c_char; decnumber_sys::DECQUAD_String]>::uninit();
let c_str = unsafe {
if f.alternate() {
decnumber_sys::decQuadToEngString(&self.inner, buf.as_mut_ptr() as *mut c_char);
} else {
decnumber_sys::decQuadToString(&self.inner, buf.as_mut_ptr() as *mut c_char);
}
CStr::from_ptr(buf.as_ptr() as *const c_char)
};
f.write_str(c_str.to_str().expect("decQuadToString yields valid UTF-8"))
}
}
impl FromStr for Decimal128 {
type Err = ParseDecimalError;
fn from_str(s: &str) -> Result<Decimal128, ParseDecimalError> {
Context::<Decimal128>::default().parse(s)
}
}
impl From<i32> for Decimal128 {
fn from(n: i32) -> Decimal128 {
let mut d = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d = unsafe {
decnumber_sys::decQuadFromInt32(d.as_mut_ptr(), n);
d.assume_init()
};
Decimal128 { inner: d }
}
}
impl From<u32> for Decimal128 {
fn from(n: u32) -> Decimal128 {
let mut d = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d = unsafe {
decnumber_sys::decQuadFromUInt32(d.as_mut_ptr(), n);
d.assume_init()
};
Decimal128 { inner: d }
}
}
impl From<Decimal32> for Decimal128 {
fn from(d32: Decimal32) -> Decimal128 {
Decimal128::from(Decimal64::from(d32))
}
}
impl From<Decimal64> for Decimal128 {
fn from(d64: Decimal64) -> Decimal128 {
let mut d128 = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d128 = unsafe {
decnumber_sys::decDoubleToWider(&d64.inner, d128.as_mut_ptr());
d128.assume_init()
};
Decimal128 { inner: d128 }
}
}
impl PartialEq for Decimal128 {
fn eq(&self, other: &Self) -> bool {
self.cmp(other) == Ordering::Equal
}
}
impl Eq for Decimal128 {}
impl PartialOrd for Decimal128 {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Decimal128 {
fn cmp(&self, other: &Self) -> Ordering {
self.total_cmp(other)
}
}
impl Add<Decimal128> for Decimal128 {
type Output = Decimal128;
fn add(self, rhs: Decimal128) -> Decimal128 {
Context::<Decimal128>::default().add(self, rhs)
}
}
impl AddAssign<Decimal128> for Decimal128 {
fn add_assign(&mut self, rhs: Decimal128) {
*self = Context::<Decimal128>::default().add(*self, rhs);
}
}
impl Div<Decimal128> for Decimal128 {
type Output = Decimal128;
fn div(self, rhs: Decimal128) -> Decimal128 {
Context::<Decimal128>::default().div(self, rhs)
}
}
impl DivAssign<Decimal128> for Decimal128 {
fn div_assign(&mut self, rhs: Decimal128) {
*self = Context::<Decimal128>::default().div(*self, rhs);
}
}
impl Mul<Decimal128> for Decimal128 {
type Output = Decimal128;
fn mul(self, rhs: Decimal128) -> Decimal128 {
Context::<Decimal128>::default().mul(self, rhs)
}
}
impl MulAssign<Decimal128> for Decimal128 {
fn mul_assign(&mut self, rhs: Decimal128) {
*self = Context::<Decimal128>::default().mul(*self, rhs);
}
}
impl Rem<Decimal128> for Decimal128 {
type Output = Decimal128;
fn rem(self, rhs: Decimal128) -> Decimal128 {
Context::<Decimal128>::default().rem(self, rhs)
}
}
impl RemAssign<Decimal128> for Decimal128 {
fn rem_assign(&mut self, rhs: Decimal128) {
*self = Context::<Decimal128>::default().rem(*self, rhs);
}
}
impl Sub<Decimal128> for Decimal128 {
type Output = Decimal128;
fn sub(self, rhs: Decimal128) -> Decimal128 {
Context::<Decimal128>::default().sub(self, rhs)
}
}
impl SubAssign<Decimal128> for Decimal128 {
fn sub_assign(&mut self, rhs: Decimal128) {
*self = Context::<Decimal128>::default().sub(*self, rhs);
}
}
impl Default for Context<Decimal128> {
fn default() -> Context<Decimal128> {
let mut ctx = MaybeUninit::<decnumber_sys::decContext>::uninit();
let ctx = unsafe {
decnumber_sys::decContextDefault(ctx.as_mut_ptr(), decnumber_sys::DEC_INIT_DECQUAD);
ctx.assume_init()
};
Context {
inner: ctx,
_phantom: PhantomData,
}
}
}
impl Context<Decimal128> {
pub fn parse<S>(&mut self, s: S) -> Result<Decimal128, ParseDecimalError>
where
S: Into<Vec<u8>>,
{
let c_string = CString::new(s).map_err(|_| ParseDecimalError)?;
let mut d = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d = unsafe {
decnumber_sys::decQuadFromString(d.as_mut_ptr(), c_string.as_ptr(), &mut self.inner);
d.assume_init()
};
if (self.inner.status & decnumber_sys::DEC_Conversion_syntax) != 0 {
Err(ParseDecimalError)
} else {
Ok(Decimal128 { inner: d })
}
}
#[cfg(feature = "arbitrary-precision")]
pub fn from_decimal<const N: usize>(&mut self, d: &Decimal<N>) -> Decimal128 {
let mut d128 = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d128 = unsafe {
decnumber_sys::decimal128FromNumber(d128.as_mut_ptr(), d.as_ptr(), &mut self.inner);
d128.assume_init()
};
Decimal128 { inner: d128 }
}
pub fn abs(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadAbs(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn add(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadAdd(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn and(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadAnd(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn div(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadDivide(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn div_integer(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadDivideInteger(
&mut lhs.inner,
&lhs.inner,
&rhs.inner,
&mut self.inner,
);
}
lhs
}
pub fn fma(&mut self, mut x: Decimal128, y: Decimal128, z: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadFMA(&mut x.inner, &x.inner, &y.inner, &z.inner, &mut self.inner);
}
x
}
pub fn invert(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadInvert(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn logb(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadLogB(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn max(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadMax(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn max_abs(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadMaxMag(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn min(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadMin(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn min_abs(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadMinMag(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn minus(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadMinus(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn mul(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadMultiply(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn next_minus(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadNextMinus(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn next_plus(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadNextPlus(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn next_toward(&mut self, mut x: Decimal128, y: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadNextToward(&mut x.inner, &x.inner, &y.inner, &mut self.inner);
}
x
}
pub fn partial_cmp(&mut self, lhs: Decimal128, rhs: Decimal128) -> Option<Ordering> {
let mut d = MaybeUninit::<decnumber_sys::decQuad>::uninit();
let d = Decimal128 {
inner: unsafe {
decnumber_sys::decQuadCompare(
d.as_mut_ptr(),
&lhs.inner,
&rhs.inner,
&mut self.inner,
);
d.assume_init()
},
};
if d.is_positive() {
Some(Ordering::Greater)
} else if d.is_negative() {
Some(Ordering::Less)
} else if d.is_zero() {
Some(Ordering::Equal)
} else {
debug_assert!(d.is_nan());
None
}
}
pub fn plus(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadPlus(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn quantize(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadQuantize(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn reduce(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadReduce(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn rem(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadRemainder(
&mut lhs.inner,
&lhs.inner,
&rhs.inner,
&mut self.inner,
);
}
lhs
}
pub fn rem_near(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadRemainderNear(
&mut lhs.inner,
&lhs.inner,
&rhs.inner,
&mut self.inner,
);
}
lhs
}
pub fn rotate(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadRotate(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn round(&mut self, mut n: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadToIntegralExact(&mut n.inner, &n.inner, &mut self.inner);
}
n
}
pub fn scaleb(&mut self, mut x: Decimal128, y: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadScaleB(&mut x.inner, &x.inner, &y.inner, &mut self.inner);
}
x
}
pub fn shift(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadShift(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn sub(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadSubtract(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn or(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadOr(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
pub fn xor(&mut self, mut lhs: Decimal128, rhs: Decimal128) -> Decimal128 {
unsafe {
decnumber_sys::decQuadXor(&mut lhs.inner, &lhs.inner, &rhs.inner, &mut self.inner);
}
lhs
}
}