Skip to main content

malachite_base/num/basic/
traits.rs

1// Copyright © 2026 Mikhail Hogrefe
2//
3// Implementations of traits for NonZero* types by b4D8.
4//
5// This file is part of Malachite.
6//
7// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
8// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
9// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.
10
11use core::num::*;
12
13/// Provides the constant 0.
14#[allow(clippy::declare_interior_mutable_const)]
15pub trait Zero {
16    const ZERO: Self;
17}
18
19/// Provides the constant 1.
20#[allow(clippy::declare_interior_mutable_const)]
21pub trait One {
22    const ONE: Self;
23}
24
25/// Provides the constant 2.
26#[allow(clippy::declare_interior_mutable_const)]
27pub trait Two {
28    const TWO: Self;
29}
30
31/// Provides the constant -1.
32#[allow(clippy::declare_interior_mutable_const)]
33pub trait NegativeOne {
34    const NEGATIVE_ONE: Self;
35}
36
37/// Provides the constant 1/2.
38#[allow(clippy::declare_interior_mutable_const)]
39pub trait OneHalf {
40    const ONE_HALF: Self;
41}
42
43/// Provides the constant -0.
44#[allow(clippy::declare_interior_mutable_const)]
45pub trait NegativeZero {
46    const NEGATIVE_ZERO: Self;
47}
48
49/// Provides the constant (positive) Infinity.
50#[allow(clippy::declare_interior_mutable_const)]
51pub trait Infinity {
52    const INFINITY: Self;
53}
54
55/// Provides the constant -Infinity.
56#[allow(clippy::declare_interior_mutable_const)]
57pub trait NegativeInfinity {
58    const NEGATIVE_INFINITY: Self;
59}
60
61/// Provides the constant NaN.
62#[allow(clippy::declare_interior_mutable_const)]
63pub trait NaN {
64    const NAN: Self;
65}
66
67/// Provides the Prouhet-Thue-Morse constant, whose bits are the Thue-Morse sequence.
68pub trait ProuhetThueMorseConstant {
69    const PROUHET_THUE_MORSE_CONSTANT: Self;
70}
71
72/// Provides the prime constant, whose $n$th bit (starting from $n=1$) is true if and only if $n$ is
73/// prime.
74pub trait PrimeConstant {
75    const PRIME_CONSTANT: Self;
76}
77
78/// Provides $\ln 2$.
79pub trait Ln2 {
80    const LN_2: Self;
81}
82
83/// Provides $\log_2 e$.
84pub trait Log2E {
85    const LOG_2_E: Self;
86}
87
88/// Provides $\sqrt{2}$.
89pub trait Sqrt2 {
90    const SQRT_2: Self;
91}
92
93/// Provides $\sqrt{3}$.
94pub trait Sqrt3 {
95    const SQRT_3: Self;
96}
97
98/// Provides $\sqrt{2}/2=\sqrt{1/2}=1/\sqrt{2}$.
99pub trait Sqrt2Over2 {
100    const SQRT_2_OVER_2: Self;
101}
102
103/// Provides $\sqrt{3}/3=\sqrt{1/3}=1/\sqrt{3}$.
104pub trait Sqrt3Over3 {
105    const SQRT_3_OVER_3: Self;
106}
107
108/// Provides $\varphi$, the golden ratio.
109pub trait Phi {
110    const PHI: Self;
111}
112
113/// Provides $\pi$.
114pub trait Pi {
115    const PI: Self;
116}
117
118/// Provides $\tau=2\pi$.
119pub trait Tau {
120    const TAU: Self;
121}
122
123/// Provides $\pi/2$.
124pub trait PiOver2 {
125    const PI_OVER_2: Self;
126}
127
128/// Provides $\pi/3$.
129pub trait PiOver3 {
130    const PI_OVER_3: Self;
131}
132
133/// Provides $\pi/4$.
134pub trait PiOver4 {
135    const PI_OVER_4: Self;
136}
137
138/// Provides $\pi/6$.
139pub trait PiOver6 {
140    const PI_OVER_6: Self;
141}
142
143/// Provides $\pi/8$.
144pub trait PiOver8 {
145    const PI_OVER_8: Self;
146}
147
148/// Provides $1/\pi$.
149pub trait OneOverPi {
150    const ONE_OVER_PI: Self;
151}
152
153/// Provides $\sqrt{\pi}$.
154pub trait SqrtPi {
155    const SQRT_PI: Self;
156}
157
158/// Provides $1/\sqrt{\pi}$.
159pub trait OneOverSqrtPi {
160    const ONE_OVER_SQRT_PI: Self;
161}
162
163/// Provides $1/\sqrt{\tau}=1/\sqrt{2\pi}$.
164pub trait OneOverSqrtTau {
165    const ONE_OVER_SQRT_TAU: Self;
166}
167
168/// Provides $2/\pi$.
169pub trait TwoOverPi {
170    const TWO_OVER_PI: Self;
171}
172
173/// Provides $2/\sqrt{\pi}$.
174pub trait TwoOverSqrtPi {
175    const TWO_OVER_SQRT_PI: Self;
176}
177
178/// Provides Gauss's constant, $G=1/\mathrm{AGM}(1,\sqrt{2})$.
179///
180/// Having three consecutive esses in an identifier is awkward, so let's pretend that we sometimes
181/// use AP Style and write "Gauss' constant".
182pub trait GaussConstant {
183    const GAUSS_CONSTANT: Self;
184}
185
186/// Provides the lemniscate constant $\varpi=\pi G$, where $G$ is Gauss's constant.
187pub trait LemniscateConstant {
188    const LEMNISCATE_CONSTANT: Self;
189}
190
191// Implementation for `NonZero*` types:
192// - `One` and `Two` for both signed and unsigned variants
193// - `NegativeOne` for the signed variant
194macro_rules! impl_non_zero {
195    ($($t:ident),+) => {
196        $(
197            impl One for $t {
198                const ONE: Self = match Self::new(1) {
199                    Some(v) => v,
200                    None => unreachable!() // 1 is a valid nonzero value
201                };
202            }
203
204            impl Two for $t {
205                const TWO: Self = match Self::new(2) {
206                    Some(v) => v,
207                    None => unreachable!() // 2 is a valid nonzero value
208                };
209            }
210        )+
211    };
212    ($($u:ident && $i:ident),+) => {
213        $(
214            impl_non_zero!($u, $i);
215
216            impl NegativeOne for $i {
217                const NEGATIVE_ONE: Self = match Self::new(-1) {
218                    Some(v) => v,
219                    None => unreachable!() // -1 is a valid non zero value
220                };
221            }
222        )+
223    }
224}
225
226impl_non_zero!(
227    NonZeroUsize && NonZeroIsize,
228    NonZeroU128 && NonZeroI128,
229    NonZeroU64 && NonZeroI64,
230    NonZeroU32 && NonZeroI32,
231    NonZeroU16 && NonZeroI16,
232    NonZeroU8 && NonZeroI8
233);