Implement SignedFixedDecimal and UnsignedFixedDecimal

components/datetime/src/format/datetime.rs

@@ -17,7 +17,7 @@ use crate::time_zone::{
 };
 
 use core::fmt::{self, Write};
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::{SignedFixedDecimal, UnsignedFixedDecimal};
 use icu_calendar::types::{
     FormattingEra, {DayOfWeekInMonth, IsoWeekday, MonthCode},
 };
@@ -29,7 +29,7 @@ use writeable::{Part, Writeable};
 fn try_write_number<W>(
     result: &mut W,
     fixed_decimal_format: Option<&FixedDecimalFormatter>,
-    mut num: FixedDecimal,
+    mut num: SignedFixedDecimal,
     length: FieldLength,
 ) -> Result<Result<(), DateTimeWriteError>, fmt::Error>
 where
@@ -39,20 +39,20 @@ where
         match length {
             FieldLength::One | FieldLength::NumericOverride(_) => {}
             FieldLength::TwoDigit => {
-                num.pad_start(2);
-                num.set_max_position(2);
+                num.absolute.pad_start(2);
+                num.absolute.set_max_position(2);
             }
             FieldLength::Abbreviated => {
-                num.pad_start(3);
+                num.absolute.pad_start(3);
             }
             FieldLength::Wide => {
-                num.pad_start(4);
+                num.absolute.pad_start(4);
             }
             FieldLength::Narrow => {
-                num.pad_start(5);
+                num.absolute.pad_start(5);
             }
             FieldLength::Six => {
-                num.pad_start(6);
+                num.absolute.pad_start(6);
             }
         }
 
@@ -417,13 +417,14 @@ where
                 }
                 (Some(second), Some(ns)) => {
                     // Formatting with fractional seconds
-                    let mut s = FixedDecimal::from(usize::from(second));
-                    let _infallible =
-                        s.concatenate_end(FixedDecimal::from(usize::from(ns)).multiplied_pow10(-9));
+                    let mut s = SignedFixedDecimal::from(usize::from(second));
+                    let _infallible = s.absolute.concatenate_end(
+                        UnsignedFixedDecimal::from(usize::from(ns)).multiplied_pow10(-9),
+                    );
                     debug_assert!(_infallible.is_ok());
                     let position = -(decimal_second as i16);
-                    s.trunc(position);
-                    s.pad_end(position);
+                    s.absolute.trunc(position);
+                    s.absolute.pad_end(position);
                     try_write_number(w, fdf, s, l)?
                 }
             }
@@ -614,7 +615,7 @@ mod tests {
                 try_write_number(
                     &mut writeable::adapters::CoreWriteAsPartsWrite(&mut s),
                     Some(&fixed_decimal_format),
-                    FixedDecimal::from(*value),
+                    SignedFixedDecimal::from(*value),
                     *length,
                 )
                 .unwrap()

components/datetime/src/time_zone.rs

@@ -11,7 +11,7 @@ use crate::{
     provider,
 };
 use core::fmt;
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::SignedFixedDecimal;
 use icu_calendar::{Date, Iso, Time};
 use icu_decimal::FixedDecimalFormatter;
 use icu_timezone::{TimeZoneBcp47Id, UtcOffset, ZoneVariant};
@@ -491,33 +491,33 @@ impl FormatTimeZone for LocalizedOffsetFormat {
                     &self,
                     sink: &mut S,
                 ) -> fmt::Result {
-                    self.fdf
-                        .format(
-                            &FixedDecimal::from(self.offset.hours_part())
-                                .with_sign_display(fixed_decimal::SignDisplay::Always)
-                                .padded_start(if self.length == FieldLength::Wide {
-                                    2
-                                } else {
-                                    0
-                                }),
-                        )
-                        .write_to(sink)?;
+                    let mut signed_fdf = SignedFixedDecimal::from(self.offset.hours_part())
+                        .with_sign_display(fixed_decimal::SignDisplay::Always);
+                    signed_fdf
+                        .absolute
+                        .pad_start(if self.length == FieldLength::Wide {
+                            2
+                        } else {
+                            0
+                        });
+                    self.fdf.format(&signed_fdf).write_to(sink)?;
 
                     if self.length == FieldLength::Wide
                         || self.offset.minutes_part() != 0
                         || self.offset.seconds_part() != 0
                     {
+                        let mut signed_fdf = SignedFixedDecimal::from(self.offset.minutes_part());
+                        signed_fdf.absolute.pad_start(2);
                         sink.write_str(self.separator)?;
-                        self.fdf
-                            .format(&FixedDecimal::from(self.offset.minutes_part()).padded_start(2))
-                            .write_to(sink)?;
+                        self.fdf.format(&signed_fdf).write_to(sink)?;
                     }
 
                     if self.offset.seconds_part() != 0 {
                         sink.write_str(self.separator)?;
-                        self.fdf
-                            .format(&FixedDecimal::from(self.offset.seconds_part()).padded_start(2))
-                            .write_to(sink)?;
+
+                        let mut signed_fdf = SignedFixedDecimal::from(self.offset.seconds_part());
+                        signed_fdf.absolute.pad_start(2);
+                        self.fdf.format(&signed_fdf).write_to(sink)?;
                     }
 
                     Ok(())

components/decimal/benches/fixed_decimal_format.rs

@@ -8,7 +8,7 @@ use rand_pcg::Lcg64Xsh32;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::SignedFixedDecimal;
 use icu_decimal::provider::DecimalSymbolsV1Marker;
 use icu_decimal::FixedDecimalFormatter;
 use icu_provider_adapters::fixed::FixedProvider;
@@ -38,7 +38,7 @@ fn overview_bench(c: &mut Criterion) {
             )
             .unwrap();
             for &num in &nums {
-                let fd = FixedDecimal::from(black_box(num));
+                let fd = SignedFixedDecimal::from(black_box(num));
                 fdf.format_to_string(&fd);
             }
         });

components/decimal/src/format.rs

@@ -7,15 +7,15 @@
 use crate::grouper;
 use crate::options::*;
 use crate::provider::*;
-use fixed_decimal::FixedDecimal;
 use fixed_decimal::Sign;
+use fixed_decimal::SignedFixedDecimal;
 use writeable::Writeable;
 
 /// An intermediate structure returned by [`FixedDecimalFormatter`](crate::FixedDecimalFormatter).
 /// Use [`Writeable`][Writeable] to render the formatted decimal to a string or buffer.
 #[derive(Debug, PartialEq, Clone)]
 pub struct FormattedFixedDecimal<'l> {
-    pub(crate) value: &'l FixedDecimal,
+    pub(crate) value: &'l SignedFixedDecimal,
     pub(crate) options: &'l FixedDecimalFormatterOptions,
     pub(crate) symbols: &'l DecimalSymbolsV1<'l>,
 }
@@ -39,14 +39,14 @@ impl Writeable for FormattedFixedDecimal<'_> {
         if let Some(affixes) = affixes {
             sink.write_str(&affixes.prefix)?;
         }
-        let range = self.value.magnitude_range();
+        let range = self.value.absolute.magnitude_range();
         let upper_magnitude = *range.end();
         for m in range.rev() {
             if m == -1 {
                 sink.write_str(&self.symbols.decimal_separator)?;
             }
             #[allow(clippy::indexing_slicing)] // digit_at in 0..=9
-            sink.write_char(self.symbols.digits[self.value.digit_at(m) as usize])?;
+            sink.write_char(self.symbols.digits[self.value.absolute.digit_at(m) as usize])?;
             if grouper::check(
                 upper_magnitude,
                 m,

components/decimal/src/grouper.rs

@@ -56,7 +56,7 @@ fn test_grouper() {
     use crate::options;
     use crate::provider::*;
     use crate::FixedDecimalFormatter;
-    use fixed_decimal::FixedDecimal;
+    use fixed_decimal::SignedFixedDecimal;
     use icu_provider::prelude::*;
     use icu_provider_adapters::fixed::FixedProvider;
     use writeable::assert_writeable_eq;
@@ -153,7 +153,7 @@ fn test_grouper() {
     ];
     for cas in &cases {
         for i in 0..4 {
-            let dec = FixedDecimal::from(1).multiplied_pow10((i as i16) + 3);
+            let dec = SignedFixedDecimal::from(1).multiplied_pow10((i as i16) + 3);
             let provider = FixedProvider::<DecimalSymbolsV1Marker>::from_owned(
                 crate::provider::DecimalSymbolsV1 {
                     grouping_sizes: cas.sizes,

components/decimal/src/lib.rs

@@ -98,7 +98,7 @@ pub mod provider;
 pub use format::FormattedFixedDecimal;
 
 use alloc::string::String;
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::SignedFixedDecimal;
 use icu_provider::prelude::*;
 use writeable::Writeable;
 
@@ -157,7 +157,7 @@ impl FixedDecimalFormatter {
     }
 
     /// Formats a [`FixedDecimal`], returning a [`FormattedFixedDecimal`].
-    pub fn format<'l>(&'l self, value: &'l FixedDecimal) -> FormattedFixedDecimal<'l> {
+    pub fn format<'l>(&'l self, value: &'l SignedFixedDecimal) -> FormattedFixedDecimal<'l> {
         FormattedFixedDecimal {
             value,
             options: &self.options,
@@ -166,7 +166,7 @@ impl FixedDecimalFormatter {
     }
 
     /// Formats a [`FixedDecimal`], returning a [`String`].
-    pub fn format_to_string(&self, value: &FixedDecimal) -> String {
+    pub fn format_to_string(&self, value: &SignedFixedDecimal) -> String {
         self.format(value).write_to_string().into_owned()
     }
 }

components/experimental/src/compactdecimal/format.rs

@@ -3,7 +3,7 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 use alloc::borrow::Cow;
-use fixed_decimal::{CompactDecimal, FixedDecimal};
+use fixed_decimal::{CompactDecimal, SignedFixedDecimal};
 use writeable::Writeable;
 use zerovec::maps::ZeroMap2dCursor;
 
@@ -62,7 +62,7 @@ impl Writeable for FormattedCompactDecimal<'_> {
         } else {
             let plural_map = self.plural_map.as_ref().ok_or(core::fmt::Error)?;
             let chosen_pattern = (|| {
-                if self.value.significand() == &FixedDecimal::from(1) {
+                if self.value.significand() == &SignedFixedDecimal::from(1) {
                     if let Some(pattern) = plural_map.get1(&Count::Explicit1) {
                         return Some(pattern);
                     }

components/experimental/src/compactdecimal/formatter.rs

@@ -13,7 +13,7 @@ use crate::compactdecimal::{
 };
 use alloc::borrow::Cow;
 use core::convert::TryFrom;
-use fixed_decimal::{CompactDecimal, FixedDecimal};
+use fixed_decimal::{CompactDecimal, SignedFixedDecimal};
 use icu_decimal::FixedDecimalFormatter;
 use icu_plurals::PluralRules;
 use icu_provider::DataError;
@@ -280,7 +280,7 @@ impl CompactDecimalFormatter {
     /// assert_writeable_eq!(short_english.format_i64(-1_172_700), "-1.2M");
     /// ```
     pub fn format_i64(&self, value: i64) -> FormattedCompactDecimal<'_> {
-        let unrounded = FixedDecimal::from(value);
+        let unrounded = SignedFixedDecimal::from(value);
         self.format_fixed_decimal(unrounded)
     }
 
@@ -345,7 +345,7 @@ impl CompactDecimalFormatter {
         use fixed_decimal::FloatPrecision::RoundTrip;
         // NOTE: This first gets the shortest representation of the f64, which
         // manifests as double rounding.
-        let partly_rounded = FixedDecimal::try_from_f64(value, RoundTrip)?;
+        let partly_rounded = SignedFixedDecimal::try_from_f64(value, RoundTrip)?;
         Ok(self.format_fixed_decimal(partly_rounded))
     }
 
@@ -447,20 +447,21 @@ impl CompactDecimalFormatter {
     ///     "-1.2M"
     /// );
     /// ```
-    pub fn format_fixed_decimal(&self, value: FixedDecimal) -> FormattedCompactDecimal<'_> {
-        let log10_type = value.nonzero_magnitude_start();
+    pub fn format_fixed_decimal(&self, value: SignedFixedDecimal) -> FormattedCompactDecimal<'_> {
+        let log10_type = value.absolute.nonzero_magnitude_start();
         let (mut plural_map, mut exponent) = self.plural_map_and_exponent_for_magnitude(log10_type);
         let mut significand = value.multiplied_pow10(-i16::from(exponent));
         // If we have just one digit before the decimal point…
-        if significand.nonzero_magnitude_start() == 0 {
+        if significand.absolute.nonzero_magnitude_start() == 0 {
             // …round to one fractional digit…
             significand.round(-1);
         } else {
             // …otherwise, we have at least 2 digits before the decimal point,
             // so round to eliminate the fractional part.
             significand.round(0);
         }
-        let rounded_magnitude = significand.nonzero_magnitude_start() + i16::from(exponent);
+        let rounded_magnitude =
+            significand.absolute.nonzero_magnitude_start() + i16::from(exponent);
         if rounded_magnitude > log10_type {
             // We got bumped up a magnitude by rounding.
             // This means that `significand` is a power of 10.
@@ -476,7 +477,7 @@ impl CompactDecimalFormatter {
             // only have become larger, it is already the correct rounding of
             // `unrounded` to the precision we want to show.
         }
-        significand.trim_end();
+        significand.absolute.trim_end();
         FormattedCompactDecimal {
             formatter: self,
             plural_map,
@@ -589,7 +590,7 @@ impl CompactDecimalFormatter {
         value: &'l CompactDecimal,
     ) -> Result<FormattedCompactDecimal<'l>, ExponentError> {
         let log10_type =
-            value.significand().nonzero_magnitude_start() + i16::from(value.exponent());
+            value.significand().absolute.nonzero_magnitude_start() + i16::from(value.exponent());
 
         let (plural_map, expected_exponent) =
             self.plural_map_and_exponent_for_magnitude(log10_type);

components/experimental/src/dimension/currency/format.rs

@@ -2,7 +2,7 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::SignedFixedDecimal;
 
 use icu_decimal::FixedDecimalFormatter;
 use writeable::Writeable;
@@ -14,7 +14,7 @@ use crate::dimension::provider::currency;
 use crate::dimension::provider::currency::CurrencyEssentialsV1;
 
 pub struct FormattedCurrency<'l> {
-    pub(crate) value: &'l FixedDecimal,
+    pub(crate) value: &'l SignedFixedDecimal,
     pub(crate) currency_code: CurrencyCode,
     pub(crate) options: &'l CurrencyFormatterOptions,
     pub(crate) essential: &'l CurrencyEssentialsV1<'l>,

components/experimental/src/dimension/currency/formatter.rs

@@ -4,7 +4,7 @@
 
 //! Experimental.
 
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::SignedFixedDecimal;
 use icu_decimal::{options::FixedDecimalFormatterOptions, FixedDecimalFormatter};
 use icu_provider::prelude::*;
 
@@ -123,7 +123,7 @@ impl CurrencyFormatter {
     /// ```
     pub fn format_fixed_decimal<'l>(
         &'l self,
-        value: &'l FixedDecimal,
+        value: &'l SignedFixedDecimal,
         currency_code: CurrencyCode,
     ) -> FormattedCurrency<'l> {
         FormattedCurrency {

components/experimental/src/dimension/currency/long_format.rs

@@ -2,7 +2,7 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::SignedFixedDecimal;
 
 use icu_decimal::FixedDecimalFormatter;
 use icu_plurals::PluralRules;
@@ -14,7 +14,7 @@ use crate::dimension::provider::extended_currency::CurrencyExtendedDataV1;
 use super::CurrencyCode;
 
 pub struct LongFormattedCurrency<'l> {
-    pub(crate) value: &'l FixedDecimal,
+    pub(crate) value: &'l SignedFixedDecimal,
     // TODO: use this if the display name is not exist and make the extended data optional.
     pub(crate) _currency_code: CurrencyCode,
     pub(crate) extended: &'l CurrencyExtendedDataV1<'l>,

components/experimental/src/dimension/currency/long_formatter.rs

@@ -4,7 +4,7 @@
 
 //! Experimental.
 
-use fixed_decimal::FixedDecimal;
+use fixed_decimal::SignedFixedDecimal;
 use icu_decimal::{options::FixedDecimalFormatterOptions, FixedDecimalFormatter};
 use icu_plurals::PluralRules;
 use icu_provider::prelude::*;
@@ -158,7 +158,7 @@ impl LongCurrencyFormatter {
     /// ```
     pub fn format_fixed_decimal<'l>(
         &'l self,
-        value: &'l FixedDecimal,
+        value: &'l SignedFixedDecimal,
         currency_code: CurrencyCode,
     ) -> LongFormattedCurrency<'l> {
         LongFormattedCurrency {