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}