Skip to main content

malachite_float/float/arithmetic/
canonicalize_gaussian_unit.rs

1// Copyright © 2026 Mikhail Hogrefe
2//
3// This file is part of Malachite.
4//
5// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
6// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
7// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
8
9use crate::Float;
10use malachite_base::num::arithmetic::traits::{
11    Abs, AbsAssign, CanonicalizeGaussianUnit, CanonicalizeGaussianUnitAssign,
12};
13
14impl CanonicalizeGaussianUnit for Float {
15    type Output = Self;
16
17    /// Brings a [`Float`] into canonical Gaussian-unit form, taking it by value.
18    ///
19    /// The canonical Gaussian-unit form of a real number is its absolute value, so this clears the
20    /// sign bit of every [`Float`], the special values included: $-0.0$ becomes $0.0$ and $-\infty$
21    /// becomes $\infty$, while NaN is left alone. This differs from
22    /// [`canonicalize_unit`](malachite_base::num::arithmetic::traits::CanonicalizeUnit), which
23    /// gives 1 for every finite nonzero [`Float`], since those are the units.
24    ///
25    /// # Worst-case complexity
26    /// Constant time and additional memory.
27    ///
28    /// # Examples
29    /// ```
30    /// use malachite_base::num::arithmetic::traits::CanonicalizeGaussianUnit;
31    /// use malachite_base::num::basic::traits::NegativeInfinity;
32    /// use malachite_float::Float;
33    ///
34    /// assert_eq!(Float::from(-1.5).canonicalize_gaussian_unit(), 1.5);
35    /// assert_eq!(Float::from(1.5).canonicalize_gaussian_unit(), 1.5);
36    /// assert_eq!(
37    ///     Float::NEGATIVE_INFINITY
38    ///         .canonicalize_gaussian_unit()
39    ///         .to_string(),
40    ///     "Infinity"
41    /// );
42    /// ```
43    #[inline]
44    fn canonicalize_gaussian_unit(self) -> Self {
45        self.abs()
46    }
47}
48
49impl CanonicalizeGaussianUnit for &Float {
50    type Output = Float;
51
52    /// Brings a [`Float`] into canonical Gaussian-unit form, taking it by reference.
53    ///
54    /// The canonical Gaussian-unit form of a real number is its absolute value, so this clears the
55    /// sign bit of every [`Float`], the special values included: $-0.0$ becomes $0.0$ and $-\infty$
56    /// becomes $\infty$, while NaN is left alone. This differs from
57    /// [`canonicalize_unit`](malachite_base::num::arithmetic::traits::CanonicalizeUnit), which
58    /// gives 1 for every finite nonzero [`Float`], since those are the units.
59    ///
60    /// # Worst-case complexity
61    /// $T(n) = O(n)$
62    ///
63    /// $M(n) = O(n)$
64    ///
65    /// where $T$ is time, $M$ is additional memory, and $n$ is `self.significant_bits()`.
66    ///
67    /// # Examples
68    /// ```
69    /// use malachite_base::num::arithmetic::traits::CanonicalizeGaussianUnit;
70    /// use malachite_base::num::basic::traits::NegativeInfinity;
71    /// use malachite_float::Float;
72    ///
73    /// assert_eq!((&Float::from(-1.5)).canonicalize_gaussian_unit(), 1.5);
74    /// assert_eq!((&Float::from(1.5)).canonicalize_gaussian_unit(), 1.5);
75    /// assert_eq!(
76    ///     (&Float::NEGATIVE_INFINITY)
77    ///         .canonicalize_gaussian_unit()
78    ///         .to_string(),
79    ///     "Infinity"
80    /// );
81    /// ```
82    #[inline]
83    fn canonicalize_gaussian_unit(self) -> Float {
84        self.abs()
85    }
86}
87
88impl CanonicalizeGaussianUnitAssign for Float {
89    /// Replaces a [`Float`] with its canonical Gaussian-unit form: its absolute value.
90    ///
91    /// # Worst-case complexity
92    /// Constant time and additional memory.
93    ///
94    /// # Examples
95    /// ```
96    /// use malachite_base::num::arithmetic::traits::CanonicalizeGaussianUnitAssign;
97    /// use malachite_float::Float;
98    ///
99    /// let mut x = Float::from(-1.5);
100    /// x.canonicalize_gaussian_unit_assign();
101    /// assert_eq!(x, 1.5);
102    /// ```
103    #[inline]
104    fn canonicalize_gaussian_unit_assign(&mut self) {
105        self.abs_assign();
106    }
107}