# @decimal.Decimal ## Stability `Decimal`, `DecimalContext`, `DecimalFlags`, and decimal interchange are supported `0.7.1` application APIs. Internal `DecCoeff` layout is not public; the pinned legal GDA corpus is fully conformant, with only `#` placeholder/ non-scalar invalid rows excluded. This page tracks the `0.7.1` IEEE API and separate GDA representation. ## Representation ## Before You Start Use `Decimal` for decimal meaning, not for a promise that every operation is exact. Keep `DecimalContext` explicit whenever flags or exponent bounds matter. ## Semantic Reminders Numeric equality, quantum equality, and total order observe different aspects of a Decimal value. Finite values are stored as: `(-1)^negative * magnitude * 10^exponent10` with an attached working `precision`. The public `coefficient()` and `magnitude()` observers return the non-negative coefficient as `BigInt`. Use `is_negative()` when the sign must be inspected separately. This matters for GDA-style values such as `-0`, where the mathematical coefficient is zero but the representation still carries a negative sign. ## Constructors and Parsing - `Decimal::make` - `Decimal::zero` - `Decimal::negative_zero` - `Decimal::one` - `Decimal::inf` - `Decimal::nan` - `Decimal::quiet_nan` - `Decimal::signaling_nan` - `Decimal::from_int` - `Decimal::from_bigint` - `Decimal::from_float` - `Decimal::from_double` - `Decimal::from_string` - `Decimal::from_interchange_hex` - `Decimal::from_bin_float` - `DecimalInterchange::from_hex` - `DecimalInterchange::from_decimal` Notes: - Numeric constructors such as `make`, `from_int`, and `from_bigint` normalize by removing removable powers of `10`. - `from_string` accepts plain decimal, scientific notation, and `Infinity`/`NaN`/`sNaN` spellings with optional sign and decimal payload. It preserves the parsed exponent/quantum when the coefficient fits the requested precision. - `from_string("-0")` preserves negative zero. - Invalid strings return `None`. - `from_interchange_hex` decodes decimal32/64/128 interchange hex strings into scalar `Decimal` values using the requested format context. - `DecimalInterchange` is the public wrapper for raw decimal32/64/128 interchange bit patterns when callers need to preserve, inspect, or canonicalize non-canonical encodings instead of collapsing immediately to a scalar decimal value. ## Access, Normalization, and Comparison - `classify` - `class_name` - `precision` - `sign` - `coefficient` - `magnitude` - `exponent10` - `is_negative` - `is_signed` - `is_finite` - `is_infinite` - `is_nan` - `is_canonical` - `is_zero` - `is_negative_zero` - `is_normal` - `is_subnormal` - `is_quiet_nan` - `is_qnan` - `is_signaling_nan` - `is_snan` - `nan_payload` - `normalized` - `with_precision` - `compare` - `compare_ctx` - `compare_signal_ctx` - `compare_total` - `compare_total_magnitude` - `min` - `max` - `min_ctx` - `max_ctx` - `min_mag_ctx` - `max_mag_ctx` - `clamp` - `clamp_checked` Notes: - `compare` aborts on `NaN`. - `compare_ctx(lhs, rhs, ctx)` returns a decimal `-1`, `0`, `1`, or quiet `NaN` plus flags. Quiet NaNs produce quiet `NaN` without invalid-operation status; signaling NaNs set `invalid_operation`. - `compare_signal_ctx(lhs, rhs, ctx)` has the same numeric result shape as `compare_ctx`, but any NaN operand sets `invalid_operation`. - `clamp` aborts if the bounds are unordered or `NaN`. - `clamp_checked` returns a structured domain error for those invalid bounds. - The shared `Sign` observer still returns `Zero` for finite zero values, including negative zero. Use `is_negative_zero()` when the sign of zero is semantically relevant. - `class_name(ctx)` returns the GDA-style class string for the value under the supplied exponent context, including normal/subnormal distinctions. - `is_canonical()` currently returns `true` because this package has no alternate decimal interchange encodings yet. - `is_qnan()` and `is_snan()` are GDA-name aliases for the existing quiet and signaling NaN predicates. - `Eq` is numeric equality for generic Luna-Flow use: `+0 == -0`, and NaN values compare equal to each other at the `Eq` layer. Use the explicit NaN observers when representation-level distinction matters. ## Arithmetic and Conversion ## When To Use Context APIs Prefer `*_ctx` for IEEE Decimal workflows that must observe rounding and `DecimalFlags`; convenience operators intentionally discard those flags. Use `decimal_gda` when sticky GDA status or traps are required. - `neg` - `abs` - `copy` - `copy_abs` - `copy_negate` - `copy_sign` - `add` - `add_ctx` - `plus_ctx` - `minus_ctx` - `abs_ctx` - `sub` - `sub_ctx` - `mul` - `mul_ctx` - `div` - `div_ctx` - `sqrt` - `sqrt_ctx` - `fma_ctx` - `divide_integer` - `remainder` - `remainder_near` - `next_plus` - `next_minus` - `next_toward` - `exp_ctx` - `exp2_ctx`, `exp10_ctx`, `expm1_ctx` - `ln_ctx` - `log2_ctx`, `log10_ctx`, `log1p_ctx` - `power_ctx`, `pown_ctx`, `rootn_ctx`, `hypot_ctx` - `sin_ctx`, `cos_ctx`, `tan_ctx` - `sinpi_ctx`, `cospi_ctx`, `tanpi_ctx` - `asin_ctx`, `acos_ctx`, `atan_ctx`, `atan2_ctx` - `sinh_ctx`, `cosh_ctx`, `tanh_ctx` - `asinh_ctx`, `acosh_ctx`, `atanh_ctx` - `logb_ctx` - `scaleb_ctx` - `to_sci_string` - `to_eng_string` - `shift_ctx` - `rotate_ctx` - `quantize` - `rescale` - `reduce_ctx` - `normalize_ctx` - `same_quantum` - `quantum` - `get_payload` - `set_payload` - `set_payload_signaling` - `to_integral_exact` - `to_integral_value` - `logical_and` - `logical_or` - `logical_xor` - `logical_invert` - `to_interchange_hex` - `to_bin_float` Every elementary `*_ctx` entry has an additive `try_*_ctx` mirror that returns `ArithmeticError::CertificationFailure` when the enclosure cannot prove a unique target value and flags. The GDA-standard surface remains limited to `exp`, `ln`, `log10`, `power`, and `sqrt`; the other families above are IEEE Decimal extensions and are not exported by `decimal_gda`. ## Interchange Encoding - `DecimalInterchangeFormat::context` - `Decimal::to_interchange_hex` - `DecimalInterchange::format` - `DecimalInterchange::to_hex` - `DecimalInterchange::to_decimal` - `DecimalInterchange::canonical` - `DecimalInterchange::is_canonical` - `DecimalInterchange::copy` - `DecimalInterchange::copy_abs` - `DecimalInterchange::copy_negate` - `DecimalInterchange::copy_sign` Supported operators: - `+` - `-` - `*` - `/` - unary `-` Conversion notes: - Decimal-to-binary conversion may be approximate for non-dyadic values. - Binary-to-decimal conversion is exact for the currently stored finite `BinFloat` value. - `to_sci_string(src, ctx)` and `to_eng_string(src, ctx)` implement the GDA string-conversion operations used by `toSci` and `toEng` decTests. They parse finite numbers, infinities, qNaNs, and sNaNs from text under the active decimal context, then return canonical GDA scientific or engineering text together with conversion status flags. The conversion path handles syntax diagnostics, payload bounds, discarded-zero `rounded` status, directed overflow to infinity or maximum finite value, Etiny underflow, clamped zero exponents, and canonical special-value spellings such as `Infinity`, `NaN7`, and `sNaN`. - `logb_ctx` returns the adjusted exponent as a Decimal integer under the active context. Finite zero returns `-Infinity` with `division_by_zero`; infinities return `+Infinity`; NaNs propagate through the context quieting/payload rules. When the adjusted exponent needs context rounding, discarded zero digits set `rounded` without `inexact`, matching GDA integer-result semantics. - `scaleb_ctx` returns `self * 10^other` under the active context. The scale operand must be a finite exponent-zero integer within the GDA context range; invalid scale operands return quiet `NaN` with `invalid_operation`. Finite results preserve coefficient cohorts where possible, then apply exponent-bound finalization, including Etiny subnormal rounding, clamped zero, and directed overflow flags. - `shift_ctx` and `rotate_ctx` implement GDA coefficient digit movement using the active context precision as the digit width. Count operands must be finite integers in range; invalid counts return quiet `NaN` with `invalid_operation`. Quiet NaNs propagate their sign and payload, and signaling NaNs are quieted with payload truncation governed by the context precision. - `to_interchange_hex(format)` encodes a `Decimal` into decimal32/64/128 interchange hex text after applying the target format context to finite values. `from_interchange_hex(src, format)` performs the inverse decode and accepts canonical and non-canonical interchange payloads, optional leading `#`, either hex case, and surrounding ASCII whitespace. - `DecimalInterchange::to_hex()` emits canonical wrapper text with an uppercase hex body and the fixed digit width required by the stored decimal32/64/128 format. - `DecimalInterchangeFormat::context()` returns the matching decimal32, decimal64, or decimal128 preset context used by the interchange encode/decode helpers. - `DecimalInterchange::from_decimal(value, format)` is the wrapper-form encode entry point: it returns the same representation and status flags as `value.to_interchange_hex(format)`, but packages the resulting bits as a `DecimalInterchange` for further representation-level operations. - `DecimalInterchange` preserves raw interchange bits for callers that need representation-level operations such as canonicalization or sign-copy without first collapsing to a scalar Decimal cohort. - `DecimalInterchange::canonical()` preserves the current interchange format, canonicalizes the raw bits once, and is idempotent when applied repeatedly. - `DecimalInterchange::is_canonical()` is the representation-level predicate paired with `canonical()`: it reports whether the current raw bits are already in canonical interchange form, including for special-value encodings. - `DecimalInterchange::to_decimal()` decodes the wrapper using its stored interchange format, preserving special-value sign, qNaN/sNaN kind, and payload semantics represented by the raw bits. - `DecimalInterchange::copy()` is a representation-preserving wrapper copy: it keeps the original raw bits and format unchanged, including non-canonical encodings. - `DecimalInterchange::copy_sign` requires both operands to use the same interchange format; mixed-format sign-copy is rejected instead of silently reinterpreting bits across decimal32/64/128 layouts. - `DecimalInterchange::copy_abs`, `copy_negate`, and `copy_sign` operate on the raw sign bit only; they preserve payload/coefficient continuation bits for NaNs, infinities, and finite encodings. ## Context And Flags - `DecimalContext::new` - `DecimalContext::try_new` - `DecimalContext::decimal32` - `DecimalContext::decimal64` - `DecimalContext::decimal128` - `DecimalContext::from_arithmetic_context` - `DecimalRoundingMode::from_arithmetic` - `DecimalRoundingMode::to_arithmetic` - `DecimalFlags::new` - `DecimalFlags::combine` - `DecimalFlags::has_error` `*_ctx` methods return `(Decimal, DecimalFlags)`. The current context layer reports `lost_digits` when non-extended GDA arithmetic reduces an oversized operand inexactly before applying the operation. tracks rounded and inexact finite results, signaling-NaN invalid operations, division by zero, undefined division, finite-result exponent bounds, clamp padding, overflow, subnormal, and underflow status. The decimal32/64/128 constructors store the expected precision and exponent bounds, and finite context-aware results are finalized against those bounds. `DecimalContext` stores both the shared Luna-Flow `rounding` mode and a decimal-native `decimal_rounding` mode. The shared field is the bridge for `ArithmeticContext` and generic checked traits. The decimal-native field covers the full GDA rounding baseline used by context-aware Decimal operations: `HalfEven`, `HalfUp`, `HalfDown`, `Down`, `Ceiling`, `Floor`, `Up`, and `ZeroFiveUp`. GDA-only modes such as `HalfUp`, `HalfDown`, and `ZeroFiveUp` return `None` from `DecimalRoundingMode::to_arithmetic()` because the shared Luna-Flow rounding enum intentionally does not claim those modes. The `extended` named argument of `DecimalContext::new` selects the GDA arithmetic mode and defaults to `true`. Most callers therefore get extended arithmetic without extra configuration. Use `DecimalContext::new(precision=17, extended=false)` when classic decNumber subset behavior is required, including operand reduction, `lost_digits`, zero and cohort cleanup, and classic transcendental rounding. The exponent-bound implementation follows the GDA baseline rules and is covered by the legal-row conformance run. Results above `e_max` produce an infinity and set `overflow`, `rounded`, and `inexact`. Exact results below `e_min` set `subnormal`; inexact subnormal results also set `underflow`. Clamp mode can pad the coefficient with trailing zeros and lower the exponent while preserving the numeric value, setting `clamped`. Context-aware finite addition, subtraction, multiplication, and quantize-style operations preserve the operation's preferred exponent when the result fits the context. For example, exact decimal-scale results such as `1.20 + 3.40` can remain in the `4.60` cohort instead of being canonicalized to `4.6`. `fma_ctx` computes the multiplication exactly and applies context rounding only after adding the third operand. `divide_integer` returns the integer part of division with exponent `0` and reports `division_impossible` when the integer quotient cannot fit the context precision. `remainder` uses that integer quotient so the implemented finite cases follow `x - divide_integer(x, y) * y`. `remainder_near` uses the nearest integer quotient, with ties resolved toward the even quotient. `power_ctx` is the context-aware GDA power entry point for the current executable scalar `power.decTest` surface. It covers exact finite integer exponents, rounded large integer exponents including million-scale cases, terminating and non-terminating reciprocal results that finalize honestly through the active context, exact `+1` and `-1` identities, NaN priority propagation, infinite-base non-integer sign/domain cases, infinite-exponent limit cases, finite positive non-integer powers, finite non-integer operand-range invalid rows, and finite power-of-ten bases whose large integer exponents force overflow or half-even underflow to zero. It also reports the official math-function `Invalid_context` restriction rows. The only excluded corpus rows are diagnostic `#` interchange/non-scalar placeholders; there is no non-diagnostic scalar `power` gap. `log10_ctx` is the context-aware GDA base-10 logarithm entry point. It uses the fixed-point logarithm baseline, preserves NaN sign/payload quieting, maps signed zero to `-Infinity`, maps positive infinity to `Infinity`, rejects negative finite values and negative infinity with `invalid_operation`, and rounds positive finite logarithms through the active context. It also reports the official math-function `Invalid_context` restriction rows. `exp_ctx` and `ln_ctx` are context-aware GDA mathematical-function entry points. `exp_ctx` uses fixed-point exponential evaluation with decimal range reduction and handles NaNs, infinities, finite signed zeros (`exp(0) = 1`), general finite values, overflow/underflow boundaries, and official math-function `Invalid_context` restriction rows. `ln_ctx` uses the fixed-point logarithm baseline and handles NaNs, infinities, signed zeros, negative finite invalid-operation cases, finite values exactly equal to one (`ln(1) = 0`), and general positive finite values. `next_plus`, `next_minus`, and `next_toward` return adjacent representable decimals in the active context. They use `Etiny = e_min - precision + 1` for the subnormal lattice, preserve quiet NaN sign/payload, quiet signaling NaNs with `invalid_operation`, and handle powers of ten by stepping across the lower cohort boundary rather than using the larger upper-side quantum. `next_toward` chooses the direction from the second operand, preserves the left-hand representation for equal finite values except for zero sign-copying, and reports GDA overflow/underflow/subnormal/rounded/inexact/clamped status for directed steps. `sqrt_ctx` is the context-aware GDA square-root entry point used by decTest execution. Exact finite roots are detected with integer decimal semantics and then finalized through the context. Non-exact finite roots return a rounded approximation and set `rounded` plus `inexact`; negative finite non-zero inputs return quiet `NaN` with `invalid_operation`. `sqrt` is the checked convenience wrapper. `plus_ctx`, `minus_ctx`, and `abs_ctx` are the context-aware unary operations used by GDA testcase execution. `copy` is the quiet no-context identity operation: it preserves finite exponent/quantum and NaN sign, payload, and qNaN/sNaN state. `copy_abs`, `copy_negate`, and `copy_sign` are representation-level sign-copy operations and do not use a context. `min_ctx`, `max_ctx`, `min_mag_ctx`, and `max_mag_ctx` are the GDA-style context-aware minimum/maximum operations. They handle quiet/signaling NaNs, use total-order tie breaking for equal numeric values, and return status flags. The IEEE 754-2019 extrema family is separate from those compatibility methods: `minimum_ctx`, `minimum_number_ctx`, `maximum_ctx`, `maximum_number_ctx`, and the four `*_magnitude_ctx` variants preserve the standard distinction between NaN-propagating and number-selecting behavior. `quantum` exposes the stored decimal exponent; payload accessors replace or quiet/signaling-mark NaN payloads without changing finite operands. `logical_and`, `logical_or`, `logical_xor`, and `logical_invert` operate on GDA logical operands: finite non-negative values with exponent `0` and coefficient digits restricted to `0` and `1`. Invalid logical operands return quiet `NaN` and set `invalid_operation`. `logical_invert` uses the active context precision as the number of logical digits to invert. `quantize` returns a value with the same exponent as the quantum operand. `rescale` is currently an alias for `quantize`. `trim` strips insignificant finite trailing zeros without first applying context rounding and leaves special values unchanged. `reduce_ctx` first applies the context-aware unary plus operation, then canonicalizes the resulting finite cohort by removing trailing decimal zeros; zero is reduced to exponent `0` while preserving its sign. `normalize_ctx` is an alias for `reduce_ctx`. `to_integral_exact` quantizes to exponent `0` and reports rounded/inexact flags; `to_integral_value` returns the same rounded value but suppresses those two informational flags. ## Trait Surface ## Documentation Boundary The public inventory is generated from the package interface; implementation kernels and benchmark thresholds remain private. `Decimal` currently implements: - `@def.Floating` - `@arithmetic.ParseChecked` - `@arithmetic.SqrtChecked` - `@arithmetic.DivChecked` - `@arithmetic.CompareChecked` - `@arithmetic.PowNatChecked` - `@arithmetic.PowIntChecked` - `@luna-generic.Zero` - `@luna-generic.One` - `@luna-generic.AddMonoid` - `@luna-generic.MulMonoid` - `@luna-generic.AddGroup` - `@luna-generic.Semiring` - `@luna-generic.Ring` - `Eq`, `Add`, `Sub`, `Mul`, `Div`, `Neg`, `Show` Behavior note: - `Decimal` does not implement separate transcendental or constant traits; its elementary functions are explicit context methods. - Checked arithmetic is the intended integration surface with `Luna-Flow/arithmetic`. - The package now exposes decimal32/64/128 interchange encode/decode APIs, but conformance status is reported by the current `gda_expr` run rather than by a blanket claim of support for every diagnostic row. ## Public Inventory Addendum `DecCoeff` is package-private; the public representation boundary is `BigInt`. Additional public entry points that must remain visible in the generated interface are `Decimal::{from_string_ctx,parse,apply_ctx,div_checked,compare_checked,compare_total_ctx,compare_total_magnitude_ctx}` and `DecimalInterchange::to_decimal_ctx`. ## Complete Public Interface The following snapshot is the complete generated package interface for `0.7.1`. Public declarations are authoritative; prose above groups them by behavior. ```moonbit // Generated using `moon info`, DON'T EDIT IT package "Luna-Flow/floating/decimal" import { "Luna-Flow/arithmetic", "Luna-Flow/floating/bin_float", "Luna-Flow/floating/def", "Luna-Flow/luna-generic", "moonbitlang/core/bigint", "moonbitlang/core/debug", } // Values // Errors // Types and methods pub struct Decimal { // private fields } derive(@debug.Debug) pub fn Decimal::abs(Self) -> Self pub fn Decimal::abs_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::acos_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::acosh_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::add(Self, Self) -> Self pub fn Decimal::add_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::apply_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::asin_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::asinh_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::atan2_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::atan_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::atanh_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::clamp(Self, min~ : Self, max~ : Self) -> Self pub fn Decimal::clamp_checked(Self, min~ : Self, max~ : Self) -> Result[Self, @arithmetic.ArithmeticError] pub fn Decimal::class_name(Self, DecimalContext) -> String pub fn Decimal::classify(Self) -> @arithmetic.FpClass pub fn Decimal::coefficient(Self) -> @bigint.BigInt pub fn Decimal::compare(Self, Self) -> Int pub fn Decimal::compare_checked(Self, Self) -> Result[Int, @arithmetic.ArithmeticError] pub fn Decimal::compare_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::compare_signal_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::compare_total(Self, Self) -> Int pub fn Decimal::compare_total_ctx(Self, Self, DecimalContext) -> (Int, DecimalFlags) pub fn Decimal::compare_total_magnitude(Self, Self) -> Int pub fn Decimal::compare_total_magnitude_ctx(Self, Self, DecimalContext) -> (Int, DecimalFlags) pub fn Decimal::copy(Self) -> Self pub fn Decimal::copy_abs(Self) -> Self pub fn Decimal::copy_negate(Self) -> Self pub fn Decimal::copy_sign(Self, Self) -> Self pub fn Decimal::cos_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::cosh_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::cospi_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::div(Self, Self) -> Self pub fn Decimal::div_checked(Self, Self) -> Result[Self, @arithmetic.ArithmeticError] pub fn Decimal::div_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::divide_integer(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::exp10_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::exp2_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::exp_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::expm1_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::exponent10(Self) -> Int pub fn Decimal::fma_ctx(Self, Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::from_bigint(@bigint.BigInt, precision? : Int) -> Self pub fn Decimal::from_bin_float(@bin_float.BinFloat, precision? : Int) -> Self pub fn Decimal::from_double(Double, precision? : Int) -> Self pub fn Decimal::from_float(Float, precision? : Int) -> Self pub fn Decimal::from_int(Int, precision? : Int) -> Self pub fn Decimal::from_interchange_hex(String, DecimalInterchangeFormat) -> Self? pub fn Decimal::from_interchange_hex_with_encoding(String, DecimalInterchangeFormat, DecimalInterchangeEncoding) -> Self? pub fn Decimal::from_string(String, precision? : Int) -> Self? pub fn Decimal::from_string_ctx(String, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::get_payload(Self) -> @bigint.BigInt pub fn Decimal::hypot_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::inf(@def.Sign, precision? : Int) -> Self pub fn Decimal::is_canonical(Self) -> Bool pub fn Decimal::is_finite(Self) -> Bool pub fn Decimal::is_infinite(Self) -> Bool pub fn Decimal::is_nan(Self) -> Bool pub fn Decimal::is_negative(Self) -> Bool pub fn Decimal::is_negative_zero(Self) -> Bool pub fn Decimal::is_normal(Self, DecimalContext) -> Bool pub fn Decimal::is_qnan(Self) -> Bool pub fn Decimal::is_quiet_nan(Self) -> Bool pub fn Decimal::is_signaling_nan(Self) -> Bool pub fn Decimal::is_signed(Self) -> Bool pub fn Decimal::is_snan(Self) -> Bool pub fn Decimal::is_subnormal(Self, DecimalContext) -> Bool pub fn Decimal::is_zero(Self) -> Bool pub fn Decimal::ln_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::log10_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::log1p_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::log2_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::logb_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::logical_and(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::logical_invert(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::logical_or(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::logical_xor(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::magnitude(Self) -> @bigint.BigInt pub fn Decimal::make(@bigint.BigInt, Int, Int, mode? : @arithmetic.RoundingMode) -> Self pub fn Decimal::max(Self, Self) -> Self pub fn Decimal::max_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::max_mag_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::maximum_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::maximum_mag_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::maximum_magnitude_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::maximum_number_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::maximum_number_mag_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::maximum_number_magnitude_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::min(Self, Self) -> Self pub fn Decimal::min_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::min_mag_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::minimum_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::minimum_mag_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::minimum_magnitude_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::minimum_number_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::minimum_number_mag_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::minimum_number_magnitude_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::minus_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::mul(Self, Self) -> Self pub fn Decimal::mul_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::nan(precision? : Int) -> Self pub fn Decimal::nan_payload(Self) -> @bigint.BigInt pub fn Decimal::neg(Self) -> Self pub fn Decimal::negative_zero(precision? : Int) -> Self pub fn Decimal::next_minus(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::next_plus(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::next_toward(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::normalize_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::normalized(Self) -> Self pub fn Decimal::one(precision? : Int) -> Self pub fn Decimal::parse(String, precision? : Int) -> Result[Self, @arithmetic.ArithmeticError] pub fn Decimal::plus_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::power_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::pown_ctx(Self, Int, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::precision(Self) -> Int pub fn Decimal::quantize(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::quantum(Self) -> Int pub fn Decimal::quiet_nan(payload? : @bigint.BigInt, negative? : Bool, precision? : Int) -> Self pub fn Decimal::reduce_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::remainder(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::remainder_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::remainder_near(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::rescale(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::rootn_ctx(Self, Int, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::rotate_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::same_quantum(Self, Self) -> Bool pub fn Decimal::scaleb_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::set_payload(Self, @bigint.BigInt) -> Self pub fn Decimal::set_payload_signaling(Self, @bigint.BigInt) -> Self pub fn Decimal::shift_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::sign(Self) -> @def.Sign pub fn Decimal::signaling_nan(payload? : @bigint.BigInt, negative? : Bool, precision? : Int) -> Self pub fn Decimal::sin_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::sinh_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::sinpi_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::sqrt(Self) -> Result[Self, @arithmetic.ArithmeticError] pub fn Decimal::sqrt_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::sub(Self, Self) -> Self pub fn Decimal::sub_ctx(Self, Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::tan_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::tanh_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::tanpi_ctx(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::to_bin_float(Self, precision? : Int, mode? : @arithmetic.RoundingMode) -> @bin_float.BinFloat pub fn Decimal::to_eng_string(String, DecimalContext) -> (String, DecimalFlags) pub fn Decimal::to_integral_exact(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::to_integral_value(Self, DecimalContext) -> (Self, DecimalFlags) pub fn Decimal::to_interchange_hex(Self, DecimalInterchangeFormat) -> (String, DecimalFlags) pub fn Decimal::to_interchange_hex_with_encoding(Self, DecimalInterchangeFormat, DecimalInterchangeEncoding) -> (String, DecimalFlags) pub fn Decimal::to_sci_string(String, DecimalContext) -> (String, DecimalFlags) pub fn Decimal::trim(Self) -> Self pub fn Decimal::try_acos_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_acosh_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_asin_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_asinh_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_atan2_ctx(Self, Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_atan_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_atanh_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_cos_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_cosh_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_cospi_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_exp10_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_exp2_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_exp_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_expm1_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_hypot_ctx(Self, Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_ln_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_log10_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_log1p_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_log2_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_power_ctx(Self, Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_pown_ctx(Self, Int, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_rootn_ctx(Self, Int, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_sin_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_sinh_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_sinpi_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_tan_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_tanh_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::try_tanpi_ctx(Self, DecimalContext) -> Result[(Self, DecimalFlags), @arithmetic.ArithmeticError] pub fn Decimal::with_precision(Self, Int, @arithmetic.RoundingMode) -> Self pub fn Decimal::zero(precision? : Int) -> Self pub impl @arithmetic.AbsContextual for Decimal pub impl @arithmetic.AddContextual for Decimal pub impl @arithmetic.CompareChecked for Decimal pub impl @arithmetic.DivChecked for Decimal pub impl @arithmetic.DivContextual for Decimal pub impl @arithmetic.ExpContextual for Decimal pub impl @arithmetic.MulContextual for Decimal pub impl @arithmetic.NumericFormatContextual for Decimal pub impl @arithmetic.ParseChecked for Decimal pub impl @arithmetic.PowIntChecked for Decimal pub impl @arithmetic.PowNatChecked for Decimal pub impl @arithmetic.SqrtChecked for Decimal pub impl @arithmetic.SqrtContextual for Decimal pub impl @arithmetic.SubContextual for Decimal pub impl @def.Floating for Decimal pub impl @luna-generic.AddGroup for Decimal pub impl @luna-generic.AddMonoid for Decimal pub impl @luna-generic.IntegralHomomorphism for Decimal pub impl @luna-generic.MulMonoid for Decimal pub impl @luna-generic.NatHomomorphism for Decimal pub impl @luna-generic.One for Decimal pub impl @luna-generic.Ring for Decimal pub impl @luna-generic.Semiring for Decimal pub impl @luna-generic.Zero for Decimal pub impl Add for Decimal pub impl Compare for Decimal pub impl Div for Decimal pub impl Eq for Decimal pub impl Mul for Decimal pub impl Neg for Decimal pub impl Show for Decimal pub impl Sub for Decimal pub struct DecimalContext { // private fields } derive(Eq) pub fn DecimalContext::clamp(Self) -> Bool pub fn DecimalContext::decimal128() -> Self pub fn DecimalContext::decimal32() -> Self pub fn DecimalContext::decimal64() -> Self pub fn DecimalContext::decimal_rounding(Self) -> DecimalRoundingMode pub fn DecimalContext::e_max(Self) -> Int pub fn DecimalContext::e_min(Self) -> Int pub fn DecimalContext::exact() -> Self pub fn DecimalContext::extended(Self) -> Bool pub fn DecimalContext::from_arithmetic_context(@arithmetic.ArithmeticContext) -> Self pub fn DecimalContext::ieee754(Self) -> Self pub fn DecimalContext::is754version2019(Self) -> Bool pub fn DecimalContext::new(precision? : Int, rounding? : @arithmetic.RoundingMode, decimal_rounding? : DecimalRoundingMode, e_min? : Int, e_max? : Int, clamp? : Bool, extended? : Bool, tininess? : DecimalTininessDetection) -> Self pub fn DecimalContext::precision(Self) -> Int pub fn DecimalContext::rounding(Self) -> @arithmetic.RoundingMode pub fn DecimalContext::tininess(Self) -> DecimalTininessDetection pub fn DecimalContext::try_new(precision? : Int, rounding? : @arithmetic.RoundingMode, decimal_rounding? : DecimalRoundingMode, e_min? : Int, e_max? : Int, clamp? : Bool, extended? : Bool, tininess? : DecimalTininessDetection) -> Result[Self, @arithmetic.ArithmeticError] pub fn DecimalContext::with_rounding(Self, @arithmetic.RoundingMode) -> Self pub fn DecimalContext::with_tininess(Self, DecimalTininessDetection) -> Self pub struct DecimalFlags { inexact : Bool rounded : Bool lost_digits : Bool invalid_operation : Bool division_by_zero : Bool overflow : Bool underflow : Bool subnormal : Bool clamped : Bool conversion_syntax : Bool division_impossible : Bool division_undefined : Bool invalid_context : Bool } derive(Eq) pub fn DecimalFlags::combine(Self, Self) -> Self pub fn DecimalFlags::contains(Self, DecimalSignal) -> Bool pub fn DecimalFlags::has_error(Self) -> Bool pub fn DecimalFlags::new() -> Self pub struct DecimalInterchange { // private fields } pub fn DecimalInterchange::canonical(Self) -> Self pub fn DecimalInterchange::copy(Self) -> Self pub fn DecimalInterchange::copy_abs(Self) -> Self pub fn DecimalInterchange::copy_negate(Self) -> Self pub fn DecimalInterchange::copy_sign(Self, Self) -> Self pub fn DecimalInterchange::encoding(Self) -> DecimalInterchangeEncoding pub fn DecimalInterchange::format(Self) -> DecimalInterchangeFormat pub fn DecimalInterchange::from_decimal(Decimal, DecimalInterchangeFormat) -> (Self, DecimalFlags) pub fn DecimalInterchange::from_decimal_with_encoding(Decimal, DecimalInterchangeFormat, DecimalInterchangeEncoding) -> (Self, DecimalFlags) pub fn DecimalInterchange::from_hex(String, DecimalInterchangeFormat) -> Self? pub fn DecimalInterchange::from_hex_with_encoding(String, DecimalInterchangeFormat, DecimalInterchangeEncoding) -> Self? pub fn DecimalInterchange::is_canonical(Self) -> Bool pub fn DecimalInterchange::to_decimal(Self) -> Decimal pub fn DecimalInterchange::to_decimal_ctx(Self) -> (Decimal, DecimalFlags) pub fn DecimalInterchange::to_hex(Self) -> String pub(all) enum DecimalInterchangeEncoding { DPD BID } derive(Eq) pub(all) enum DecimalInterchangeFormat { Decimal32 Decimal64 Decimal128 } derive(Eq) pub fn DecimalInterchangeFormat::context(Self) -> DecimalContext pub(all) enum DecimalRoundingMode { HalfEven HalfUp HalfDown Down Ceiling Floor Up ZeroFiveUp } derive(Eq) pub fn DecimalRoundingMode::from_arithmetic(@arithmetic.RoundingMode) -> Self pub fn DecimalRoundingMode::to_arithmetic(Self) -> @arithmetic.RoundingMode? pub(all) enum DecimalSignal { ConversionSyntax DivisionByZero DivisionImpossible DivisionUndefined InvalidContext InvalidOperation Overflow Underflow Subnormal Inexact Rounded Clamped LostDigits } derive(Eq) pub(all) enum DecimalTininessDetection { BeforeRounding AfterRounding } derive(Eq) // Type aliases // Traits ```