decimal-scaled 0.3.3

Const-generic base-10 fixed-point decimals (D9/D18/D38/D76/D153/D307) with integer-only transcendentals correctly rounded to within 0.5 ULP — exact at the type's last representable place. Deterministic across every platform; no_std-friendly.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283

//! Emits the [`DecimalTranscendental`] impl for a decimal width.
//!
//! Every method is a one-line delegator to the inherent method of
//! the same name. `#[inline]` lets LLVM erase the trait dispatch,
//! so generic-over-`DecimalTranscendental` code pays no runtime
//! cost compared to calling the inherent method directly.

/// Emits `impl<const SCALE: u32> DecimalTranscendental for $Type<SCALE>`
/// for a decimal type. Requires the type to have every inherent
/// method named in the trait (see `decl_strict_transcendentals!` and
/// `decl_wide_transcendental!` for the per-width method emissions).
macro_rules! decl_decimal_transcendental_impl {
    ($Type:ident) => {
        impl<const SCALE: u32> $crate::transcendental_trait::DecimalTranscendental
            for $Type<SCALE>
        {
            // ── Logarithms ───────────────────────────────
            #[inline] fn ln_strict(self) -> Self { <$Type<SCALE>>::ln_strict(self) }
            #[inline] fn ln_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::ln_strict_with(self, mode)
            }
            #[inline] fn ln_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::ln_approx(self, working_digits)
            }
            #[inline] fn ln_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::ln_approx_with(self, working_digits, mode)
            }

            #[inline] fn log_strict(self, base: Self) -> Self { <$Type<SCALE>>::log_strict(self, base) }
            #[inline] fn log_strict_with(self, base: Self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::log_strict_with(self, base, mode)
            }
            #[inline] fn log_approx(self, base: Self, working_digits: u32) -> Self {
                <$Type<SCALE>>::log_approx(self, base, working_digits)
            }
            #[inline] fn log_approx_with(self, base: Self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::log_approx_with(self, base, working_digits, mode)
            }

            #[inline] fn log2_strict(self) -> Self { <$Type<SCALE>>::log2_strict(self) }
            #[inline] fn log2_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::log2_strict_with(self, mode)
            }
            #[inline] fn log2_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::log2_approx(self, working_digits)
            }
            #[inline] fn log2_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::log2_approx_with(self, working_digits, mode)
            }

            #[inline] fn log10_strict(self) -> Self { <$Type<SCALE>>::log10_strict(self) }
            #[inline] fn log10_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::log10_strict_with(self, mode)
            }
            #[inline] fn log10_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::log10_approx(self, working_digits)
            }
            #[inline] fn log10_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::log10_approx_with(self, working_digits, mode)
            }

            // ── Exponentials ─────────────────────────────
            #[inline] fn exp_strict(self) -> Self { <$Type<SCALE>>::exp_strict(self) }
            #[inline] fn exp_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::exp_strict_with(self, mode)
            }
            #[inline] fn exp_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::exp_approx(self, working_digits)
            }
            #[inline] fn exp_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::exp_approx_with(self, working_digits, mode)
            }

            #[inline] fn exp2_strict(self) -> Self { <$Type<SCALE>>::exp2_strict(self) }
            #[inline] fn exp2_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::exp2_strict_with(self, mode)
            }
            #[inline] fn exp2_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::exp2_approx(self, working_digits)
            }
            #[inline] fn exp2_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::exp2_approx_with(self, working_digits, mode)
            }

            // ── Power ────────────────────────────────────
            #[inline] fn powf_strict(self, exp: Self) -> Self { <$Type<SCALE>>::powf_strict(self, exp) }
            #[inline] fn powf_strict_with(self, exp: Self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::powf_strict_with(self, exp, mode)
            }
            #[inline] fn powf_approx(self, exp: Self, working_digits: u32) -> Self {
                <$Type<SCALE>>::powf_approx(self, exp, working_digits)
            }
            #[inline] fn powf_approx_with(self, exp: Self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::powf_approx_with(self, exp, working_digits, mode)
            }

            // ── Roots ────────────────────────────────────
            #[inline] fn sqrt_strict(self) -> Self { <$Type<SCALE>>::sqrt_strict(self) }
            #[inline] fn sqrt_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::sqrt_strict_with(self, mode)
            }
            #[inline] fn cbrt_strict(self) -> Self { <$Type<SCALE>>::cbrt_strict(self) }
            #[inline] fn cbrt_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::cbrt_strict_with(self, mode)
            }
            #[inline] fn hypot_strict(self, other: Self) -> Self { <$Type<SCALE>>::hypot_strict(self, other) }
            #[inline] fn hypot_strict_with(self, other: Self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::hypot_strict_with(self, other, mode)
            }

            // ── Trig (forward) ───────────────────────────
            #[inline] fn sin_strict(self) -> Self { <$Type<SCALE>>::sin_strict(self) }
            #[inline] fn sin_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::sin_strict_with(self, mode)
            }
            #[inline] fn sin_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::sin_approx(self, working_digits)
            }
            #[inline] fn sin_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::sin_approx_with(self, working_digits, mode)
            }

            #[inline] fn cos_strict(self) -> Self { <$Type<SCALE>>::cos_strict(self) }
            #[inline] fn cos_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::cos_strict_with(self, mode)
            }
            #[inline] fn cos_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::cos_approx(self, working_digits)
            }
            #[inline] fn cos_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::cos_approx_with(self, working_digits, mode)
            }

            #[inline] fn tan_strict(self) -> Self { <$Type<SCALE>>::tan_strict(self) }
            #[inline] fn tan_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::tan_strict_with(self, mode)
            }
            #[inline] fn tan_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::tan_approx(self, working_digits)
            }
            #[inline] fn tan_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::tan_approx_with(self, working_digits, mode)
            }

            // ── Trig (inverse) ───────────────────────────
            #[inline] fn atan_strict(self) -> Self { <$Type<SCALE>>::atan_strict(self) }
            #[inline] fn atan_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::atan_strict_with(self, mode)
            }
            #[inline] fn atan_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::atan_approx(self, working_digits)
            }
            #[inline] fn atan_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::atan_approx_with(self, working_digits, mode)
            }

            #[inline] fn asin_strict(self) -> Self { <$Type<SCALE>>::asin_strict(self) }
            #[inline] fn asin_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::asin_strict_with(self, mode)
            }
            #[inline] fn asin_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::asin_approx(self, working_digits)
            }
            #[inline] fn asin_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::asin_approx_with(self, working_digits, mode)
            }

            #[inline] fn acos_strict(self) -> Self { <$Type<SCALE>>::acos_strict(self) }
            #[inline] fn acos_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::acos_strict_with(self, mode)
            }
            #[inline] fn acos_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::acos_approx(self, working_digits)
            }
            #[inline] fn acos_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::acos_approx_with(self, working_digits, mode)
            }

            #[inline] fn atan2_strict(self, other: Self) -> Self { <$Type<SCALE>>::atan2_strict(self, other) }
            #[inline] fn atan2_strict_with(self, other: Self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::atan2_strict_with(self, other, mode)
            }
            #[inline] fn atan2_approx(self, other: Self, working_digits: u32) -> Self {
                <$Type<SCALE>>::atan2_approx(self, other, working_digits)
            }
            #[inline] fn atan2_approx_with(self, other: Self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::atan2_approx_with(self, other, working_digits, mode)
            }

            // ── Hyperbolic ───────────────────────────────
            #[inline] fn sinh_strict(self) -> Self { <$Type<SCALE>>::sinh_strict(self) }
            #[inline] fn sinh_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::sinh_strict_with(self, mode)
            }
            #[inline] fn sinh_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::sinh_approx(self, working_digits)
            }
            #[inline] fn sinh_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::sinh_approx_with(self, working_digits, mode)
            }

            #[inline] fn cosh_strict(self) -> Self { <$Type<SCALE>>::cosh_strict(self) }
            #[inline] fn cosh_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::cosh_strict_with(self, mode)
            }
            #[inline] fn cosh_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::cosh_approx(self, working_digits)
            }
            #[inline] fn cosh_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::cosh_approx_with(self, working_digits, mode)
            }

            #[inline] fn tanh_strict(self) -> Self { <$Type<SCALE>>::tanh_strict(self) }
            #[inline] fn tanh_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::tanh_strict_with(self, mode)
            }
            #[inline] fn tanh_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::tanh_approx(self, working_digits)
            }
            #[inline] fn tanh_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::tanh_approx_with(self, working_digits, mode)
            }

            #[inline] fn asinh_strict(self) -> Self { <$Type<SCALE>>::asinh_strict(self) }
            #[inline] fn asinh_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::asinh_strict_with(self, mode)
            }
            #[inline] fn asinh_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::asinh_approx(self, working_digits)
            }
            #[inline] fn asinh_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::asinh_approx_with(self, working_digits, mode)
            }

            #[inline] fn acosh_strict(self) -> Self { <$Type<SCALE>>::acosh_strict(self) }
            #[inline] fn acosh_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::acosh_strict_with(self, mode)
            }
            #[inline] fn acosh_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::acosh_approx(self, working_digits)
            }
            #[inline] fn acosh_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::acosh_approx_with(self, working_digits, mode)
            }

            #[inline] fn atanh_strict(self) -> Self { <$Type<SCALE>>::atanh_strict(self) }
            #[inline] fn atanh_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::atanh_strict_with(self, mode)
            }
            #[inline] fn atanh_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::atanh_approx(self, working_digits)
            }
            #[inline] fn atanh_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::atanh_approx_with(self, working_digits, mode)
            }

            // ── Angle conversion ─────────────────────────
            #[inline] fn to_degrees_strict(self) -> Self { <$Type<SCALE>>::to_degrees_strict(self) }
            #[inline] fn to_degrees_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::to_degrees_strict_with(self, mode)
            }
            #[inline] fn to_degrees_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::to_degrees_approx(self, working_digits)
            }
            #[inline] fn to_degrees_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::to_degrees_approx_with(self, working_digits, mode)
            }

            #[inline] fn to_radians_strict(self) -> Self { <$Type<SCALE>>::to_radians_strict(self) }
            #[inline] fn to_radians_strict_with(self, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::to_radians_strict_with(self, mode)
            }
            #[inline] fn to_radians_approx(self, working_digits: u32) -> Self {
                <$Type<SCALE>>::to_radians_approx(self, working_digits)
            }
            #[inline] fn to_radians_approx_with(self, working_digits: u32, mode: $crate::rounding::RoundingMode) -> Self {
                <$Type<SCALE>>::to_radians_approx_with(self, working_digits, mode)
            }
        }
    };
}

pub(crate) use decl_decimal_transcendental_impl;