pxfm/polyeval.rs
1/*
2 * // Copyright (c) Radzivon Bartoshyk 7/2025. All rights reserved.
3 * //
4 * // Redistribution and use in source and binary forms, with or without modification,
5 * // are permitted provided that the following conditions are met:
6 * //
7 * // 1. Redistributions of source code must retain the above copyright notice, this
8 * // list of conditions and the following disclaimer.
9 * //
10 * // 2. Redistributions in binary form must reproduce the above copyright notice,
11 * // this list of conditions and the following disclaimer in the documentation
12 * // and/or other materials provided with the distribution.
13 * //
14 * // 3. Neither the name of the copyright holder nor the names of its
15 * // contributors may be used to endorse or promote products derived from
16 * // this software without specific prior written permission.
17 * //
18 * // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22 * // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 * // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 * // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 * // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29use crate::common::{f_fmla, f_fmlaf};
30use crate::double_double::DoubleDouble;
31use crate::dyadic_float::DyadicFloat128;
32use std::ops::Mul;
33
34pub(crate) trait PolyevalMla {
35 fn polyeval_mla(a: Self, b: Self, c: Self) -> Self;
36}
37
38impl PolyevalMla for f64 {
39 #[inline(always)]
40 fn polyeval_mla(a: Self, b: Self, c: Self) -> Self {
41 f_fmla(a, b, c)
42 }
43}
44
45impl PolyevalMla for f32 {
46 #[inline(always)]
47 fn polyeval_mla(a: Self, b: Self, c: Self) -> Self {
48 f_fmlaf(a, b, c)
49 }
50}
51
52impl PolyevalMla for DoubleDouble {
53 #[inline(always)]
54 fn polyeval_mla(a: Self, b: Self, c: Self) -> Self {
55 DoubleDouble::mul_add(a, b, c)
56 }
57}
58
59impl PolyevalMla for DyadicFloat128 {
60 #[inline(always)]
61 fn polyeval_mla(a: Self, b: Self, c: Self) -> Self {
62 c.quick_add(&a.quick_mul(&b))
63 }
64}
65
66// impl PolyevalMla for DyadicFloat256 {
67// #[inline(always)]
68// fn polyeval_mla(a: Self, b: Self, c: Self) -> Self {
69// c.quick_add(&a.quick_mul(&b))
70// }
71// }
72
73#[inline(always)]
74#[allow(clippy::too_many_arguments)]
75pub(crate) fn f_polyeval6<T: PolyevalMla + Copy + Mul<T, Output = T>>(
76 x: T,
77 a0: T,
78 a1: T,
79 a2: T,
80 a3: T,
81 a4: T,
82 a5: T,
83) -> T {
84 let x2 = x * x;
85
86 let u0 = T::polyeval_mla(x, a5, a4);
87 let u1 = T::polyeval_mla(x, a3, a2);
88 let u2 = T::polyeval_mla(x, a1, a0);
89
90 let v0 = T::polyeval_mla(x2, u0, u1);
91
92 T::polyeval_mla(x2, v0, u2)
93}
94
95// #[inline(always)]
96// #[allow(clippy::too_many_arguments)]
97// pub(crate) fn f_polyeval5<T: PolyevalMla + Copy + Mul<T, Output = T>>(
98// x: T,
99// a0: T,
100// a1: T,
101// a2: T,
102// a3: T,
103// a4: T,
104// ) -> T {
105// let t2 = T::polyeval_mla(x, a4, a3);
106// let t3 = T::polyeval_mla(x, t2, a2);
107// let t4 = T::polyeval_mla(x, t3, a1);
108// T::polyeval_mla(x, t4, a0)
109// }
110
111#[inline(always)]
112#[allow(clippy::too_many_arguments)]
113pub(crate) fn f_polyeval9<T: PolyevalMla + Copy + Mul<T, Output = T>>(
114 x: T,
115 a0: T,
116 a1: T,
117 a2: T,
118 a3: T,
119 a4: T,
120 a5: T,
121 a6: T,
122 a7: T,
123 a8: T,
124) -> T {
125 let mut acc = a8;
126 acc = T::polyeval_mla(x, acc, a7);
127 acc = T::polyeval_mla(x, acc, a6);
128 acc = T::polyeval_mla(x, acc, a5);
129 acc = T::polyeval_mla(x, acc, a4);
130 acc = T::polyeval_mla(x, acc, a3);
131 acc = T::polyeval_mla(x, acc, a2);
132 acc = T::polyeval_mla(x, acc, a1);
133 T::polyeval_mla(x, acc, a0)
134}
135
136#[inline(always)]
137#[allow(clippy::too_many_arguments)]
138pub(crate) fn f_estrin_polyeval9<T: PolyevalMla + Copy + Mul<T, Output = T>>(
139 x: T,
140 a0: T,
141 a1: T,
142 a2: T,
143 a3: T,
144 a4: T,
145 a5: T,
146 a6: T,
147 a7: T,
148 a8: T,
149) -> T {
150 let x2 = x * x;
151 let x4 = x2 * x2;
152 let x8 = x4 * x4;
153 let p0 = T::polyeval_mla(x, a1, a0);
154 let p1 = T::polyeval_mla(x, a3, a2);
155 let p2 = T::polyeval_mla(x, a5, a4);
156 let p3 = T::polyeval_mla(x, a7, a6);
157
158 let q0 = T::polyeval_mla(x2, p1, p0);
159 let q1 = T::polyeval_mla(x2, p3, p2);
160 let r0 = T::polyeval_mla(x4, q1, q0);
161 T::polyeval_mla(x8, a8, r0)
162}
163
164#[inline(always)]
165#[allow(clippy::too_many_arguments)]
166pub(crate) fn f_polyeval10<T: PolyevalMla + Copy + Mul<T, Output = T>>(
167 x: T,
168 a0: T,
169 a1: T,
170 a2: T,
171 a3: T,
172 a4: T,
173 a5: T,
174 a6: T,
175 a7: T,
176 a8: T,
177 a9: T,
178) -> T {
179 let x2 = x * x;
180 let x4 = x2 * x2;
181 let x8 = x4 * x4;
182
183 let p0 = T::polyeval_mla(x, a1, a0);
184 let p1 = T::polyeval_mla(x, a3, a2);
185 let p2 = T::polyeval_mla(x, a5, a4);
186 let p3 = T::polyeval_mla(x, a7, a6);
187 let p4 = T::polyeval_mla(x, a9, a8);
188
189 let q0 = T::polyeval_mla(x2, p1, p0);
190 let q1 = T::polyeval_mla(x2, p3, p2);
191
192 let r0 = T::polyeval_mla(x4, q1, q0);
193 T::polyeval_mla(x8, p4, r0)
194}
195
196#[inline(always)]
197#[allow(clippy::too_many_arguments)]
198pub(crate) fn f_polyeval11<T: PolyevalMla + Copy + Mul<T, Output = T>>(
199 x: T,
200 a0: T,
201 a1: T,
202 a2: T,
203 a3: T,
204 a4: T,
205 a5: T,
206 a6: T,
207 a7: T,
208 a8: T,
209 a9: T,
210 a10: T,
211) -> T {
212 let x2 = x * x;
213 let x4 = x2 * x2;
214 let x8 = x4 * x4;
215
216 let q0 = T::polyeval_mla(x, a1, a0);
217 let q1 = T::polyeval_mla(x, a3, a2);
218 let q2 = T::polyeval_mla(x, a5, a4);
219 let q3 = T::polyeval_mla(x, a7, a6);
220 let q4 = T::polyeval_mla(x, a9, a8);
221
222 let r0 = T::polyeval_mla(x2, q1, q0);
223 let r1 = T::polyeval_mla(x2, q3, q2);
224
225 let s0 = T::polyeval_mla(x4, r1, r0);
226 let s1 = T::polyeval_mla(x2, a10, q4);
227 T::polyeval_mla(x8, s1, s0)
228}
229
230#[inline(always)]
231pub(crate) fn f_polyeval3<T: PolyevalMla + Copy>(x: T, a0: T, a1: T, a2: T) -> T {
232 T::polyeval_mla(x, T::polyeval_mla(x, a2, a1), a0)
233}
234
235#[inline(always)]
236#[allow(clippy::too_many_arguments)]
237pub(crate) fn f_polyeval4<T: PolyevalMla + Copy>(x: T, a0: T, a1: T, a2: T, a3: T) -> T {
238 let t2 = T::polyeval_mla(x, a3, a2);
239 let t5 = T::polyeval_mla(x, t2, a1);
240 T::polyeval_mla(x, t5, a0)
241}
242
243#[inline(always)]
244#[allow(clippy::too_many_arguments)]
245pub(crate) fn f_estrin_polyeval4<T: PolyevalMla + Copy + Mul<T, Output = T>>(
246 x: T,
247 a0: T,
248 a1: T,
249 a2: T,
250 a3: T,
251) -> T {
252 let x2 = x * x;
253
254 let p01 = T::polyeval_mla(x, a1, a0);
255 let p23 = T::polyeval_mla(x, a3, a2);
256
257 T::polyeval_mla(x2, p23, p01)
258}
259
260#[inline(always)]
261#[allow(clippy::too_many_arguments)]
262pub(crate) fn f_polyeval13<T: PolyevalMla + Copy + Mul<T, Output = T>>(
263 x: T,
264 a0: T,
265 a1: T,
266 a2: T,
267 a3: T,
268 a4: T,
269 a5: T,
270 a6: T,
271 a7: T,
272 a8: T,
273 a9: T,
274 a10: T,
275 a11: T,
276 a12: T,
277) -> T {
278 let x2 = x * x;
279 let x4 = x2 * x2;
280 let x8 = x4 * x4;
281
282 let t0 = T::polyeval_mla(x, a3, a2);
283 let t1 = T::polyeval_mla(x, a1, a0);
284 let t2 = T::polyeval_mla(x, a7, a6);
285 let t3 = T::polyeval_mla(x, a5, a4);
286 let t4 = T::polyeval_mla(x, a11, a10);
287 let t5 = T::polyeval_mla(x, a9, a8);
288
289 let q0 = T::polyeval_mla(x2, t0, t1);
290 let q1 = T::polyeval_mla(x2, t2, t3);
291
292 let q2 = T::polyeval_mla(x2, t4, t5);
293
294 let q3 = a12;
295
296 let r0 = T::polyeval_mla(x4, q1, q0);
297 let r1 = T::polyeval_mla(x4, q3, q2);
298
299 T::polyeval_mla(x8, r1, r0)
300}
301
302#[inline(always)]
303#[allow(clippy::too_many_arguments)]
304pub(crate) fn f_polyeval12<T: PolyevalMla + Copy + Mul<T, Output = T>>(
305 x: T,
306 a0: T,
307 a1: T,
308 a2: T,
309 a3: T,
310 a4: T,
311 a5: T,
312 a6: T,
313 a7: T,
314 a8: T,
315 a9: T,
316 a10: T,
317 a11: T,
318) -> T {
319 let x2 = x * x;
320 let x4 = x2 * x2;
321 let x8 = x4 * x4;
322
323 let e0 = T::polyeval_mla(x, a1, a0);
324 let e1 = T::polyeval_mla(x, a3, a2);
325 let e2 = T::polyeval_mla(x, a5, a4);
326 let e3 = T::polyeval_mla(x, a7, a6);
327 let e4 = T::polyeval_mla(x, a9, a8);
328 let e5 = T::polyeval_mla(x, a11, a10);
329
330 let f0 = T::polyeval_mla(x2, e1, e0);
331 let f1 = T::polyeval_mla(x2, e3, e2);
332 let f2 = T::polyeval_mla(x2, e5, e4);
333
334 let g0 = T::polyeval_mla(x4, f1, f0);
335
336 T::polyeval_mla(x8, f2, g0)
337}
338
339// #[inline(always)]
340// #[allow(clippy::too_many_arguments)]
341// pub(crate) fn f_horner_polyeval13<T: PolyevalMla + Copy + Mul<T, Output = T>>(
342// x: T,
343// a0: T,
344// a1: T,
345// a2: T,
346// a3: T,
347// a4: T,
348// a5: T,
349// a6: T,
350// a7: T,
351// a8: T,
352// a9: T,
353// a10: T,
354// a11: T,
355// a12: T,
356// ) -> T {
357// let mut acc = a12;
358// acc = T::polyeval_mla(x, acc, a11);
359// acc = T::polyeval_mla(x, acc, a10);
360// acc = T::polyeval_mla(x, acc, a9);
361// acc = T::polyeval_mla(x, acc, a8);
362// acc = T::polyeval_mla(x, acc, a7);
363// acc = T::polyeval_mla(x, acc, a6);
364// acc = T::polyeval_mla(x, acc, a5);
365// acc = T::polyeval_mla(x, acc, a4);
366// acc = T::polyeval_mla(x, acc, a3);
367// acc = T::polyeval_mla(x, acc, a2);
368// acc = T::polyeval_mla(x, acc, a1);
369// T::polyeval_mla(x, acc, a0)
370// }
371
372// #[inline(always)]
373// #[allow(clippy::too_many_arguments)]
374// pub(crate) fn f_horner_polyeval14<T: PolyevalMla + Copy + Mul<T, Output = T>>(
375// x: T,
376// a0: T,
377// a1: T,
378// a2: T,
379// a3: T,
380// a4: T,
381// a5: T,
382// a6: T,
383// a7: T,
384// a8: T,
385// a9: T,
386// a10: T,
387// a11: T,
388// a12: T,
389// a13: T,
390// ) -> T {
391// let mut acc = a13;
392// acc = T::polyeval_mla(x, acc, a12);
393// acc = T::polyeval_mla(x, acc, a11);
394// acc = T::polyeval_mla(x, acc, a10);
395// acc = T::polyeval_mla(x, acc, a9);
396// acc = T::polyeval_mla(x, acc, a8);
397// acc = T::polyeval_mla(x, acc, a7);
398// acc = T::polyeval_mla(x, acc, a6);
399// acc = T::polyeval_mla(x, acc, a5);
400// acc = T::polyeval_mla(x, acc, a4);
401// acc = T::polyeval_mla(x, acc, a3);
402// acc = T::polyeval_mla(x, acc, a2);
403// acc = T::polyeval_mla(x, acc, a1);
404// T::polyeval_mla(x, acc, a0)
405// }
406
407// #[inline(always)]
408// #[allow(clippy::too_many_arguments)]
409// pub(crate) fn f_horner_polyeval12<T: PolyevalMla + Copy + Mul<T, Output = T>>(
410// x: T,
411// a0: T,
412// a1: T,
413// a2: T,
414// a3: T,
415// a4: T,
416// a5: T,
417// a6: T,
418// a7: T,
419// a8: T,
420// a9: T,
421// a10: T,
422// a11: T,
423// ) -> T {
424// let mut acc = a11;
425// acc = T::polyeval_mla(x, acc, a10);
426// acc = T::polyeval_mla(x, acc, a9);
427// acc = T::polyeval_mla(x, acc, a8);
428// acc = T::polyeval_mla(x, acc, a7);
429// acc = T::polyeval_mla(x, acc, a6);
430// acc = T::polyeval_mla(x, acc, a5);
431// acc = T::polyeval_mla(x, acc, a4);
432// acc = T::polyeval_mla(x, acc, a3);
433// acc = T::polyeval_mla(x, acc, a2);
434// acc = T::polyeval_mla(x, acc, a1);
435// T::polyeval_mla(x, acc, a0)
436// }
437
438// #[inline(always)]
439// #[allow(clippy::too_many_arguments)]
440// pub(crate) fn f_polyeval11<T: PolyevalMla + Copy>(
441// x: T,
442// a0: T,
443// a1: T,
444// a2: T,
445// a3: T,
446// a4: T,
447// a5: T,
448// a6: T,
449// a7: T,
450// a8: T,
451// a9: T,
452// a10: T,
453// ) -> T {
454// let k0 = T::polyeval_mla(x, a10, a9);
455// let k1 = T::polyeval_mla(x, k0, a8);
456// let z0 = T::polyeval_mla(x, k1, a7);
457// let t0a = T::polyeval_mla(x, z0, a6);
458// let t1 = T::polyeval_mla(x, t0a, a5);
459// let t2 = T::polyeval_mla(x, t1, a4);
460// let t3 = T::polyeval_mla(x, t2, a3);
461// let t4 = T::polyeval_mla(x, t3, a2);
462// let t5 = T::polyeval_mla(x, t4, a1);
463// T::polyeval_mla(x, t5, a0)
464// }
465
466#[inline(always)]
467#[allow(clippy::too_many_arguments)]
468pub(crate) fn f_polyeval14<T: PolyevalMla + Copy + Mul<T, Output = T>>(
469 x: T,
470 a0: T,
471 a1: T,
472 a2: T,
473 a3: T,
474 a4: T,
475 a5: T,
476 a6: T,
477 a7: T,
478 a8: T,
479 a9: T,
480 a10: T,
481 a11: T,
482 a12: T,
483 a13: T,
484) -> T {
485 let x2 = x * x;
486 let x4 = x2 * x2;
487 let x8 = x4 * x4;
488
489 let g0 = T::polyeval_mla(x, a1, a0);
490 let g1 = T::polyeval_mla(x, a3, a2);
491 let g2 = T::polyeval_mla(x, a5, a4);
492 let g3 = T::polyeval_mla(x, a7, a6);
493 let g4 = T::polyeval_mla(x, a9, a8);
494 let g5 = T::polyeval_mla(x, a11, a10);
495 let g6 = T::polyeval_mla(x, a13, a12);
496
497 let h0 = T::polyeval_mla(x2, g1, g0);
498 let h1 = T::polyeval_mla(x2, g3, g2);
499 let h2 = T::polyeval_mla(x2, g5, g4);
500
501 let q0 = T::polyeval_mla(x4, h1, h0);
502 let q1 = T::polyeval_mla(x4, g6, h2);
503
504 T::polyeval_mla(x8, q1, q0)
505}
506
507// #[inline(always)]
508// #[allow(clippy::too_many_arguments)]
509// pub(crate) fn f_polyeval12<T: PolyevalMla + Copy>(
510// x: T,
511// a0: T,
512// a1: T,
513// a2: T,
514// a3: T,
515// a4: T,
516// a5: T,
517// a6: T,
518// a7: T,
519// a8: T,
520// a9: T,
521// a10: T,
522// a11: T,
523// ) -> T {
524// let t0 = T::polyeval_mla(x, a11, a10);
525// let k0 = T::polyeval_mla(x, t0, a9);
526// let k1 = T::polyeval_mla(x, k0, a8);
527// let z0 = T::polyeval_mla(x, k1, a7);
528// let t0a = T::polyeval_mla(x, z0, a6);
529// let t1 = T::polyeval_mla(x, t0a, a5);
530// let t2 = T::polyeval_mla(x, t1, a4);
531// let t3 = T::polyeval_mla(x, t2, a3);
532// let t4 = T::polyeval_mla(x, t3, a2);
533// let t5 = T::polyeval_mla(x, t4, a1);
534// T::polyeval_mla(x, t5, a0)
535// }
536
537#[inline(always)]
538#[allow(clippy::too_many_arguments)]
539pub(crate) fn f_polyeval7<T: PolyevalMla + Copy>(
540 x: T,
541 a0: T,
542 a1: T,
543 a2: T,
544 a3: T,
545 a4: T,
546 a5: T,
547 a6: T,
548) -> T {
549 let t1 = T::polyeval_mla(x, a6, a5);
550 let t2 = T::polyeval_mla(x, t1, a4);
551 let t3 = T::polyeval_mla(x, t2, a3);
552 let t4 = T::polyeval_mla(x, t3, a2);
553 let t5 = T::polyeval_mla(x, t4, a1);
554 T::polyeval_mla(x, t5, a0)
555}
556
557#[inline(always)]
558#[allow(clippy::too_many_arguments)]
559pub(crate) fn f_estrin_polyeval7<T: PolyevalMla + Copy + Mul<T, Output = T>>(
560 x: T,
561 a0: T,
562 a1: T,
563 a2: T,
564 a3: T,
565 a4: T,
566 a5: T,
567 a6: T,
568) -> T {
569 let x2 = x * x;
570 let x4 = x2 * x2;
571
572 let b0 = T::polyeval_mla(x, a1, a0);
573 let b1 = T::polyeval_mla(x, a3, a2);
574 let b2 = T::polyeval_mla(x, a5, a4);
575
576 let c0 = T::polyeval_mla(x2, b1, b0);
577 let c1 = T::polyeval_mla(x2, a6, b2);
578
579 T::polyeval_mla(x4, c1, c0)
580}
581
582#[allow(clippy::too_many_arguments)]
583pub(crate) fn f_polyeval5<T: PolyevalMla + Copy>(x: T, a0: T, a1: T, a2: T, a3: T, a4: T) -> T {
584 let mut acc = a4;
585 acc = T::polyeval_mla(x, acc, a3);
586 acc = T::polyeval_mla(x, acc, a2);
587 acc = T::polyeval_mla(x, acc, a1);
588 T::polyeval_mla(x, acc, a0)
589}
590
591#[allow(clippy::too_many_arguments)]
592pub(crate) fn f_estrin_polyeval5<T: PolyevalMla + Copy + Mul<T, Output = T>>(
593 x: T,
594 a0: T,
595 a1: T,
596 a2: T,
597 a3: T,
598 a4: T,
599) -> T {
600 let x2 = x * x;
601 let p01 = T::polyeval_mla(x, a1, a0);
602 let p23 = T::polyeval_mla(x, a3, a2);
603 let t = T::polyeval_mla(x2, a4, p23);
604 T::polyeval_mla(x2, t, p01)
605}
606
607#[inline(always)]
608#[allow(clippy::too_many_arguments)]
609pub(crate) fn f_polyeval8<T: PolyevalMla + Copy>(
610 x: T,
611 a0: T,
612 a1: T,
613 a2: T,
614 a3: T,
615 a4: T,
616 a5: T,
617 a6: T,
618 a7: T,
619) -> T {
620 let z0 = T::polyeval_mla(x, a7, a6);
621 let t1 = T::polyeval_mla(x, z0, a5);
622 let t2 = T::polyeval_mla(x, t1, a4);
623 let t3 = T::polyeval_mla(x, t2, a3);
624 let t4 = T::polyeval_mla(x, t3, a2);
625 let t5 = T::polyeval_mla(x, t4, a1);
626 T::polyeval_mla(x, t5, a0)
627}
628
629#[inline(always)]
630#[allow(clippy::too_many_arguments)]
631pub(crate) fn f_estrin_polyeval8<T: PolyevalMla + Copy + Mul<T, Output = T>>(
632 x: T,
633 a0: T,
634 a1: T,
635 a2: T,
636 a3: T,
637 a4: T,
638 a5: T,
639 a6: T,
640 a7: T,
641) -> T {
642 let x2 = x * x;
643 let x4 = x2 * x2;
644
645 let p0 = T::polyeval_mla(x, a1, a0);
646 let p1 = T::polyeval_mla(x, a3, a2);
647 let p2 = T::polyeval_mla(x, a5, a4);
648 let p3 = T::polyeval_mla(x, a7, a6);
649
650 let q0 = T::polyeval_mla(x2, p1, p0);
651 let q1 = T::polyeval_mla(x2, p3, p2);
652
653 T::polyeval_mla(x4, q1, q0)
654}
655
656#[inline(always)]
657#[allow(clippy::too_many_arguments)]
658pub(crate) fn f_polyeval16<T: PolyevalMla + Copy + Mul<T, Output = T>>(
659 x: T,
660 a0: T,
661 a1: T,
662 a2: T,
663 a3: T,
664 a4: T,
665 a5: T,
666 a6: T,
667 a7: T,
668 a8: T,
669 a9: T,
670 a10: T,
671 a11: T,
672 a12: T,
673 a13: T,
674 a14: T,
675 a15: T,
676) -> T {
677 let x2 = x * x;
678 let x4 = x2 * x2;
679 let x8 = x4 * x4;
680
681 let q0 = T::polyeval_mla(x, a1, a0);
682 let q1 = T::polyeval_mla(x, a3, a2);
683 let q2 = T::polyeval_mla(x, a5, a4);
684 let q3 = T::polyeval_mla(x, a7, a6);
685 let q4 = T::polyeval_mla(x, a9, a8);
686 let q5 = T::polyeval_mla(x, a11, a10);
687 let q6 = T::polyeval_mla(x, a13, a12);
688 let q7 = T::polyeval_mla(x, a15, a14);
689
690 let r0 = T::polyeval_mla(x2, q1, q0);
691 let r1 = T::polyeval_mla(x2, q3, q2);
692 let r2 = T::polyeval_mla(x2, q5, q4);
693 let r3 = T::polyeval_mla(x2, q7, q6);
694
695 let s0 = T::polyeval_mla(x4, r1, r0);
696 let s1 = T::polyeval_mla(x4, r3, r2);
697
698 T::polyeval_mla(x8, s1, s0)
699}
700
701#[inline(always)]
702#[allow(clippy::too_many_arguments)]
703pub(crate) fn f_polyeval15<T: PolyevalMla + Copy + Mul<T, Output = T>>(
704 x: T,
705 a0: T,
706 a1: T,
707 a2: T,
708 a3: T,
709 a4: T,
710 a5: T,
711 a6: T,
712 a7: T,
713 a8: T,
714 a9: T,
715 a10: T,
716 a11: T,
717 a12: T,
718 a13: T,
719 a14: T,
720) -> T {
721 let x2 = x * x;
722 let x4 = x2 * x2;
723 let x8 = x4 * x4;
724
725 let e0 = T::polyeval_mla(x, a1, a0);
726 let e1 = T::polyeval_mla(x, a3, a2);
727 let e2 = T::polyeval_mla(x, a5, a4);
728 let e3 = T::polyeval_mla(x, a7, a6);
729 let e4 = T::polyeval_mla(x, a9, a8);
730 let e5 = T::polyeval_mla(x, a11, a10);
731 let e6 = T::polyeval_mla(x, a13, a12);
732
733 // Level 2
734 let f0 = T::polyeval_mla(x2, e1, e0);
735 let f1 = T::polyeval_mla(x2, e3, e2);
736 let f2 = T::polyeval_mla(x2, e5, e4);
737 let f3 = T::polyeval_mla(x2, a14, e6);
738
739 // Level 3
740 let g0 = T::polyeval_mla(x4, f1, f0);
741 let g1 = T::polyeval_mla(x4, f3, f2);
742
743 // Final
744 T::polyeval_mla(x8, g1, g0)
745}
746
747#[inline(always)]
748#[allow(clippy::too_many_arguments)]
749pub(crate) fn f_polyeval18<T: PolyevalMla + Copy + Mul<T, Output = T>>(
750 x: T,
751 a0: T,
752 a1: T,
753 a2: T,
754 a3: T,
755 a4: T,
756 a5: T,
757 a6: T,
758 a7: T,
759 a8: T,
760 a9: T,
761 a10: T,
762 a11: T,
763 a12: T,
764 a13: T,
765 a14: T,
766 a15: T,
767 a16: T,
768 a17: T,
769) -> T {
770 let x2 = x * x;
771 let x4 = x2 * x2;
772 let x8 = x4 * x4;
773 let x16 = x8 * x8;
774
775 let q0 = T::polyeval_mla(x, a1, a0);
776 let q1 = T::polyeval_mla(x, a3, a2);
777 let q2 = T::polyeval_mla(x, a5, a4);
778 let q3 = T::polyeval_mla(x, a7, a6);
779 let q4 = T::polyeval_mla(x, a9, a8);
780 let q5 = T::polyeval_mla(x, a11, a10);
781 let q6 = T::polyeval_mla(x, a13, a12);
782 let q7 = T::polyeval_mla(x, a15, a14);
783 let q8 = T::polyeval_mla(x, a17, a16);
784
785 let r0 = T::polyeval_mla(x2, q1, q0);
786 let r1 = T::polyeval_mla(x2, q3, q2);
787 let r2 = T::polyeval_mla(x2, q5, q4);
788 let r3 = T::polyeval_mla(x2, q7, q6);
789
790 let s0 = T::polyeval_mla(x4, r1, r0);
791 let s1 = T::polyeval_mla(x4, r3, r2);
792
793 let t0 = T::polyeval_mla(x8, s1, s0);
794
795 T::polyeval_mla(x16, q8, t0)
796}
797
798// #[inline(always)]
799// #[allow(clippy::too_many_arguments)]
800// pub(crate) fn f_polyeval17<T: PolyevalMla + Copy + Mul<T, Output = T>>(
801// x: T,
802// a0: T,
803// a1: T,
804// a2: T,
805// a3: T,
806// a4: T,
807// a5: T,
808// a6: T,
809// a7: T,
810// a8: T,
811// a9: T,
812// a10: T,
813// a11: T,
814// a12: T,
815// a13: T,
816// a14: T,
817// a15: T,
818// a16: T,
819// ) -> T {
820// let x2 = x * x;
821// let x4 = x2 * x2;
822// let x8 = x4 * x4;
823// let x16 = x8 * x8;
824//
825// let p0 = T::polyeval_mla(x, a1, a0);
826// let p1 = T::polyeval_mla(x, a3, a2);
827// let p2 = T::polyeval_mla(x, a5, a4);
828// let p3 = T::polyeval_mla(x, a7, a6);
829// let p4 = T::polyeval_mla(x, a9, a8);
830// let p5 = T::polyeval_mla(x, a11, a10);
831// let p6 = T::polyeval_mla(x, a13, a12);
832// let p7 = T::polyeval_mla(x, a15, a14);
833//
834// let q0 = T::polyeval_mla(x2, p1, p0);
835// let q1 = T::polyeval_mla(x2, p3, p2);
836// let q2 = T::polyeval_mla(x2, p5, p4);
837// let q3 = T::polyeval_mla(x2, p7, p6);
838//
839// let r0 = T::polyeval_mla(x4, q1, q0);
840// let r1 = T::polyeval_mla(x4, q3, q2);
841//
842// let s0 = T::polyeval_mla(x8, r1, r0);
843//
844// T::polyeval_mla(x16, a16, s0)
845// }
846
847#[inline(always)]
848#[allow(clippy::too_many_arguments)]
849pub(crate) fn f_polyeval19<T: PolyevalMla + Copy + Mul<T, Output = T>>(
850 x: T,
851 a0: T,
852 a1: T,
853 a2: T,
854 a3: T,
855 a4: T,
856 a5: T,
857 a6: T,
858 a7: T,
859 a8: T,
860 a9: T,
861 a10: T,
862 a11: T,
863 a12: T,
864 a13: T,
865 a14: T,
866 a15: T,
867 a16: T,
868 a17: T,
869 a18: T,
870) -> T {
871 // let z000 = T::polyeval_mla(x, a18, a17);
872 // let z00 = T::polyeval_mla(x, z000, a16);
873 // let z01 = T::polyeval_mla(x, z00, a15);
874 // let t1 = T::polyeval_mla(x, z01, a14);
875 // let t2 = T::polyeval_mla(x, t1, a13);
876 // let t3 = T::polyeval_mla(x, t2, a12);
877 // let t4 = T::polyeval_mla(x, t3, a11);
878 // let t5 = T::polyeval_mla(x, t4, a10);
879 // let t6 = T::polyeval_mla(x, t5, a9);
880 // let t7 = T::polyeval_mla(x, t6, a8);
881 // let t8 = T::polyeval_mla(x, t7, a7);
882 // let t9 = T::polyeval_mla(x, t8, a6);
883 // let t10 = T::polyeval_mla(x, t9, a5);
884 // let t11 = T::polyeval_mla(x, t10, a4);
885 // let t12 = T::polyeval_mla(x, t11, a3);
886 // let t13 = T::polyeval_mla(x, t12, a2);
887 // let t14 = T::polyeval_mla(x, t13, a1);
888 // T::polyeval_mla(x, t14, a0)
889
890 let x2 = x * x;
891 let x4 = x2 * x2;
892 let x8 = x4 * x4;
893 let x16 = x8 * x8;
894
895 // Level 0: pairs
896 let e0 = T::polyeval_mla(x, a1, a0); // a0 + a1·x
897 let e1 = T::polyeval_mla(x, a3, a2); // a2 + a3·x
898 let e2 = T::polyeval_mla(x, a5, a4);
899 let e3 = T::polyeval_mla(x, a7, a6);
900 let e4 = T::polyeval_mla(x, a9, a8);
901 let e5 = T::polyeval_mla(x, a11, a10);
902 let e6 = T::polyeval_mla(x, a13, a12);
903 let e7 = T::polyeval_mla(x, a15, a14);
904 let e8 = T::polyeval_mla(x, a17, a16);
905
906 // Level 1: combine with x²
907 let f0 = T::polyeval_mla(x2, e1, e0);
908 let f1 = T::polyeval_mla(x2, e3, e2);
909 let f2 = T::polyeval_mla(x2, e5, e4);
910 let f3 = T::polyeval_mla(x2, e7, e6);
911
912 // Level 2: combine with x⁴
913 let g0 = T::polyeval_mla(x4, f1, f0);
914 let g1 = T::polyeval_mla(x4, f3, f2);
915
916 // Level 3: combine with x⁸
917 let h0 = T::polyeval_mla(x8, g1, g0);
918
919 // Final: combine with x¹⁶
920 let final_poly = T::polyeval_mla(x16, e8, h0);
921
922 // Degree 18: Add a18·x¹⁸
923 // This assumes `x18 = x16 * x2`, since x² already computed
924 let x18 = x16 * x2;
925 T::polyeval_mla(x18, a18, final_poly)
926}
927
928// #[inline(always)]
929// #[allow(clippy::too_many_arguments)]
930// pub(crate) fn f_polyeval20<T: PolyevalMla + Copy + Mul<T, Output = T>>(
931// x: T,
932// a0: T,
933// a1: T,
934// a2: T,
935// a3: T,
936// a4: T,
937// a5: T,
938// a6: T,
939// a7: T,
940// a8: T,
941// a9: T,
942// a10: T,
943// a11: T,
944// a12: T,
945// a13: T,
946// a14: T,
947// a15: T,
948// a16: T,
949// a17: T,
950// a18: T,
951// a19: T,
952// ) -> T {
953// // let z000 = T::polyeval_mla(x, a19, a18);
954// // let z000 = T::polyeval_mla(x, z000, a17);
955// // let z00 = T::polyeval_mla(x, z000, a16);
956// // let z01 = T::polyeval_mla(x, z00, a15);
957// // let t1 = T::polyeval_mla(x, z01, a14);
958// // let t2 = T::polyeval_mla(x, t1, a13);
959// // let t3 = T::polyeval_mla(x, t2, a12);
960// // let t4 = T::polyeval_mla(x, t3, a11);
961// // let t5 = T::polyeval_mla(x, t4, a10);
962// // let t6 = T::polyeval_mla(x, t5, a9);
963// // let t7 = T::polyeval_mla(x, t6, a8);
964// // let t8 = T::polyeval_mla(x, t7, a7);
965// // let t9 = T::polyeval_mla(x, t8, a6);
966// // let t10 = T::polyeval_mla(x, t9, a5);
967// // let t11 = T::polyeval_mla(x, t10, a4);
968// // let t12 = T::polyeval_mla(x, t11, a3);
969// // let t13 = T::polyeval_mla(x, t12, a2);
970// // let t14 = T::polyeval_mla(x, t13, a1);
971// // T::polyeval_mla(x, t14, a0)
972//
973// let x2 = x * x;
974// let x4 = x2 * x2;
975// let x8 = x4 * x4;
976// let x16 = x8 * x8;
977//
978// // Evaluate groups of 2 terms at a time
979// let e0 = T::polyeval_mla(x, a1, a0);
980// let e1 = T::polyeval_mla(x, a3, a2);
981// let e2 = T::polyeval_mla(x, a5, a4);
982// let e3 = T::polyeval_mla(x, a7, a6);
983// let e4 = T::polyeval_mla(x, a9, a8);
984// let e5 = T::polyeval_mla(x, a11, a10);
985// let e6 = T::polyeval_mla(x, a13, a12);
986// let e7 = T::polyeval_mla(x, a15, a14);
987// let e8 = T::polyeval_mla(x, a17, a16);
988// let e9 = T::polyeval_mla(x, a19, a18);
989//
990// // Now build up using higher powers
991// let f0 = T::polyeval_mla(x2, e1, e0); // (e1 * x² + e0)
992// let f1 = T::polyeval_mla(x2, e3, e2);
993// let f2 = T::polyeval_mla(x2, e5, e4);
994// let f3 = T::polyeval_mla(x2, e7, e6);
995// let f4 = T::polyeval_mla(x2, e9, e8);
996//
997// // Next level
998// let g0 = T::polyeval_mla(x4, f1, f0);
999// let g1 = T::polyeval_mla(x4, f3, f2);
1000//
1001// // Final levels
1002// let h0 = T::polyeval_mla(x8, g1, g0);
1003// T::polyeval_mla(x16, f4, h0)
1004// }
1005
1006// #[inline(always)]
1007// #[allow(clippy::too_many_arguments)]
1008// pub(crate) fn f_horner_polyeval21<T: PolyevalMla + Copy>(
1009// x: T,
1010// a0: T,
1011// a1: T,
1012// a2: T,
1013// a3: T,
1014// a4: T,
1015// a5: T,
1016// a6: T,
1017// a7: T,
1018// a8: T,
1019// a9: T,
1020// a10: T,
1021// a11: T,
1022// a12: T,
1023// a13: T,
1024// a14: T,
1025// a15: T,
1026// a16: T,
1027// a17: T,
1028// a18: T,
1029// a19: T,
1030// a20: T,
1031// ) -> T {
1032// let z000 = T::polyeval_mla(x, a20, a19);
1033// let z000 = T::polyeval_mla(x, z000, a18);
1034// let z000 = T::polyeval_mla(x, z000, a17);
1035// let z00 = T::polyeval_mla(x, z000, a16);
1036// let z01 = T::polyeval_mla(x, z00, a15);
1037// let t1 = T::polyeval_mla(x, z01, a14);
1038// let t2 = T::polyeval_mla(x, t1, a13);
1039// let t3 = T::polyeval_mla(x, t2, a12);
1040// let t4 = T::polyeval_mla(x, t3, a11);
1041// let t5 = T::polyeval_mla(x, t4, a10);
1042// let t6 = T::polyeval_mla(x, t5, a9);
1043// let t7 = T::polyeval_mla(x, t6, a8);
1044// let t8 = T::polyeval_mla(x, t7, a7);
1045// let t9 = T::polyeval_mla(x, t8, a6);
1046// let t10 = T::polyeval_mla(x, t9, a5);
1047// let t11 = T::polyeval_mla(x, t10, a4);
1048// let t12 = T::polyeval_mla(x, t11, a3);
1049// let t13 = T::polyeval_mla(x, t12, a2);
1050// let t14 = T::polyeval_mla(x, t13, a1);
1051// T::polyeval_mla(x, t14, a0)
1052// }
1053
1054// #[inline(always)]
1055// #[allow(clippy::too_many_arguments)]
1056// pub(crate) fn f_polyeval21<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1057// x: T,
1058// a0: T,
1059// a1: T,
1060// a2: T,
1061// a3: T,
1062// a4: T,
1063// a5: T,
1064// a6: T,
1065// a7: T,
1066// a8: T,
1067// a9: T,
1068// a10: T,
1069// a11: T,
1070// a12: T,
1071// a13: T,
1072// a14: T,
1073// a15: T,
1074// a16: T,
1075// a17: T,
1076// a18: T,
1077// a19: T,
1078// a20: T,
1079// ) -> T {
1080// // let z000 = T::polyeval_mla(x, a20, a19);
1081// // let z000 = T::polyeval_mla(x, z000, a18);
1082// // let z000 = T::polyeval_mla(x, z000, a17);
1083// // let z00 = T::polyeval_mla(x, z000, a16);
1084// // let z01 = T::polyeval_mla(x, z00, a15);
1085// // let t1 = T::polyeval_mla(x, z01, a14);
1086// // let t2 = T::polyeval_mla(x, t1, a13);
1087// // let t3 = T::polyeval_mla(x, t2, a12);
1088// // let t4 = T::polyeval_mla(x, t3, a11);
1089// // let t5 = T::polyeval_mla(x, t4, a10);
1090// // let t6 = T::polyeval_mla(x, t5, a9);
1091// // let t7 = T::polyeval_mla(x, t6, a8);
1092// // let t8 = T::polyeval_mla(x, t7, a7);
1093// // let t9 = T::polyeval_mla(x, t8, a6);
1094// // let t10 = T::polyeval_mla(x, t9, a5);
1095// // let t11 = T::polyeval_mla(x, t10, a4);
1096// // let t12 = T::polyeval_mla(x, t11, a3);
1097// // let t13 = T::polyeval_mla(x, t12, a2);
1098// // let t14 = T::polyeval_mla(x, t13, a1);
1099// // T::polyeval_mla(x, t14, a0)
1100//
1101// // Powers
1102// let x2 = x * x;
1103// let x4 = x2 * x2;
1104// let x8 = x4 * x4;
1105// let x16 = x8 * x8;
1106//
1107// // Level 0: smallest groups
1108// let e0 = T::polyeval_mla(x, a1, a0); // a0 + a1*x
1109// let e1 = T::polyeval_mla(x, a3, a2); // a2 + a3*x
1110// let e2 = T::polyeval_mla(x, a5, a4);
1111// let e3 = T::polyeval_mla(x, a7, a6);
1112// let e4 = T::polyeval_mla(x, a9, a8);
1113// let e5 = T::polyeval_mla(x, a11, a10);
1114// let e6 = T::polyeval_mla(x, a13, a12);
1115// let e7 = T::polyeval_mla(x, a15, a14);
1116// let e8 = T::polyeval_mla(x, a17, a16);
1117// let e9 = T::polyeval_mla(x, a19, a18); // a18 + a19*x
1118//
1119// // a20 is alone for now
1120//
1121// // Level 1: group by x²
1122// let f0 = T::polyeval_mla(x2, e1, e0); // (e1)*x² + e0
1123// let f1 = T::polyeval_mla(x2, e3, e2);
1124// let f2 = T::polyeval_mla(x2, e5, e4);
1125// let f3 = T::polyeval_mla(x2, e7, e6);
1126// let f4 = T::polyeval_mla(x2, e9, e8);
1127//
1128// // Level 2: group by x⁴
1129// let g0 = T::polyeval_mla(x4, f1, f0);
1130// let g1 = T::polyeval_mla(x4, f3, f2);
1131//
1132// // Level 3: group by x⁸
1133// let h0 = T::polyeval_mla(x8, g1, g0);
1134//
1135// // Level 4: final
1136// let i0 = T::polyeval_mla(x16, f4, a20); // (e9 x + a20) * x² → then into x¹⁶
1137// T::polyeval_mla(x8, i0, h0)
1138//
1139// }
1140
1141#[inline(always)]
1142#[allow(clippy::too_many_arguments)]
1143pub(crate) fn f_polyeval22<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1144 x: T,
1145 a0: T,
1146 a1: T,
1147 a2: T,
1148 a3: T,
1149 a4: T,
1150 a5: T,
1151 a6: T,
1152 a7: T,
1153 a8: T,
1154 a9: T,
1155 a10: T,
1156 a11: T,
1157 a12: T,
1158 a13: T,
1159 a14: T,
1160 a15: T,
1161 a16: T,
1162 a17: T,
1163 a18: T,
1164 a19: T,
1165 a20: T,
1166 a21: T,
1167) -> T {
1168 let x2 = x * x;
1169 let x4 = x2 * x2;
1170 let x8 = x4 * x4;
1171 let x16 = x8 * x8;
1172
1173 let p0 = T::polyeval_mla(x, a1, a0); // a1·x + a0
1174 let p1 = T::polyeval_mla(x, a3, a2); // a3·x + a2
1175 let p2 = T::polyeval_mla(x, a5, a4);
1176 let p3 = T::polyeval_mla(x, a7, a6);
1177 let p4 = T::polyeval_mla(x, a9, a8);
1178 let p5 = T::polyeval_mla(x, a11, a10);
1179 let p6 = T::polyeval_mla(x, a13, a12);
1180 let p7 = T::polyeval_mla(x, a15, a14);
1181 let p8 = T::polyeval_mla(x, a17, a16);
1182 let p9 = T::polyeval_mla(x, a19, a18);
1183 let p10 = T::polyeval_mla(x, a21, a20);
1184
1185 let q0 = T::polyeval_mla(x2, p1, p0); // (a3·x + a2)·x² + (a1·x + a0)
1186 let q1 = T::polyeval_mla(x2, p3, p2);
1187 let q2 = T::polyeval_mla(x2, p5, p4);
1188 let q3 = T::polyeval_mla(x2, p7, p6);
1189 let q4 = T::polyeval_mla(x2, p9, p8);
1190 let r0 = T::polyeval_mla(x4, q1, q0); // q1·x⁴ + q0
1191 let r1 = T::polyeval_mla(x4, q3, q2);
1192 let s0 = T::polyeval_mla(x8, r1, r0); // r1·x⁸ + r0
1193 let r2 = T::polyeval_mla(x4, p10, q4); // p10·x⁴ + q4
1194 T::polyeval_mla(x16, r2, s0)
1195}
1196
1197// #[inline(always)]
1198// #[allow(clippy::too_many_arguments)]
1199// pub(crate) fn f_polyeval28<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1200// x: T,
1201// a0: T,
1202// a1: T,
1203// a2: T,
1204// a3: T,
1205// a4: T,
1206// a5: T,
1207// a6: T,
1208// a7: T,
1209// a8: T,
1210// a9: T,
1211// a10: T,
1212// a11: T,
1213// a12: T,
1214// a13: T,
1215// a14: T,
1216// a15: T,
1217// a16: T,
1218// a17: T,
1219// a18: T,
1220// a19: T,
1221// a20: T,
1222// a21: T,
1223// a22: T,
1224// a23: T,
1225// a24: T,
1226// a25: T,
1227// a26: T,
1228// a27: T,
1229// ) -> T {
1230// let x2 = x * x;
1231// let x4 = x2 * x2;
1232// let x8 = x4 * x4;
1233//
1234// // Degree 0–3
1235// let e0 = T::polyeval_mla(x, a1, a0);
1236// let e1 = T::polyeval_mla(x, a3, a2);
1237// let p0 = T::polyeval_mla(x2, e1, e0);
1238//
1239// // Degree 4–7
1240// let e2 = T::polyeval_mla(x, a5, a4);
1241// let e3 = T::polyeval_mla(x, a7, a6);
1242// let p1 = T::polyeval_mla(x2, e3, e2);
1243//
1244// // Degree 8–11
1245// let e4 = T::polyeval_mla(x, a9, a8);
1246// let e5 = T::polyeval_mla(x, a11, a10);
1247// let p2 = T::polyeval_mla(x2, e5, e4);
1248//
1249// // Degree 12–15
1250// let e6 = T::polyeval_mla(x, a13, a12);
1251// let e7 = T::polyeval_mla(x, a15, a14);
1252// let p3 = T::polyeval_mla(x2, e7, e6);
1253//
1254// // Degree 16–19
1255// let e8 = T::polyeval_mla(x, a17, a16);
1256// let e9 = T::polyeval_mla(x, a19, a18);
1257// let p4 = T::polyeval_mla(x2, e9, e8);
1258//
1259// // Degree 20–23
1260// let e10 = T::polyeval_mla(x, a21, a20);
1261// let e11 = T::polyeval_mla(x, a23, a22);
1262// let p5 = T::polyeval_mla(x2, e11, e10);
1263//
1264// // Degree 24–27
1265// let e12 = T::polyeval_mla(x, a25, a24);
1266// let e13 = T::polyeval_mla(x, a27, a26);
1267// let p6 = T::polyeval_mla(x2, e13, e12);
1268//
1269// // Group into x⁴
1270// let q0 = T::polyeval_mla(x4, p1, p0);
1271// let q1 = T::polyeval_mla(x4, p3, p2);
1272// let q2 = T::polyeval_mla(x4, p5, p4);
1273//
1274// // Final x⁸ group
1275// let r0 = T::polyeval_mla(x8, q1, q0);
1276// let r1 = T::polyeval_mla(x8, p6, q2);
1277//
1278// // Final result
1279// T::polyeval_mla(x8 * x8, r1, r0)
1280// }
1281
1282// #[inline(always)]
1283// #[allow(clippy::too_many_arguments)]
1284// pub(crate) fn f_polyeval23<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1285// x: T,
1286// a0: T,
1287// a1: T,
1288// a2: T,
1289// a3: T,
1290// a4: T,
1291// a5: T,
1292// a6: T,
1293// a7: T,
1294// a8: T,
1295// a9: T,
1296// a10: T,
1297// a11: T,
1298// a12: T,
1299// a13: T,
1300// a14: T,
1301// a15: T,
1302// a16: T,
1303// a17: T,
1304// a18: T,
1305// a19: T,
1306// a20: T,
1307// a21: T,
1308// a22: T,
1309// ) -> T {
1310// let mut acc = a22;
1311// acc = T::polyeval_mla(x, acc, a21);
1312// acc = T::polyeval_mla(x, acc, a20);
1313// acc = T::polyeval_mla(x, acc, a19);
1314// acc = T::polyeval_mla(x, acc, a18);
1315// acc = T::polyeval_mla(x, acc, a17);
1316// acc = T::polyeval_mla(x, acc, a16);
1317// acc = T::polyeval_mla(x, acc, a15);
1318// acc = T::polyeval_mla(x, acc, a14);
1319// acc = T::polyeval_mla(x, acc, a13);
1320// acc = T::polyeval_mla(x, acc, a12);
1321// acc = T::polyeval_mla(x, acc, a11);
1322// acc = T::polyeval_mla(x, acc, a10);
1323// acc = T::polyeval_mla(x, acc, a9);
1324// acc = T::polyeval_mla(x, acc, a8);
1325// acc = T::polyeval_mla(x, acc, a7);
1326// acc = T::polyeval_mla(x, acc, a6);
1327// acc = T::polyeval_mla(x, acc, a5);
1328// acc = T::polyeval_mla(x, acc, a4);
1329// acc = T::polyeval_mla(x, acc, a3);
1330// acc = T::polyeval_mla(x, acc, a2);
1331// acc = T::polyeval_mla(x, acc, a1);
1332// T::polyeval_mla(x, acc, a0)
1333// }
1334
1335#[inline(always)]
1336#[allow(clippy::too_many_arguments)]
1337pub(crate) fn f_polyeval24<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1338 x: T,
1339 a0: T,
1340 a1: T,
1341 a2: T,
1342 a3: T,
1343 a4: T,
1344 a5: T,
1345 a6: T,
1346 a7: T,
1347 a8: T,
1348 a9: T,
1349 a10: T,
1350 a11: T,
1351 a12: T,
1352 a13: T,
1353 a14: T,
1354 a15: T,
1355 a16: T,
1356 a17: T,
1357 a18: T,
1358 a19: T,
1359 a20: T,
1360 a21: T,
1361 a22: T,
1362 a23: T,
1363) -> T {
1364 // let z000 = T::polyeval_mla(x, a23, a22);
1365 // let z000 = T::polyeval_mla(x, z000, a21);
1366 // let z000 = T::polyeval_mla(x, z000, a20);
1367 // let z000 = T::polyeval_mla(x, z000, a19);
1368 // let z000 = T::polyeval_mla(x, z000, a18);
1369 // let z000 = T::polyeval_mla(x, z000, a17);
1370 // let z00 = T::polyeval_mla(x, z000, a16);
1371 // let z01 = T::polyeval_mla(x, z00, a15);
1372 // let t1 = T::polyeval_mla(x, z01, a14);
1373 // let t2 = T::polyeval_mla(x, t1, a13);
1374 // let t3 = T::polyeval_mla(x, t2, a12);
1375 // let t4 = T::polyeval_mla(x, t3, a11);
1376 // let t5 = T::polyeval_mla(x, t4, a10);
1377 // let t6 = T::polyeval_mla(x, t5, a9);
1378 // let t7 = T::polyeval_mla(x, t6, a8);
1379 // let t8 = T::polyeval_mla(x, t7, a7);
1380 // let t9 = T::polyeval_mla(x, t8, a6);
1381 // let t10 = T::polyeval_mla(x, t9, a5);
1382 // let t11 = T::polyeval_mla(x, t10, a4);
1383 // let t12 = T::polyeval_mla(x, t11, a3);
1384 // let t13 = T::polyeval_mla(x, t12, a2);
1385 // let t14 = T::polyeval_mla(x, t13, a1);
1386 // T::polyeval_mla(x, t14, a0)
1387
1388 let x2 = x * x;
1389 let x4 = x2 * x2;
1390 let x8 = x4 * x4;
1391 let x16 = x8 * x8;
1392
1393 // Group degree 0–1
1394 let e0 = T::polyeval_mla(x, a1, a0);
1395 // Group degree 2–3
1396 let e1 = T::polyeval_mla(x, a3, a2);
1397 // Group degree 4–5
1398 let e2 = T::polyeval_mla(x, a5, a4);
1399 // Group degree 6–7
1400 let e3 = T::polyeval_mla(x, a7, a6);
1401 // Group degree 8–9
1402 let e4 = T::polyeval_mla(x, a9, a8);
1403 // Group degree 10–11
1404 let e5 = T::polyeval_mla(x, a11, a10);
1405 // Group degree 12–13
1406 let e6 = T::polyeval_mla(x, a13, a12);
1407 // Group degree 14–15
1408 let e7 = T::polyeval_mla(x, a15, a14);
1409 // Group degree 16–17
1410 let e8 = T::polyeval_mla(x, a17, a16);
1411 // Group degree 18–19
1412 let e9 = T::polyeval_mla(x, a19, a18);
1413 // Group degree 20–21
1414 let e10 = T::polyeval_mla(x, a21, a20);
1415 // Group degree 22–23
1416 let e11 = T::polyeval_mla(x, a23, a22);
1417
1418 // Now group into x2 terms
1419 let f0 = T::polyeval_mla(x2, e1, e0);
1420 let f1 = T::polyeval_mla(x2, e3, e2);
1421 let f2 = T::polyeval_mla(x2, e5, e4);
1422 let f3 = T::polyeval_mla(x2, e7, e6);
1423 let f4 = T::polyeval_mla(x2, e9, e8);
1424 let f5 = T::polyeval_mla(x2, e11, e10);
1425
1426 // Now group into x4 terms
1427 let g0 = T::polyeval_mla(x4, f1, f0);
1428 let g1 = T::polyeval_mla(x4, f3, f2);
1429 let g2 = T::polyeval_mla(x4, f5, f4);
1430
1431 // Now group into x8 terms
1432 let h0 = T::polyeval_mla(x8, g1, g0);
1433 let h1 = g2;
1434
1435 // Final step (x16 term)
1436 T::polyeval_mla(x16, h1, h0)
1437}
1438
1439// #[inline(always)]
1440// #[allow(clippy::too_many_arguments)]
1441// pub(crate) fn f_polyeval25<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1442// x: T,
1443// a0: T,
1444// a1: T,
1445// a2: T,
1446// a3: T,
1447// a4: T,
1448// a5: T,
1449// a6: T,
1450// a7: T,
1451// a8: T,
1452// a9: T,
1453// a10: T,
1454// a11: T,
1455// a12: T,
1456// a13: T,
1457// a14: T,
1458// a15: T,
1459// a16: T,
1460// a17: T,
1461// a18: T,
1462// a19: T,
1463// a20: T,
1464// a21: T,
1465// a22: T,
1466// a23: T,
1467// a24: T,
1468// ) -> T {
1469// let z000 = T::polyeval_mla(x, a24, a23);
1470// let z000 = T::polyeval_mla(x, z000, a22);
1471// let z000 = T::polyeval_mla(x, z000, a21);
1472// let z000 = T::polyeval_mla(x, z000, a20);
1473// let z000 = T::polyeval_mla(x, z000, a19);
1474// let z000 = T::polyeval_mla(x, z000, a18);
1475// let z000 = T::polyeval_mla(x, z000, a17);
1476// let z00 = T::polyeval_mla(x, z000, a16);
1477// let z01 = T::polyeval_mla(x, z00, a15);
1478// let t1 = T::polyeval_mla(x, z01, a14);
1479// let t2 = T::polyeval_mla(x, t1, a13);
1480// let t3 = T::polyeval_mla(x, t2, a12);
1481// let t4 = T::polyeval_mla(x, t3, a11);
1482// let t5 = T::polyeval_mla(x, t4, a10);
1483// let t6 = T::polyeval_mla(x, t5, a9);
1484// let t7 = T::polyeval_mla(x, t6, a8);
1485// let t8 = T::polyeval_mla(x, t7, a7);
1486// let t9 = T::polyeval_mla(x, t8, a6);
1487// let t10 = T::polyeval_mla(x, t9, a5);
1488// let t11 = T::polyeval_mla(x, t10, a4);
1489// let t12 = T::polyeval_mla(x, t11, a3);
1490// let t13 = T::polyeval_mla(x, t12, a2);
1491// let t14 = T::polyeval_mla(x, t13, a1);
1492// T::polyeval_mla(x, t14, a0)
1493// }
1494
1495// #[inline(always)]
1496// #[allow(clippy::too_many_arguments)]
1497// pub(crate) fn f_polyeval26<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1498// x: T,
1499// a0: T,
1500// a1: T,
1501// a2: T,
1502// a3: T,
1503// a4: T,
1504// a5: T,
1505// a6: T,
1506// a7: T,
1507// a8: T,
1508// a9: T,
1509// a10: T,
1510// a11: T,
1511// a12: T,
1512// a13: T,
1513// a14: T,
1514// a15: T,
1515// a16: T,
1516// a17: T,
1517// a18: T,
1518// a19: T,
1519// a20: T,
1520// a21: T,
1521// a22: T,
1522// a23: T,
1523// a24: T,
1524// a25: T,
1525// ) -> T {
1526// let x2 = x * x;
1527// let x4 = x2 * x2;
1528// let x8 = x4 * x4;
1529// let x16 = x8 * x8;
1530//
1531// let y0 = T::polyeval_mla(x, a1, a0);
1532// let y1 = T::polyeval_mla(x, a3, a2);
1533// let y2 = T::polyeval_mla(x, a5, a4);
1534// let y3 = T::polyeval_mla(x, a7, a6);
1535// let y4 = T::polyeval_mla(x, a9, a8);
1536// let y5 = T::polyeval_mla(x, a11, a10);
1537// let y6 = T::polyeval_mla(x, a13, a12);
1538// let y7 = T::polyeval_mla(x, a15, a14);
1539// let y8 = T::polyeval_mla(x, a17, a16);
1540// let y9 = T::polyeval_mla(x, a19, a18);
1541// let y10 = T::polyeval_mla(x, a21, a20);
1542// let y11 = T::polyeval_mla(x, a23, a22);
1543// let y12 = T::polyeval_mla(x, a25, a24);
1544//
1545// let z0 = T::polyeval_mla(x2, y1, y0);
1546// let z1 = T::polyeval_mla(x2, y3, y2);
1547// let z2 = T::polyeval_mla(x2, y5, y4);
1548// let z3 = T::polyeval_mla(x2, y7, y6);
1549// let z4 = T::polyeval_mla(x2, y9, y8);
1550// let z5 = T::polyeval_mla(x2, y11, y10);
1551//
1552// let w0 = T::polyeval_mla(x4, z1, z0);
1553// let w1 = T::polyeval_mla(x4, z3, z2);
1554// let w2 = T::polyeval_mla(x4, z5, z4);
1555//
1556// let v0 = T::polyeval_mla(x8, w1, w0);
1557// let v1 = T::polyeval_mla(x8, y12, w2);
1558//
1559// T::polyeval_mla(x16, v1, v0)
1560// }
1561
1562// #[inline(always)]
1563// #[allow(clippy::too_many_arguments)]
1564// pub(crate) fn f_polyeval27<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1565// x: T,
1566// a0: T,
1567// a1: T,
1568// a2: T,
1569// a3: T,
1570// a4: T,
1571// a5: T,
1572// a6: T,
1573// a7: T,
1574// a8: T,
1575// a9: T,
1576// a10: T,
1577// a11: T,
1578// a12: T,
1579// a13: T,
1580// a14: T,
1581// a15: T,
1582// a16: T,
1583// a17: T,
1584// a18: T,
1585// a19: T,
1586// a20: T,
1587// a21: T,
1588// a22: T,
1589// a23: T,
1590// a24: T,
1591// a25: T,
1592// a26: T,
1593// ) -> T {
1594// let z000 = T::polyeval_mla(x, a26, a25);
1595// let z000 = T::polyeval_mla(x, z000, a24);
1596// let z000 = T::polyeval_mla(x, z000, a23);
1597// let z000 = T::polyeval_mla(x, z000, a22);
1598// let z000 = T::polyeval_mla(x, z000, a21);
1599// let z000 = T::polyeval_mla(x, z000, a20);
1600// let z000 = T::polyeval_mla(x, z000, a19);
1601// let z000 = T::polyeval_mla(x, z000, a18);
1602// let z000 = T::polyeval_mla(x, z000, a17);
1603// let z00 = T::polyeval_mla(x, z000, a16);
1604// let z01 = T::polyeval_mla(x, z00, a15);
1605// let t1 = T::polyeval_mla(x, z01, a14);
1606// let t2 = T::polyeval_mla(x, t1, a13);
1607// let t3 = T::polyeval_mla(x, t2, a12);
1608// let t4 = T::polyeval_mla(x, t3, a11);
1609// let t5 = T::polyeval_mla(x, t4, a10);
1610// let t6 = T::polyeval_mla(x, t5, a9);
1611// let t7 = T::polyeval_mla(x, t6, a8);
1612// let t8 = T::polyeval_mla(x, t7, a7);
1613// let t9 = T::polyeval_mla(x, t8, a6);
1614// let t10 = T::polyeval_mla(x, t9, a5);
1615// let t11 = T::polyeval_mla(x, t10, a4);
1616// let t12 = T::polyeval_mla(x, t11, a3);
1617// let t13 = T::polyeval_mla(x, t12, a2);
1618// let t14 = T::polyeval_mla(x, t13, a1);
1619// T::polyeval_mla(x, t14, a0)
1620// }
1621
1622// #[inline(always)]
1623// #[allow(clippy::too_many_arguments)]
1624// pub(crate) fn f_polyeval30<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1625// x: T,
1626// a0: T,
1627// a1: T,
1628// a2: T,
1629// a3: T,
1630// a4: T,
1631// a5: T,
1632// a6: T,
1633// a7: T,
1634// a8: T,
1635// a9: T,
1636// a10: T,
1637// a11: T,
1638// a12: T,
1639// a13: T,
1640// a14: T,
1641// a15: T,
1642// a16: T,
1643// a17: T,
1644// a18: T,
1645// a19: T,
1646// a20: T,
1647// a21: T,
1648// a22: T,
1649// a23: T,
1650// a24: T,
1651// a25: T,
1652// a26: T,
1653// a27: T,
1654// a28: T,
1655// a29: T,
1656// ) -> T {
1657// let x2 = x * x;
1658// let x4 = x2 * x2;
1659// let x8 = x4 * x4;
1660// let x16 = x8 * x8;
1661//
1662// // Degree 0–1
1663// let e0 = T::polyeval_mla(x, a1, a0);
1664// // Degree 2–3
1665// let e1 = T::polyeval_mla(x, a3, a2);
1666// // Degree 4–5
1667// let e2 = T::polyeval_mla(x, a5, a4);
1668// // Degree 6–7
1669// let e3 = T::polyeval_mla(x, a7, a6);
1670// // Degree 8–9
1671// let e4 = T::polyeval_mla(x, a9, a8);
1672// // Degree 10–11
1673// let e5 = T::polyeval_mla(x, a11, a10);
1674// // Degree 12–13
1675// let e6 = T::polyeval_mla(x, a13, a12);
1676// // Degree 14–15
1677// let e7 = T::polyeval_mla(x, a15, a14);
1678//
1679// // Combine with x²
1680// let f0 = T::polyeval_mla(x2, e1, e0); // deg 0–3
1681// let f1 = T::polyeval_mla(x2, e3, e2); // deg 4–7
1682// let f2 = T::polyeval_mla(x2, e5, e4); // deg 8–11
1683// let f3 = T::polyeval_mla(x2, e7, e6); // deg 12–15
1684//
1685// // Combine with x⁴
1686// let g0 = T::polyeval_mla(x4, f1, f0); // deg 0–7
1687// let g1 = T::polyeval_mla(x4, f3, f2); // deg 8–15
1688//
1689// // Degree 16–17
1690// let e8 = T::polyeval_mla(x, a17, a16);
1691// // Degree 18–19
1692// let e9 = T::polyeval_mla(x, a19, a18);
1693// // Degree 20–21
1694// let e10 = T::polyeval_mla(x, a21, a20);
1695// // Degree 22–23
1696// let e11 = T::polyeval_mla(x, a23, a22);
1697// // Degree 24–25
1698// let e12 = T::polyeval_mla(x, a25, a24);
1699// // Degree 26–27
1700// let e13 = T::polyeval_mla(x, a27, a26);
1701// // Degree 28–29
1702// let e14 = T::polyeval_mla(x, a29, a28);
1703//
1704// // Combine with x²
1705// let f4 = T::polyeval_mla(x2, e9, e8); // deg 16–19
1706// let f5 = T::polyeval_mla(x2, e11, e10); // deg 20–23
1707// let f6 = T::polyeval_mla(x2, e13, e12); // deg 24–27
1708//
1709// // Combine remaining term (28–29)
1710// let f7 = e14;
1711//
1712// // Combine with x⁴
1713// let g2 = T::polyeval_mla(x4, f5, f4); // deg 16–23
1714// let g3 = T::polyeval_mla(x4, f7, f6); // deg 24–29
1715//
1716// // Combine with x⁸
1717// let h0 = T::polyeval_mla(x8, g1, g0); // deg 0–15
1718// let h1 = T::polyeval_mla(x8, g3, g2); // deg 16–29
1719//
1720// // Final combination with x¹⁶
1721// T::polyeval_mla(x16, h1, h0)
1722// }
1723
1724// #[inline(always)]
1725// #[allow(clippy::too_many_arguments)]
1726// pub(crate) fn f_horner_polyeval30<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1727// x: T,
1728// a0: T,
1729// a1: T,
1730// a2: T,
1731// a3: T,
1732// a4: T,
1733// a5: T,
1734// a6: T,
1735// a7: T,
1736// a8: T,
1737// a9: T,
1738// a10: T,
1739// a11: T,
1740// a12: T,
1741// a13: T,
1742// a14: T,
1743// a15: T,
1744// a16: T,
1745// a17: T,
1746// a18: T,
1747// a19: T,
1748// a20: T,
1749// a21: T,
1750// a22: T,
1751// a23: T,
1752// a24: T,
1753// a25: T,
1754// a26: T,
1755// a27: T,
1756// a28: T,
1757// a29: T,
1758// ) -> T {
1759// let mut acc = a29;
1760// acc = T::polyeval_mla(x, acc, a28);
1761// acc = T::polyeval_mla(x, acc, a27);
1762// acc = T::polyeval_mla(x, acc, a26);
1763// acc = T::polyeval_mla(x, acc, a25);
1764// acc = T::polyeval_mla(x, acc, a24);
1765// acc = T::polyeval_mla(x, acc, a23);
1766// acc = T::polyeval_mla(x, acc, a22);
1767// acc = T::polyeval_mla(x, acc, a21);
1768// acc = T::polyeval_mla(x, acc, a20);
1769// acc = T::polyeval_mla(x, acc, a19);
1770// acc = T::polyeval_mla(x, acc, a18);
1771// acc = T::polyeval_mla(x, acc, a17);
1772// acc = T::polyeval_mla(x, acc, a16);
1773// acc = T::polyeval_mla(x, acc, a15);
1774// acc = T::polyeval_mla(x, acc, a14);
1775// acc = T::polyeval_mla(x, acc, a13);
1776// acc = T::polyeval_mla(x, acc, a12);
1777// acc = T::polyeval_mla(x, acc, a11);
1778// acc = T::polyeval_mla(x, acc, a10);
1779// acc = T::polyeval_mla(x, acc, a9);
1780// acc = T::polyeval_mla(x, acc, a8);
1781// acc = T::polyeval_mla(x, acc, a7);
1782// acc = T::polyeval_mla(x, acc, a6);
1783// acc = T::polyeval_mla(x, acc, a5);
1784// acc = T::polyeval_mla(x, acc, a4);
1785// acc = T::polyeval_mla(x, acc, a3);
1786// acc = T::polyeval_mla(x, acc, a2);
1787// acc = T::polyeval_mla(x, acc, a1);
1788// T::polyeval_mla(x, acc, a0)
1789// }
1790
1791// #[inline(always)]
1792// #[allow(clippy::too_many_arguments)]
1793// pub(crate) fn f_polyeval31<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1794// x: T,
1795// a0: T,
1796// a1: T,
1797// a2: T,
1798// a3: T,
1799// a4: T,
1800// a5: T,
1801// a6: T,
1802// a7: T,
1803// a8: T,
1804// a9: T,
1805// a10: T,
1806// a11: T,
1807// a12: T,
1808// a13: T,
1809// a14: T,
1810// a15: T,
1811// a16: T,
1812// a17: T,
1813// a18: T,
1814// a19: T,
1815// a20: T,
1816// a21: T,
1817// a22: T,
1818// a23: T,
1819// a24: T,
1820// a25: T,
1821// a26: T,
1822// a27: T,
1823// a28: T,
1824// a29: T,
1825// a30: T,
1826// ) -> T {
1827// let z000 = T::polyeval_mla(x, a30, a29);
1828// let z000 = T::polyeval_mla(x, z000, a28);
1829// let z000 = T::polyeval_mla(x, z000, a27);
1830// let z000 = T::polyeval_mla(x, z000, a26);
1831// let z000 = T::polyeval_mla(x, z000, a25);
1832// let z000 = T::polyeval_mla(x, z000, a24);
1833// let z000 = T::polyeval_mla(x, z000, a23);
1834// let z000 = T::polyeval_mla(x, z000, a22);
1835// let z000 = T::polyeval_mla(x, z000, a21);
1836// let z000 = T::polyeval_mla(x, z000, a20);
1837// let z000 = T::polyeval_mla(x, z000, a19);
1838// let z000 = T::polyeval_mla(x, z000, a18);
1839// let z000 = T::polyeval_mla(x, z000, a17);
1840// let z00 = T::polyeval_mla(x, z000, a16);
1841// let z01 = T::polyeval_mla(x, z00, a15);
1842// let t1 = T::polyeval_mla(x, z01, a14);
1843// let t2 = T::polyeval_mla(x, t1, a13);
1844// let t3 = T::polyeval_mla(x, t2, a12);
1845// let t4 = T::polyeval_mla(x, t3, a11);
1846// let t5 = T::polyeval_mla(x, t4, a10);
1847// let t6 = T::polyeval_mla(x, t5, a9);
1848// let t7 = T::polyeval_mla(x, t6, a8);
1849// let t8 = T::polyeval_mla(x, t7, a7);
1850// let t9 = T::polyeval_mla(x, t8, a6);
1851// let t10 = T::polyeval_mla(x, t9, a5);
1852// let t11 = T::polyeval_mla(x, t10, a4);
1853// let t12 = T::polyeval_mla(x, t11, a3);
1854// let t13 = T::polyeval_mla(x, t12, a2);
1855// let t14 = T::polyeval_mla(x, t13, a1);
1856// T::polyeval_mla(x, t14, a0)
1857// }
1858
1859// #[inline(always)]
1860// #[allow(clippy::too_many_arguments)]
1861// pub(crate) fn f_polyeval33<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1862// x: T,
1863// a0: T,
1864// a1: T,
1865// a2: T,
1866// a3: T,
1867// a4: T,
1868// a5: T,
1869// a6: T,
1870// a7: T,
1871// a8: T,
1872// a9: T,
1873// a10: T,
1874// a11: T,
1875// a12: T,
1876// a13: T,
1877// a14: T,
1878// a15: T,
1879// a16: T,
1880// a17: T,
1881// a18: T,
1882// a19: T,
1883// a20: T,
1884// a21: T,
1885// a22: T,
1886// a23: T,
1887// a24: T,
1888// a25: T,
1889// a26: T,
1890// a27: T,
1891// a28: T,
1892// a29: T,
1893// a30: T,
1894// a31: T,
1895// a32: T,
1896// ) -> T {
1897// let z000 = T::polyeval_mla(x, a32, a31);
1898// let z000 = T::polyeval_mla(x, z000, a30);
1899// let z000 = T::polyeval_mla(x, z000, a29);
1900// let z000 = T::polyeval_mla(x, z000, a28);
1901// let z000 = T::polyeval_mla(x, z000, a27);
1902// let z000 = T::polyeval_mla(x, z000, a26);
1903// let z000 = T::polyeval_mla(x, z000, a25);
1904// let z000 = T::polyeval_mla(x, z000, a24);
1905// let z000 = T::polyeval_mla(x, z000, a23);
1906// let z000 = T::polyeval_mla(x, z000, a22);
1907// let z000 = T::polyeval_mla(x, z000, a21);
1908// let z000 = T::polyeval_mla(x, z000, a20);
1909// let z000 = T::polyeval_mla(x, z000, a19);
1910// let z000 = T::polyeval_mla(x, z000, a18);
1911// let z000 = T::polyeval_mla(x, z000, a17);
1912// let z00 = T::polyeval_mla(x, z000, a16);
1913// let z01 = T::polyeval_mla(x, z00, a15);
1914// let t1 = T::polyeval_mla(x, z01, a14);
1915// let t2 = T::polyeval_mla(x, t1, a13);
1916// let t3 = T::polyeval_mla(x, t2, a12);
1917// let t4 = T::polyeval_mla(x, t3, a11);
1918// let t5 = T::polyeval_mla(x, t4, a10);
1919// let t6 = T::polyeval_mla(x, t5, a9);
1920// let t7 = T::polyeval_mla(x, t6, a8);
1921// let t8 = T::polyeval_mla(x, t7, a7);
1922// let t9 = T::polyeval_mla(x, t8, a6);
1923// let t10 = T::polyeval_mla(x, t9, a5);
1924// let t11 = T::polyeval_mla(x, t10, a4);
1925// let t12 = T::polyeval_mla(x, t11, a3);
1926// let t13 = T::polyeval_mla(x, t12, a2);
1927// let t14 = T::polyeval_mla(x, t13, a1);
1928// T::polyeval_mla(x, t14, a0)
1929// }
1930
1931// #[inline(always)]
1932// #[allow(clippy::too_many_arguments)]
1933// pub(crate) fn f_polyeval29<T: PolyevalMla + Copy + Mul<T, Output = T>>(
1934// x: T,
1935// a0: T,
1936// a1: T,
1937// a2: T,
1938// a3: T,
1939// a4: T,
1940// a5: T,
1941// a6: T,
1942// a7: T,
1943// a8: T,
1944// a9: T,
1945// a10: T,
1946// a11: T,
1947// a12: T,
1948// a13: T,
1949// a14: T,
1950// a15: T,
1951// a16: T,
1952// a17: T,
1953// a18: T,
1954// a19: T,
1955// a20: T,
1956// a21: T,
1957// a22: T,
1958// a23: T,
1959// a24: T,
1960// a25: T,
1961// a26: T,
1962// a27: T,
1963// a28: T,
1964// ) -> T {
1965// let x2 = x * x;
1966// let x4 = x2 * x2;
1967// let x8 = x4 * x4;
1968//
1969// // Level 0
1970// let e0 = T::polyeval_mla(x, a1, a0);
1971// let e1 = T::polyeval_mla(x, a3, a2);
1972// let e2 = T::polyeval_mla(x, a5, a4);
1973// let e3 = T::polyeval_mla(x, a7, a6);
1974// let e4 = T::polyeval_mla(x, a9, a8);
1975// let e5 = T::polyeval_mla(x, a11, a10);
1976// let e6 = T::polyeval_mla(x, a13, a12);
1977// let e7 = T::polyeval_mla(x, a15, a14);
1978// let e8 = T::polyeval_mla(x, a17, a16);
1979// let e9 = T::polyeval_mla(x, a19, a18);
1980// let e10 = T::polyeval_mla(x, a21, a20);
1981// let e11 = T::polyeval_mla(x, a23, a22);
1982// let e12 = T::polyeval_mla(x, a25, a24);
1983// let e13 = T::polyeval_mla(x, a27, a26);
1984// let e14 = a28; // single term left
1985//
1986// // Level 1
1987// let f0 = T::polyeval_mla(x2, e1, e0); // e1*x² + e0
1988// let f1 = T::polyeval_mla(x2, e3, e2);
1989// let f2 = T::polyeval_mla(x2, e5, e4);
1990// let f3 = T::polyeval_mla(x2, e7, e6);
1991// let f4 = T::polyeval_mla(x2, e9, e8);
1992// let f5 = T::polyeval_mla(x2, e11, e10);
1993// let f6 = T::polyeval_mla(x2, e13, e12);
1994// let f7 = e14; // promote
1995//
1996// // Level 2
1997// let g0 = T::polyeval_mla(x4, f1, f0);
1998// let g1 = T::polyeval_mla(x4, f3, f2);
1999// let g2 = T::polyeval_mla(x4, f5, f4);
2000// let g3 = T::polyeval_mla(x4, f7, f6);
2001//
2002// // Level 3
2003// let h0 = T::polyeval_mla(x8, g1, g0);
2004// let h1 = T::polyeval_mla(x8, g3, g2);
2005//
2006// // Final level
2007// let x16 = x8 * x8;
2008// T::polyeval_mla(x16, h1, h0)
2009// }
2010
2011// #[inline(always)]
2012// #[allow(clippy::too_many_arguments)]
2013// pub(crate) fn f_polyeval37<T: PolyevalMla + Copy + Mul<T, Output = T>>(
2014// x: T,
2015// a0: T,
2016// a1: T,
2017// a2: T,
2018// a3: T,
2019// a4: T,
2020// a5: T,
2021// a6: T,
2022// a7: T,
2023// a8: T,
2024// a9: T,
2025// a10: T,
2026// a11: T,
2027// a12: T,
2028// a13: T,
2029// a14: T,
2030// a15: T,
2031// a16: T,
2032// a17: T,
2033// a18: T,
2034// a19: T,
2035// a20: T,
2036// a21: T,
2037// a22: T,
2038// a23: T,
2039// a24: T,
2040// a25: T,
2041// a26: T,
2042// a27: T,
2043// a28: T,
2044// a29: T,
2045// a30: T,
2046// a31: T,
2047// a32: T,
2048// a33: T,
2049// a34: T,
2050// a35: T,
2051// a36: T,
2052// ) -> T {
2053// let z000 = T::polyeval_mla(x, a36, a35);
2054// let z000 = T::polyeval_mla(x, z000, a34);
2055// let z000 = T::polyeval_mla(x, z000, a33);
2056// let z000 = T::polyeval_mla(x, z000, a32);
2057// let z000 = T::polyeval_mla(x, z000, a31);
2058// let z000 = T::polyeval_mla(x, z000, a30);
2059// let z000 = T::polyeval_mla(x, z000, a29);
2060// let z000 = T::polyeval_mla(x, z000, a28);
2061// let z000 = T::polyeval_mla(x, z000, a27);
2062// let z000 = T::polyeval_mla(x, z000, a26);
2063// let z000 = T::polyeval_mla(x, z000, a25);
2064// let z000 = T::polyeval_mla(x, z000, a24);
2065// let z000 = T::polyeval_mla(x, z000, a23);
2066// let z000 = T::polyeval_mla(x, z000, a22);
2067// let z000 = T::polyeval_mla(x, z000, a21);
2068// let z000 = T::polyeval_mla(x, z000, a20);
2069// let z000 = T::polyeval_mla(x, z000, a19);
2070// let z000 = T::polyeval_mla(x, z000, a18);
2071// let z000 = T::polyeval_mla(x, z000, a17);
2072// let z00 = T::polyeval_mla(x, z000, a16);
2073// let z01 = T::polyeval_mla(x, z00, a15);
2074// let t1 = T::polyeval_mla(x, z01, a14);
2075// let t2 = T::polyeval_mla(x, t1, a13);
2076// let t3 = T::polyeval_mla(x, t2, a12);
2077// let t4 = T::polyeval_mla(x, t3, a11);
2078// let t5 = T::polyeval_mla(x, t4, a10);
2079// let t6 = T::polyeval_mla(x, t5, a9);
2080// let t7 = T::polyeval_mla(x, t6, a8);
2081// let t8 = T::polyeval_mla(x, t7, a7);
2082// let t9 = T::polyeval_mla(x, t8, a6);
2083// let t10 = T::polyeval_mla(x, t9, a5);
2084// let t11 = T::polyeval_mla(x, t10, a4);
2085// let t12 = T::polyeval_mla(x, t11, a3);
2086// let t13 = T::polyeval_mla(x, t12, a2);
2087// let t14 = T::polyeval_mla(x, t13, a1);
2088// T::polyeval_mla(x, t14, a0)
2089// }
2090
2091// #[inline(always)]
2092// #[allow(clippy::too_many_arguments)]
2093// pub(crate) fn f_polyeval36<T: PolyevalMla + Copy + Mul<T, Output = T>>(
2094// x: T,
2095// a0: T,
2096// a1: T,
2097// a2: T,
2098// a3: T,
2099// a4: T,
2100// a5: T,
2101// a6: T,
2102// a7: T,
2103// a8: T,
2104// a9: T,
2105// a10: T,
2106// a11: T,
2107// a12: T,
2108// a13: T,
2109// a14: T,
2110// a15: T,
2111// a16: T,
2112// a17: T,
2113// a18: T,
2114// a19: T,
2115// a20: T,
2116// a21: T,
2117// a22: T,
2118// a23: T,
2119// a24: T,
2120// a25: T,
2121// a26: T,
2122// a27: T,
2123// a28: T,
2124// a29: T,
2125// a30: T,
2126// a31: T,
2127// a32: T,
2128// a33: T,
2129// a34: T,
2130// a35: T,
2131// ) -> T {
2132// let z000 = T::polyeval_mla(x, a35, a34);
2133// let z000 = T::polyeval_mla(x, z000, a33);
2134// let z000 = T::polyeval_mla(x, z000, a32);
2135// let z000 = T::polyeval_mla(x, z000, a31);
2136// let z000 = T::polyeval_mla(x, z000, a30);
2137// let z000 = T::polyeval_mla(x, z000, a29);
2138// let z000 = T::polyeval_mla(x, z000, a28);
2139// let z000 = T::polyeval_mla(x, z000, a27);
2140// let z000 = T::polyeval_mla(x, z000, a26);
2141// let z000 = T::polyeval_mla(x, z000, a25);
2142// let z000 = T::polyeval_mla(x, z000, a24);
2143// let z000 = T::polyeval_mla(x, z000, a23);
2144// let z000 = T::polyeval_mla(x, z000, a22);
2145// let z000 = T::polyeval_mla(x, z000, a21);
2146// let z000 = T::polyeval_mla(x, z000, a20);
2147// let z000 = T::polyeval_mla(x, z000, a19);
2148// let z000 = T::polyeval_mla(x, z000, a18);
2149// let z000 = T::polyeval_mla(x, z000, a17);
2150// let z00 = T::polyeval_mla(x, z000, a16);
2151// let z01 = T::polyeval_mla(x, z00, a15);
2152// let t1 = T::polyeval_mla(x, z01, a14);
2153// let t2 = T::polyeval_mla(x, t1, a13);
2154// let t3 = T::polyeval_mla(x, t2, a12);
2155// let t4 = T::polyeval_mla(x, t3, a11);
2156// let t5 = T::polyeval_mla(x, t4, a10);
2157// let t6 = T::polyeval_mla(x, t5, a9);
2158// let t7 = T::polyeval_mla(x, t6, a8);
2159// let t8 = T::polyeval_mla(x, t7, a7);
2160// let t9 = T::polyeval_mla(x, t8, a6);
2161// let t10 = T::polyeval_mla(x, t9, a5);
2162// let t11 = T::polyeval_mla(x, t10, a4);
2163// let t12 = T::polyeval_mla(x, t11, a3);
2164// let t13 = T::polyeval_mla(x, t12, a2);
2165// let t14 = T::polyeval_mla(x, t13, a1);
2166// T::polyeval_mla(x, t14, a0)
2167// }
2168
2169// #[inline(always)]
2170// #[allow(clippy::too_many_arguments)]
2171// pub(crate) fn f_polyeval41<T: PolyevalMla + Copy + Mul<T, Output = T>>(
2172// x: T,
2173// a0: T,
2174// a1: T,
2175// a2: T,
2176// a3: T,
2177// a4: T,
2178// a5: T,
2179// a6: T,
2180// a7: T,
2181// a8: T,
2182// a9: T,
2183// a10: T,
2184// a11: T,
2185// a12: T,
2186// a13: T,
2187// a14: T,
2188// a15: T,
2189// a16: T,
2190// a17: T,
2191// a18: T,
2192// a19: T,
2193// a20: T,
2194// a21: T,
2195// a22: T,
2196// a23: T,
2197// a24: T,
2198// a25: T,
2199// a26: T,
2200// a27: T,
2201// a28: T,
2202// a29: T,
2203// a30: T,
2204// a31: T,
2205// a32: T,
2206// a33: T,
2207// a34: T,
2208// a35: T,
2209// a36: T,
2210// a37: T,
2211// a38: T,
2212// a39: T,
2213// a40: T,
2214// ) -> T {
2215// let mut acc = a40;
2216// acc = T::polyeval_mla(x, acc, a39);
2217// acc = T::polyeval_mla(x, acc, a38);
2218// acc = T::polyeval_mla(x, acc, a37);
2219// acc = T::polyeval_mla(x, acc, a36);
2220// acc = T::polyeval_mla(x, acc, a35);
2221// acc = T::polyeval_mla(x, acc, a34);
2222// acc = T::polyeval_mla(x, acc, a33);
2223// acc = T::polyeval_mla(x, acc, a32);
2224// acc = T::polyeval_mla(x, acc, a31);
2225// acc = T::polyeval_mla(x, acc, a30);
2226// acc = T::polyeval_mla(x, acc, a29);
2227// acc = T::polyeval_mla(x, acc, a28);
2228// acc = T::polyeval_mla(x, acc, a27);
2229// acc = T::polyeval_mla(x, acc, a26);
2230// acc = T::polyeval_mla(x, acc, a25);
2231// acc = T::polyeval_mla(x, acc, a24);
2232// acc = T::polyeval_mla(x, acc, a23);
2233// acc = T::polyeval_mla(x, acc, a22);
2234// acc = T::polyeval_mla(x, acc, a21);
2235// acc = T::polyeval_mla(x, acc, a20);
2236// acc = T::polyeval_mla(x, acc, a19);
2237// acc = T::polyeval_mla(x, acc, a18);
2238// acc = T::polyeval_mla(x, acc, a17);
2239// acc = T::polyeval_mla(x, acc, a16);
2240// acc = T::polyeval_mla(x, acc, a15);
2241// acc = T::polyeval_mla(x, acc, a14);
2242// acc = T::polyeval_mla(x, acc, a13);
2243// acc = T::polyeval_mla(x, acc, a12);
2244// acc = T::polyeval_mla(x, acc, a11);
2245// acc = T::polyeval_mla(x, acc, a10);
2246// acc = T::polyeval_mla(x, acc, a9);
2247// acc = T::polyeval_mla(x, acc, a8);
2248// acc = T::polyeval_mla(x, acc, a7);
2249// acc = T::polyeval_mla(x, acc, a6);
2250// acc = T::polyeval_mla(x, acc, a5);
2251// acc = T::polyeval_mla(x, acc, a4);
2252// acc = T::polyeval_mla(x, acc, a3);
2253// acc = T::polyeval_mla(x, acc, a2);
2254// acc = T::polyeval_mla(x, acc, a1);
2255// T::polyeval_mla(x, acc, a0)
2256// }
2257
2258// #[inline(always)]
2259// #[allow(clippy::too_many_arguments)]
2260// pub(crate) fn f_polyeval44<T: PolyevalMla + Copy + Mul<T, Output = T>>(
2261// x: T,
2262// a0: T,
2263// a1: T,
2264// a2: T,
2265// a3: T,
2266// a4: T,
2267// a5: T,
2268// a6: T,
2269// a7: T,
2270// a8: T,
2271// a9: T,
2272// a10: T,
2273// a11: T,
2274// a12: T,
2275// a13: T,
2276// a14: T,
2277// a15: T,
2278// a16: T,
2279// a17: T,
2280// a18: T,
2281// a19: T,
2282// a20: T,
2283// a21: T,
2284// a22: T,
2285// a23: T,
2286// a24: T,
2287// a25: T,
2288// a26: T,
2289// a27: T,
2290// a28: T,
2291// a29: T,
2292// a30: T,
2293// a31: T,
2294// a32: T,
2295// a33: T,
2296// a34: T,
2297// a35: T,
2298// a36: T,
2299// a37: T,
2300// a38: T,
2301// a39: T,
2302// a40: T,
2303// a41: T,
2304// a42: T,
2305// a43: T,
2306// ) -> T {
2307// let mut acc = a43;
2308// acc = T::polyeval_mla(x, acc, a42);
2309// acc = T::polyeval_mla(x, acc, a41);
2310// acc = T::polyeval_mla(x, acc, a40);
2311// acc = T::polyeval_mla(x, acc, a39);
2312// acc = T::polyeval_mla(x, acc, a38);
2313// acc = T::polyeval_mla(x, acc, a37);
2314// acc = T::polyeval_mla(x, acc, a36);
2315// acc = T::polyeval_mla(x, acc, a35);
2316// acc = T::polyeval_mla(x, acc, a34);
2317// acc = T::polyeval_mla(x, acc, a33);
2318// acc = T::polyeval_mla(x, acc, a32);
2319// acc = T::polyeval_mla(x, acc, a31);
2320// acc = T::polyeval_mla(x, acc, a30);
2321// acc = T::polyeval_mla(x, acc, a29);
2322// acc = T::polyeval_mla(x, acc, a28);
2323// acc = T::polyeval_mla(x, acc, a27);
2324// acc = T::polyeval_mla(x, acc, a26);
2325// acc = T::polyeval_mla(x, acc, a25);
2326// acc = T::polyeval_mla(x, acc, a24);
2327// acc = T::polyeval_mla(x, acc, a23);
2328// acc = T::polyeval_mla(x, acc, a22);
2329// acc = T::polyeval_mla(x, acc, a21);
2330// acc = T::polyeval_mla(x, acc, a20);
2331// acc = T::polyeval_mla(x, acc, a19);
2332// acc = T::polyeval_mla(x, acc, a18);
2333// acc = T::polyeval_mla(x, acc, a17);
2334// acc = T::polyeval_mla(x, acc, a16);
2335// acc = T::polyeval_mla(x, acc, a15);
2336// acc = T::polyeval_mla(x, acc, a14);
2337// acc = T::polyeval_mla(x, acc, a13);
2338// acc = T::polyeval_mla(x, acc, a12);
2339// acc = T::polyeval_mla(x, acc, a11);
2340// acc = T::polyeval_mla(x, acc, a10);
2341// acc = T::polyeval_mla(x, acc, a9);
2342// acc = T::polyeval_mla(x, acc, a8);
2343// acc = T::polyeval_mla(x, acc, a7);
2344// acc = T::polyeval_mla(x, acc, a6);
2345// acc = T::polyeval_mla(x, acc, a5);
2346// acc = T::polyeval_mla(x, acc, a4);
2347// acc = T::polyeval_mla(x, acc, a3);
2348// acc = T::polyeval_mla(x, acc, a2);
2349// acc = T::polyeval_mla(x, acc, a1);
2350// T::polyeval_mla(x, acc, a0)
2351// }
2352
2353// #[inline(always)]
2354// #[allow(clippy::too_many_arguments)]
2355// pub(crate) fn f_polyeval43<T: PolyevalMla + Copy + Mul<T, Output = T>>(
2356// x: T,
2357// a0: T,
2358// a1: T,
2359// a2: T,
2360// a3: T,
2361// a4: T,
2362// a5: T,
2363// a6: T,
2364// a7: T,
2365// a8: T,
2366// a9: T,
2367// a10: T,
2368// a11: T,
2369// a12: T,
2370// a13: T,
2371// a14: T,
2372// a15: T,
2373// a16: T,
2374// a17: T,
2375// a18: T,
2376// a19: T,
2377// a20: T,
2378// a21: T,
2379// a22: T,
2380// a23: T,
2381// a24: T,
2382// a25: T,
2383// a26: T,
2384// a27: T,
2385// a28: T,
2386// a29: T,
2387// a30: T,
2388// a31: T,
2389// a32: T,
2390// a33: T,
2391// a34: T,
2392// a35: T,
2393// a36: T,
2394// a37: T,
2395// a38: T,
2396// a39: T,
2397// a40: T,
2398// a41: T,
2399// a42: T,
2400// ) -> T {
2401// let z000 = T::polyeval_mla(x, a42, a41);
2402// let z000 = T::polyeval_mla(x, z000, a40);
2403// let z000 = T::polyeval_mla(x, z000, a39);
2404// let z000 = T::polyeval_mla(x, z000, a38);
2405// let z000 = T::polyeval_mla(x, z000, a37);
2406// let z000 = T::polyeval_mla(x, z000, a36);
2407// let z000 = T::polyeval_mla(x, z000, a35);
2408// let z000 = T::polyeval_mla(x, z000, a34);
2409// let z000 = T::polyeval_mla(x, z000, a33);
2410// let z000 = T::polyeval_mla(x, z000, a32);
2411// let z000 = T::polyeval_mla(x, z000, a31);
2412// let z000 = T::polyeval_mla(x, z000, a30);
2413// let z000 = T::polyeval_mla(x, z000, a29);
2414// let z000 = T::polyeval_mla(x, z000, a28);
2415// let z000 = T::polyeval_mla(x, z000, a27);
2416// let z000 = T::polyeval_mla(x, z000, a26);
2417// let z000 = T::polyeval_mla(x, z000, a25);
2418// let z000 = T::polyeval_mla(x, z000, a24);
2419// let z000 = T::polyeval_mla(x, z000, a23);
2420// let z000 = T::polyeval_mla(x, z000, a22);
2421// let z000 = T::polyeval_mla(x, z000, a21);
2422// let z000 = T::polyeval_mla(x, z000, a20);
2423// let z000 = T::polyeval_mla(x, z000, a19);
2424// let z000 = T::polyeval_mla(x, z000, a18);
2425// let z000 = T::polyeval_mla(x, z000, a17);
2426// let z00 = T::polyeval_mla(x, z000, a16);
2427// let z01 = T::polyeval_mla(x, z00, a15);
2428// let t1 = T::polyeval_mla(x, z01, a14);
2429// let t2 = T::polyeval_mla(x, t1, a13);
2430// let t3 = T::polyeval_mla(x, t2, a12);
2431// let t4 = T::polyeval_mla(x, t3, a11);
2432// let t5 = T::polyeval_mla(x, t4, a10);
2433// let t6 = T::polyeval_mla(x, t5, a9);
2434// let t7 = T::polyeval_mla(x, t6, a8);
2435// let t8 = T::polyeval_mla(x, t7, a7);
2436// let t9 = T::polyeval_mla(x, t8, a6);
2437// let t10 = T::polyeval_mla(x, t9, a5);
2438// let t11 = T::polyeval_mla(x, t10, a4);
2439// let t12 = T::polyeval_mla(x, t11, a3);
2440// let t13 = T::polyeval_mla(x, t12, a2);
2441// let t14 = T::polyeval_mla(x, t13, a1);
2442// T::polyeval_mla(x, t14, a0)
2443// }
2444
2445// #[inline(always)]
2446// #[allow(clippy::too_many_arguments)]
2447// pub(crate) fn f_polyeval35<T: PolyevalMla + Copy + Mul<T, Output = T>>(
2448// x: T,
2449// a0: T,
2450// a1: T,
2451// a2: T,
2452// a3: T,
2453// a4: T,
2454// a5: T,
2455// a6: T,
2456// a7: T,
2457// a8: T,
2458// a9: T,
2459// a10: T,
2460// a11: T,
2461// a12: T,
2462// a13: T,
2463// a14: T,
2464// a15: T,
2465// a16: T,
2466// a17: T,
2467// a18: T,
2468// a19: T,
2469// a20: T,
2470// a21: T,
2471// a22: T,
2472// a23: T,
2473// a24: T,
2474// a25: T,
2475// a26: T,
2476// a27: T,
2477// a28: T,
2478// a29: T,
2479// a30: T,
2480// a31: T,
2481// a32: T,
2482// a33: T,
2483// a34: T,
2484// ) -> T {
2485// // let z000 = T::polyeval_mla(x, a34, a33);
2486// // let z000 = T::polyeval_mla(x, z000, a32);
2487// // let z000 = T::polyeval_mla(x, z000, a31);
2488// // let z000 = T::polyeval_mla(x, z000, a30);
2489// // let z000 = T::polyeval_mla(x, z000, a29);
2490// // let z000 = T::polyeval_mla(x, z000, a28);
2491// // let z000 = T::polyeval_mla(x, z000, a27);
2492// // let z000 = T::polyeval_mla(x, z000, a26);
2493// // let z000 = T::polyeval_mla(x, z000, a25);
2494// // let z000 = T::polyeval_mla(x, z000, a24);
2495// // let z000 = T::polyeval_mla(x, z000, a23);
2496// // let z000 = T::polyeval_mla(x, z000, a22);
2497// // let z000 = T::polyeval_mla(x, z000, a21);
2498// // let z000 = T::polyeval_mla(x, z000, a20);
2499// // let z000 = T::polyeval_mla(x, z000, a19);
2500// // let z000 = T::polyeval_mla(x, z000, a18);
2501// // let z000 = T::polyeval_mla(x, z000, a17);
2502// // let z00 = T::polyeval_mla(x, z000, a16);
2503// // let z01 = T::polyeval_mla(x, z00, a15);
2504// // let t1 = T::polyeval_mla(x, z01, a14);
2505// // let t2 = T::polyeval_mla(x, t1, a13);
2506// // let t3 = T::polyeval_mla(x, t2, a12);
2507// // let t4 = T::polyeval_mla(x, t3, a11);
2508// // let t5 = T::polyeval_mla(x, t4, a10);
2509// // let t6 = T::polyeval_mla(x, t5, a9);
2510// // let t7 = T::polyeval_mla(x, t6, a8);
2511// // let t8 = T::polyeval_mla(x, t7, a7);
2512// // let t9 = T::polyeval_mla(x, t8, a6);
2513// // let t10 = T::polyeval_mla(x, t9, a5);
2514// // let t11 = T::polyeval_mla(x, t10, a4);
2515// // let t12 = T::polyeval_mla(x, t11, a3);
2516// // let t13 = T::polyeval_mla(x, t12, a2);
2517// // let t14 = T::polyeval_mla(x, t13, a1);
2518// // T::polyeval_mla(x, t14, a0)
2519//
2520// let x2 = x * x;
2521// let x4 = x2 * x2;
2522// let x8 = x4 * x4;
2523// let x16 = x8 * x8;
2524// let x32 = x16 * x16;
2525//
2526// // Level 0
2527// let z0 = T::polyeval_mla(x, a1, a0);
2528// let z1 = T::polyeval_mla(x, a3, a2);
2529// let z2 = T::polyeval_mla(x, a5, a4);
2530// let z3 = T::polyeval_mla(x, a7, a6);
2531// let z4 = T::polyeval_mla(x, a9, a8);
2532// let z5 = T::polyeval_mla(x, a11, a10);
2533// let z6 = T::polyeval_mla(x, a13, a12);
2534// let z7 = T::polyeval_mla(x, a15, a14);
2535// let z8 = T::polyeval_mla(x, a17, a16);
2536// let z9 = T::polyeval_mla(x, a19, a18);
2537// let z10 = T::polyeval_mla(x, a21, a20);
2538// let z11 = T::polyeval_mla(x, a23, a22);
2539// let z12 = T::polyeval_mla(x, a25, a24);
2540// let z13 = T::polyeval_mla(x, a27, a26);
2541// let z14 = T::polyeval_mla(x, a29, a28);
2542// let z15 = T::polyeval_mla(x, a31, a30);
2543// let z16 = T::polyeval_mla(x, a33, a32);
2544// let z17 = a34;
2545//
2546// // Level 1
2547// let y0 = T::polyeval_mla(x2, z1, z0);
2548// let y1 = T::polyeval_mla(x2, z3, z2);
2549// let y2 = T::polyeval_mla(x2, z5, z4);
2550// let y3 = T::polyeval_mla(x2, z7, z6);
2551// let y4 = T::polyeval_mla(x2, z9, z8);
2552// let y5 = T::polyeval_mla(x2, z11, z10);
2553// let y6 = T::polyeval_mla(x2, z13, z12);
2554// let y7 = T::polyeval_mla(x2, z15, z14);
2555// let y8 = T::polyeval_mla(x2, z17, z16);
2556//
2557// // Level 2
2558// let w0 = T::polyeval_mla(x4, y1, y0);
2559// let w1 = T::polyeval_mla(x4, y3, y2);
2560// let w2 = T::polyeval_mla(x4, y5, y4);
2561// let w3 = T::polyeval_mla(x4, y7, y6);
2562// let w4 = y8;
2563//
2564// // Level 3
2565// let v0 = T::polyeval_mla(x8, w1, w0);
2566// let v1 = T::polyeval_mla(x8, w3, w2);
2567// let v2 = w4;
2568//
2569// // Level 4
2570// let u0 = T::polyeval_mla(x16, v1, v0);
2571// let u1 = v2;
2572//
2573// // Level 5 (final)
2574// T::polyeval_mla(x32, u1, u0)
2575// }