p_chan/
ops.rs

1//! Constant "trait" operations
2//!
3//! This module provides wrapper structs for performing operations on channel
4//! values (which are `const` compatible).
5//!
6//! ## Conversion
7//!
8//! This is like [`From`] / [`Into`], but `const`.
9//!
10//! ## Difference
11//!
12//! Subtract a list of channel values from a channel value.
13//!
14//! ## Inversion
15//!
16//! Flip value between the minimum and maximum.
17//!
18//! ## Negation
19//!
20//! This is the same as inversion except for unsigned floating-point channels.
21//!
22//! ## Product
23//!
24//! Multiply the channel values together (saturating for ints).
25//!
26//! ## Sum
27//!
28//! Add the channel values together (saturating for ints).
29
30use core::marker::PhantomData;
31
32/// Constant sum operation (`add`)
33///
34///  - `Sum([]).add()`
35#[derive(Debug)]
36pub struct Sum<T, const N: usize>(pub [T; N]);
37
38/// Constant product operation (`mul`)
39///
40///  - `Product([]).mul()`
41#[derive(Debug)]
42pub struct Product<T, const N: usize>(pub [T; N]);
43
44/// Constant conversion operation (`conv`)
45///
46///  - `Conversion::<_, U>::conv(_)`
47#[derive(Debug)]
48pub struct Conversion<T, U>(T, PhantomData<fn() -> U>);
49
50/// Constant inversion operation (`inv`)
51///
52///  - `Inversion(_)::inv()`
53#[derive(Debug)]
54pub struct Inversion<T>(pub T);
55
56/// Constant negation operation (`neg`)
57///
58///  - `Negation(_)::neg()`
59#[derive(Debug)]
60pub struct Negation<T>(pub T);
61
62/// Constant difference operation (`sub`)
63///
64///  - `Difference(_, []).sub()`
65#[derive(Debug)]
66pub struct Difference<T, const N: usize>(pub T, pub [T; N]);
67
68#[cfg(any(feature = "signed", feature = "unsigned"))]
69macro_rules! int_channel {
70    ($type:ty) => {
71        impl<const N: usize> Sum<$type, N> {
72            /// Add up the sum.
73            pub const fn add(self) -> $type {
74                let mut ret = 0;
75                let mut i = 0;
76
77                loop {
78                    if i >= N {
79                        break <$type>::new(ret);
80                    }
81
82                    let value = self.0[i];
83
84                    ret = ret.saturating_add(value.into_inner());
85                    i += 1;
86                }
87            }
88        }
89
90        impl<const N: usize> Difference<$type, N> {
91            /// Subtract to get the difference.
92            pub const fn sub(self) -> $type {
93                let mut ret = self.0.into_inner();
94                let mut i = 0;
95
96                loop {
97                    if i >= N {
98                        break <$type>::new(ret);
99                    }
100
101                    let value = self.1[i];
102
103                    ret = ret.saturating_sub(value.into_inner());
104                    i += 1;
105                }
106            }
107        }
108
109        impl<const N: usize> Product<$type, N> {
110            /// Multiply for the product.
111            pub const fn mul(self) -> $type {
112                let mut ret = <$type>::MAX;
113                let mut i = 0;
114
115                loop {
116                    if i >= N {
117                        break ret;
118                    }
119
120                    ret.int_multiply(self.0[i]);
121                    i += 1;
122                }
123            }
124        }
125    };
126}
127
128#[cfg(any(feature = "signed", feature = "unsigned"))]
129macro_rules! float_channel {
130    ($type:ty) => {
131        impl<const N: usize> Sum<$type, N> {
132            /// Add up the sum.
133            pub const fn add(self) -> $type {
134                let mut ret = 0.0;
135                let mut i = 0;
136
137                loop {
138                    if i >= N {
139                        break <$type>::new(ret);
140                    }
141
142                    let value = self.0[i];
143
144                    ret += value.into_inner();
145                    i += 1;
146                }
147            }
148        }
149
150        impl<const N: usize> Difference<$type, N> {
151            /// Subtract to get the difference.
152            pub const fn sub(self) -> $type {
153                let mut ret = self.0.into_inner();
154                let mut i = 0;
155
156                loop {
157                    if i >= N {
158                        break <$type>::new(ret);
159                    }
160
161                    let value = self.1[i];
162
163                    ret -= value.into_inner();
164                    i += 1;
165                }
166            }
167        }
168
169        impl<const N: usize> Product<$type, N> {
170            /// Multiply for the product.
171            pub const fn mul(self) -> $type {
172                let mut ret = 1.0;
173                let mut i = 0;
174
175                loop {
176                    if i >= N {
177                        break <$type>::new(ret);
178                    }
179
180                    let value = self.0[i];
181
182                    ret *= value.into_inner();
183                    i += 1;
184                }
185            }
186        }
187
188        impl Negation<$type> {
189            /// Negate the value.
190            pub const fn neg(self) -> $type {
191                <$type>::new(-self.0.into_inner())
192            }
193        }
194    };
195}
196
197#[cfg(feature = "unsigned")]
198mod unsigned {
199    use super::*;
200    use crate::unsigned::{Ch8, Ch12, Ch16, Ch24, Ch32, Ch64};
201
202    int_channel!(Ch8);
203    int_channel!(Ch12);
204    int_channel!(Ch16);
205    int_channel!(Ch24);
206    float_channel!(Ch32);
207    float_channel!(Ch64);
208
209    impl Inversion<Ch32> {
210        /// Invert the value.
211        pub const fn inv(self) -> Ch32 {
212            Ch32::new(1.0 - self.0.into_inner())
213        }
214    }
215
216    impl Inversion<Ch64> {
217        /// Invert the value.
218        pub const fn inv(self) -> Ch64 {
219            Ch64::new(1.0 - self.0.into_inner())
220        }
221    }
222
223    impl Inversion<Ch8> {
224        /// Invert the value.
225        pub const fn inv(self) -> Ch8 {
226            Ch8::new(Ch8::MAX.into_inner() - self.0.into_inner())
227        }
228    }
229
230    impl Inversion<Ch12> {
231        /// Invert the value.
232        pub const fn inv(self) -> Ch12 {
233            Ch12::new(Ch12::MAX.into_inner() - self.0.into_inner())
234        }
235    }
236
237    impl Inversion<Ch16> {
238        /// Invert the value.
239        pub const fn inv(self) -> Ch16 {
240            Ch16::new(Ch16::MAX.into_inner() - self.0.into_inner())
241        }
242    }
243
244    impl Inversion<Ch24> {
245        /// Invert the value.
246        pub const fn inv(self) -> Ch24 {
247            Ch24::new(Ch24::MAX.into_inner() - self.0.into_inner())
248        }
249    }
250
251    impl Negation<Ch8> {
252        /// Negate the value.
253        pub const fn neg(self) -> Ch8 {
254            Ch8::new(Ch8::MAX.into_inner() - self.0.into_inner())
255        }
256    }
257
258    impl Negation<Ch12> {
259        /// Negate the value.
260        pub const fn neg(self) -> Ch12 {
261            Ch12::new(Ch12::MAX.into_inner() - self.0.into_inner())
262        }
263    }
264
265    impl Negation<Ch16> {
266        /// Negate the value.
267        pub const fn neg(self) -> Ch16 {
268            Ch16::new(Ch16::MAX.into_inner() - self.0.into_inner())
269        }
270    }
271
272    impl Negation<Ch24> {
273        /// Negate the value.
274        pub const fn neg(self) -> Ch24 {
275            Ch24::new(Ch24::MAX.into_inner() - self.0.into_inner())
276        }
277    }
278
279    impl Conversion<Ch8, Ch12> {
280        /// Convert between types.
281        pub const fn conv(value: Ch8) -> Ch12 {
282            let value = crate::upscale::u8_to_u32(value.into_inner());
283
284            Ch12::new(crate::downscale::u32_to_u12(value))
285        }
286    }
287
288    impl Conversion<Ch8, Ch16> {
289        /// Convert between types.
290        pub const fn conv(value: Ch8) -> Ch16 {
291            let value = crate::upscale::u8_to_u32(value.into_inner());
292
293            Ch16::new(crate::downscale::u32_to_u16(value))
294        }
295    }
296
297    impl Conversion<Ch8, Ch24> {
298        /// Convert between types.
299        pub const fn conv(value: Ch8) -> Ch24 {
300            let value = crate::upscale::u8_to_u32(value.into_inner());
301
302            Ch24::new(crate::downscale::u32_to_u24(value))
303        }
304    }
305
306    impl Conversion<Ch8, Ch32> {
307        /// Convert between types.
308        pub const fn conv(value: Ch8) -> Ch32 {
309            let value = crate::upscale::u8_to_u32(value.into_inner());
310
311            Ch32::new(crate::convert::u32_to_f32(value))
312        }
313    }
314
315    impl Conversion<Ch8, Ch64> {
316        /// Convert between types.
317        pub const fn conv(value: Ch8) -> Ch64 {
318            let value = crate::upscale::u8_to_u64(value.into_inner());
319
320            Ch64::new(crate::convert::u64_to_f64(value))
321        }
322    }
323
324    impl Conversion<Ch12, Ch8> {
325        /// Convert between types.
326        pub const fn conv(value: Ch12) -> Ch8 {
327            let value = crate::upscale::u12_to_u32(value.into_inner());
328
329            Ch8::new(crate::downscale::u32_to_u8(value))
330        }
331    }
332
333    impl Conversion<Ch12, Ch16> {
334        /// Convert between types.
335        pub const fn conv(value: Ch12) -> Ch16 {
336            let value = crate::upscale::u12_to_u32(value.into_inner());
337
338            Ch16::new(crate::downscale::u32_to_u16(value))
339        }
340    }
341
342    impl Conversion<Ch12, Ch24> {
343        /// Convert between types.
344        pub const fn conv(value: Ch12) -> Ch24 {
345            let value = crate::upscale::u12_to_u32(value.into_inner());
346
347            Ch24::new(crate::downscale::u32_to_u24(value))
348        }
349    }
350
351    impl Conversion<Ch12, Ch32> {
352        /// Convert between types.
353        pub const fn conv(value: Ch12) -> Ch32 {
354            let value = crate::upscale::u12_to_u32(value.into_inner());
355
356            Ch32::new(crate::convert::u32_to_f32(value))
357        }
358    }
359
360    impl Conversion<Ch12, Ch64> {
361        /// Convert between types.
362        pub const fn conv(value: Ch12) -> Ch64 {
363            let value = crate::upscale::u12_to_u64(value.into_inner());
364
365            Ch64::new(crate::convert::u64_to_f64(value))
366        }
367    }
368
369    impl Conversion<Ch16, Ch8> {
370        /// Convert between types.
371        pub const fn conv(value: Ch16) -> Ch8 {
372            let value = crate::upscale::u16_to_u32(value.into_inner());
373
374            Ch8::new(crate::downscale::u32_to_u8(value))
375        }
376    }
377
378    impl Conversion<Ch16, Ch12> {
379        /// Convert between types.
380        pub const fn conv(value: Ch16) -> Ch12 {
381            let value = crate::upscale::u16_to_u32(value.into_inner());
382
383            Ch12::new(crate::downscale::u32_to_u12(value))
384        }
385    }
386
387    impl Conversion<Ch16, Ch24> {
388        /// Convert between types.
389        pub const fn conv(value: Ch16) -> Ch24 {
390            let value = crate::upscale::u16_to_u32(value.into_inner());
391
392            Ch24::new(crate::downscale::u32_to_u24(value))
393        }
394    }
395
396    impl Conversion<Ch16, Ch32> {
397        /// Convert between types.
398        pub const fn conv(value: Ch16) -> Ch32 {
399            let value = crate::upscale::u16_to_u32(value.into_inner());
400
401            Ch32::new(crate::convert::u32_to_f32(value))
402        }
403    }
404
405    impl Conversion<Ch16, Ch64> {
406        /// Convert between types.
407        pub const fn conv(value: Ch16) -> Ch64 {
408            let value = crate::upscale::u16_to_u64(value.into_inner());
409
410            Ch64::new(crate::convert::u64_to_f64(value))
411        }
412    }
413
414    impl Conversion<Ch24, Ch8> {
415        /// Convert between types.
416        pub const fn conv(value: Ch24) -> Ch8 {
417            let value = crate::upscale::u24_to_u32(value.into_inner());
418
419            Ch8::new(crate::downscale::u32_to_u8(value))
420        }
421    }
422
423    impl Conversion<Ch24, Ch12> {
424        /// Convert between types.
425        pub const fn conv(value: Ch24) -> Ch12 {
426            let value = crate::upscale::u24_to_u32(value.into_inner());
427
428            Ch12::new(crate::downscale::u32_to_u12(value))
429        }
430    }
431
432    impl Conversion<Ch24, Ch16> {
433        /// Convert between types.
434        pub const fn conv(value: Ch24) -> Ch16 {
435            let value = crate::upscale::u24_to_u32(value.into_inner());
436
437            Ch16::new(crate::downscale::u32_to_u16(value))
438        }
439    }
440
441    impl Conversion<Ch24, Ch32> {
442        /// Convert between types.
443        pub const fn conv(value: Ch24) -> Ch32 {
444            let value = crate::upscale::u24_to_u32(value.into_inner());
445
446            Ch32::new(crate::convert::u32_to_f32(value))
447        }
448    }
449
450    impl Conversion<Ch24, Ch64> {
451        /// Convert between types.
452        pub const fn conv(value: Ch24) -> Ch64 {
453            let value = crate::upscale::u24_to_u64(value.into_inner());
454
455            Ch64::new(crate::convert::u64_to_f64(value))
456        }
457    }
458
459    impl Conversion<Ch32, Ch8> {
460        /// Convert between types.
461        pub const fn conv(value: Ch32) -> Ch8 {
462            let value = crate::convert::f32_to_u32(value.into_inner());
463
464            Ch8::new(crate::downscale::u32_to_u8(value))
465        }
466    }
467
468    impl Conversion<Ch32, Ch12> {
469        /// Convert between types.
470        pub const fn conv(value: Ch32) -> Ch12 {
471            let value = crate::convert::f32_to_u32(value.into_inner());
472
473            Ch12::new(crate::downscale::u32_to_u12(value))
474        }
475    }
476
477    impl Conversion<Ch32, Ch16> {
478        /// Convert between types.
479        pub const fn conv(value: Ch32) -> Ch16 {
480            let value = crate::convert::f32_to_u32(value.into_inner());
481
482            Ch16::new(crate::downscale::u32_to_u16(value))
483        }
484    }
485
486    impl Conversion<Ch32, Ch24> {
487        /// Convert between types.
488        pub const fn conv(value: Ch32) -> Ch24 {
489            let value = crate::convert::f32_to_u32(value.into_inner());
490
491            Ch24::new(crate::downscale::u32_to_u24(value))
492        }
493    }
494
495    impl Conversion<Ch32, Ch64> {
496        /// Convert between types.
497        pub const fn conv(value: Ch32) -> Ch64 {
498            let value = crate::upscale::f32_to_f64(value.into_inner());
499
500            Ch64::new(value)
501        }
502    }
503
504    impl Conversion<Ch64, Ch8> {
505        /// Convert between types.
506        pub const fn conv(value: Ch64) -> Ch8 {
507            let value = crate::convert::f64_to_u64(value.into_inner());
508
509            Ch8::new(crate::downscale::u64_to_u8(value))
510        }
511    }
512
513    impl Conversion<Ch64, Ch12> {
514        /// Convert between types.
515        pub const fn conv(value: Ch64) -> Ch12 {
516            let value = crate::convert::f64_to_u64(value.into_inner());
517
518            Ch12::new(crate::downscale::u64_to_u12(value))
519        }
520    }
521
522    impl Conversion<Ch64, Ch16> {
523        /// Convert between types.
524        pub const fn conv(value: Ch64) -> Ch16 {
525            let value = crate::convert::f64_to_u64(value.into_inner());
526
527            Ch16::new(crate::downscale::u64_to_u16(value))
528        }
529    }
530
531    impl Conversion<Ch64, Ch24> {
532        /// Convert between types.
533        pub const fn conv(value: Ch64) -> Ch24 {
534            let value = crate::convert::f64_to_u64(value.into_inner());
535
536            Ch24::new(crate::downscale::u64_to_u24(value))
537        }
538    }
539
540    impl Conversion<Ch64, Ch32> {
541        /// Convert between types.
542        pub const fn conv(value: Ch64) -> Ch32 {
543            let value = crate::downscale::f64_to_f32(value.into_inner());
544
545            Ch32::new(value)
546        }
547    }
548
549    #[cfg(feature = "signed")]
550    mod signed {
551        use super::*;
552        use crate::signed;
553
554        impl Conversion<signed::Ch8, Ch8> {
555            /// Convert between types.
556            pub const fn conv(value: signed::Ch8) -> Ch8 {
557                let value = crate::upscale::i8_to_i32(value.into_inner());
558                let value = crate::convert::i32_to_u32(value);
559
560                Ch8::new(crate::downscale::u32_to_u8(value))
561            }
562        }
563
564        impl Conversion<signed::Ch12, Ch12> {
565            /// Convert between types.
566            pub const fn conv(value: signed::Ch12) -> Ch12 {
567                let value = crate::upscale::i12_to_i32(value.into_inner());
568                let value = crate::convert::i32_to_u32(value);
569
570                Ch12::new(crate::downscale::u32_to_u12(value))
571            }
572        }
573
574        impl Conversion<signed::Ch16, Ch16> {
575            /// Convert between types.
576            pub const fn conv(value: signed::Ch16) -> Ch16 {
577                let value = crate::upscale::i16_to_i32(value.into_inner());
578                let value = crate::convert::i32_to_u32(value);
579
580                Ch16::new(crate::downscale::u32_to_u16(value))
581            }
582        }
583
584        impl Conversion<signed::Ch24, Ch24> {
585            /// Convert between types.
586            pub const fn conv(value: signed::Ch24) -> Ch24 {
587                let value = crate::upscale::i24_to_i32(value.into_inner());
588                let value = crate::convert::i32_to_u32(value);
589
590                Ch24::new(crate::downscale::u32_to_u24(value))
591            }
592        }
593
594        impl Conversion<signed::Ch32, Ch32> {
595            /// Convert between types.
596            pub const fn conv(value: signed::Ch32) -> Ch32 {
597                let value = crate::convert::f32_to_i32(value.into_inner());
598                let value = crate::convert::i32_to_u32(value);
599
600                Ch32::new(crate::convert::u32_to_f32(value))
601            }
602        }
603
604        impl Conversion<signed::Ch64, Ch64> {
605            /// Convert between types.
606            pub const fn conv(value: signed::Ch64) -> Ch64 {
607                let value = crate::convert::f64_to_i64(value.into_inner());
608                let value = crate::convert::i64_to_u64(value);
609
610                Ch64::new(crate::convert::u64_to_f64(value))
611            }
612        }
613
614        impl Conversion<signed::Ch8, Ch12> {
615            /// Convert between types.
616            pub const fn conv(value: signed::Ch8) -> Ch12 {
617                let value = crate::upscale::i8_to_i32(value.into_inner());
618                let value = crate::convert::i32_to_u32(value);
619
620                Ch12::new(crate::downscale::u32_to_u12(value))
621            }
622        }
623
624        impl Conversion<signed::Ch8, Ch16> {
625            /// Convert between types.
626            pub const fn conv(value: signed::Ch8) -> Ch16 {
627                let value = crate::upscale::i8_to_i32(value.into_inner());
628                let value = crate::convert::i32_to_u32(value);
629
630                Ch16::new(crate::downscale::u32_to_u16(value))
631            }
632        }
633
634        impl Conversion<signed::Ch8, Ch24> {
635            /// Convert between types.
636            pub const fn conv(value: signed::Ch8) -> Ch24 {
637                let value = crate::upscale::i8_to_i32(value.into_inner());
638                let value = crate::convert::i32_to_u32(value);
639
640                Ch24::new(crate::downscale::u32_to_u24(value))
641            }
642        }
643
644        impl Conversion<signed::Ch8, Ch32> {
645            /// Convert between types.
646            pub const fn conv(value: signed::Ch8) -> Ch32 {
647                let value = crate::upscale::i8_to_i32(value.into_inner());
648                let value = crate::convert::i32_to_u32(value);
649
650                Ch32::new(crate::convert::u32_to_f32(value))
651            }
652        }
653
654        impl Conversion<signed::Ch8, Ch64> {
655            /// Convert between types.
656            pub const fn conv(value: signed::Ch8) -> Ch64 {
657                let value = crate::upscale::i8_to_i64(value.into_inner());
658                let value = crate::convert::i64_to_u64(value);
659
660                Ch64::new(crate::convert::u64_to_f64(value))
661            }
662        }
663
664        impl Conversion<signed::Ch12, Ch8> {
665            /// Convert between types.
666            pub const fn conv(value: signed::Ch12) -> Ch8 {
667                let value = crate::upscale::i12_to_i32(value.into_inner());
668                let value = crate::convert::i32_to_u32(value);
669
670                Ch8::new(crate::downscale::u32_to_u8(value))
671            }
672        }
673
674        impl Conversion<signed::Ch12, Ch16> {
675            /// Convert between types.
676            pub const fn conv(value: signed::Ch12) -> Ch16 {
677                let value = crate::upscale::i12_to_i32(value.into_inner());
678                let value = crate::convert::i32_to_u32(value);
679
680                Ch16::new(crate::downscale::u32_to_u16(value))
681            }
682        }
683
684        impl Conversion<signed::Ch12, Ch24> {
685            /// Convert between types.
686            pub const fn conv(value: signed::Ch12) -> Ch24 {
687                let value = crate::upscale::i12_to_i32(value.into_inner());
688                let value = crate::convert::i32_to_u32(value);
689
690                Ch24::new(crate::downscale::u32_to_u24(value))
691            }
692        }
693
694        impl Conversion<signed::Ch12, Ch32> {
695            /// Convert between types.
696            pub const fn conv(value: signed::Ch12) -> Ch32 {
697                let value = crate::upscale::i12_to_i32(value.into_inner());
698                let value = crate::convert::i32_to_u32(value);
699
700                Ch32::new(crate::convert::u32_to_f32(value))
701            }
702        }
703
704        impl Conversion<signed::Ch12, Ch64> {
705            /// Convert between types.
706            pub const fn conv(value: signed::Ch12) -> Ch64 {
707                let value = crate::upscale::i12_to_i64(value.into_inner());
708                let value = crate::convert::i64_to_u64(value);
709
710                Ch64::new(crate::convert::u64_to_f64(value))
711            }
712        }
713
714        impl Conversion<signed::Ch16, Ch8> {
715            /// Convert between types.
716            pub const fn conv(value: signed::Ch16) -> Ch8 {
717                let value = crate::upscale::i16_to_i32(value.into_inner());
718                let value = crate::convert::i32_to_u32(value);
719
720                Ch8::new(crate::downscale::u32_to_u8(value))
721            }
722        }
723
724        impl Conversion<signed::Ch16, Ch12> {
725            /// Convert between types.
726            pub const fn conv(value: signed::Ch16) -> Ch12 {
727                let value = crate::upscale::i16_to_i32(value.into_inner());
728                let value = crate::convert::i32_to_u32(value);
729
730                Ch12::new(crate::downscale::u32_to_u12(value))
731            }
732        }
733
734        impl Conversion<signed::Ch16, Ch24> {
735            /// Convert between types.
736            pub const fn conv(value: signed::Ch16) -> Ch24 {
737                let value = crate::upscale::i16_to_i32(value.into_inner());
738                let value = crate::convert::i32_to_u32(value);
739
740                Ch24::new(crate::downscale::u32_to_u24(value))
741            }
742        }
743
744        impl Conversion<signed::Ch16, Ch32> {
745            /// Convert between types.
746            pub const fn conv(value: signed::Ch16) -> Ch32 {
747                let value = crate::upscale::i16_to_i32(value.into_inner());
748                let value = crate::convert::i32_to_u32(value);
749
750                Ch32::new(crate::convert::u32_to_f32(value))
751            }
752        }
753
754        impl Conversion<signed::Ch16, Ch64> {
755            /// Convert between types.
756            pub const fn conv(value: signed::Ch16) -> Ch64 {
757                let value = crate::upscale::i16_to_i64(value.into_inner());
758                let value = crate::convert::i64_to_u64(value);
759
760                Ch64::new(crate::convert::u64_to_f64(value))
761            }
762        }
763
764        impl Conversion<signed::Ch24, Ch8> {
765            /// Convert between types.
766            pub const fn conv(value: signed::Ch24) -> Ch8 {
767                let value = crate::upscale::i24_to_i32(value.into_inner());
768                let value = crate::convert::i32_to_u32(value);
769
770                Ch8::new(crate::downscale::u32_to_u8(value))
771            }
772        }
773
774        impl Conversion<signed::Ch24, Ch12> {
775            /// Convert between types.
776            pub const fn conv(value: signed::Ch24) -> Ch12 {
777                let value = crate::upscale::i24_to_i32(value.into_inner());
778                let value = crate::convert::i32_to_u32(value);
779
780                Ch12::new(crate::downscale::u32_to_u12(value))
781            }
782        }
783
784        impl Conversion<signed::Ch24, Ch16> {
785            /// Convert between types.
786            pub const fn conv(value: signed::Ch24) -> Ch16 {
787                let value = crate::upscale::i24_to_i32(value.into_inner());
788                let value = crate::convert::i32_to_u32(value);
789
790                Ch16::new(crate::downscale::u32_to_u16(value))
791            }
792        }
793
794        impl Conversion<signed::Ch24, Ch32> {
795            /// Convert between types.
796            pub const fn conv(value: signed::Ch24) -> Ch32 {
797                let value = crate::upscale::i24_to_i32(value.into_inner());
798                let value = crate::convert::i32_to_u32(value);
799
800                Ch32::new(crate::convert::u32_to_f32(value))
801            }
802        }
803
804        impl Conversion<signed::Ch24, Ch64> {
805            /// Convert between types.
806            pub const fn conv(value: signed::Ch24) -> Ch64 {
807                let value = crate::upscale::i24_to_i64(value.into_inner());
808                let value = crate::convert::i64_to_u64(value);
809
810                Ch64::new(crate::convert::u64_to_f64(value))
811            }
812        }
813
814        impl Conversion<signed::Ch32, Ch8> {
815            /// Convert between types.
816            pub const fn conv(value: signed::Ch32) -> Ch8 {
817                let value = crate::convert::f32_to_i32(value.into_inner());
818                let value = crate::convert::i32_to_u32(value);
819
820                Ch8::new(crate::downscale::u32_to_u8(value))
821            }
822        }
823
824        impl Conversion<signed::Ch32, Ch12> {
825            /// Convert between types.
826            pub const fn conv(value: signed::Ch32) -> Ch12 {
827                let value = crate::convert::f32_to_i32(value.into_inner());
828                let value = crate::convert::i32_to_u32(value);
829
830                Ch12::new(crate::downscale::u32_to_u12(value))
831            }
832        }
833
834        impl Conversion<signed::Ch32, Ch16> {
835            /// Convert between types.
836            pub const fn conv(value: signed::Ch32) -> Ch16 {
837                let value = crate::convert::f32_to_i32(value.into_inner());
838                let value = crate::convert::i32_to_u32(value);
839
840                Ch16::new(crate::downscale::u32_to_u16(value))
841            }
842        }
843
844        impl Conversion<signed::Ch32, Ch24> {
845            /// Convert between types.
846            pub const fn conv(value: signed::Ch32) -> Ch24 {
847                let value = crate::convert::f32_to_i32(value.into_inner());
848                let value = crate::convert::i32_to_u32(value);
849
850                Ch24::new(crate::downscale::u32_to_u24(value))
851            }
852        }
853
854        impl Conversion<signed::Ch32, Ch64> {
855            /// Convert between types.
856            pub const fn conv(value: signed::Ch32) -> Ch64 {
857                let value = crate::upscale::f32_to_f64(value.into_inner());
858                let value = crate::convert::f64_to_i64(value);
859                let value = crate::convert::i64_to_u64(value);
860
861                Ch64::new(crate::convert::u64_to_f64(value))
862            }
863        }
864
865        impl Conversion<signed::Ch64, Ch8> {
866            /// Convert between types.
867            pub const fn conv(value: signed::Ch64) -> Ch8 {
868                let value = crate::convert::f64_to_i64(value.into_inner());
869                let value = crate::convert::i64_to_u64(value);
870
871                Ch8::new(crate::downscale::u64_to_u8(value))
872            }
873        }
874
875        impl Conversion<signed::Ch64, Ch12> {
876            /// Convert between types.
877            pub const fn conv(value: signed::Ch64) -> Ch12 {
878                let value = crate::convert::f64_to_i64(value.into_inner());
879                let value = crate::convert::i64_to_u64(value);
880
881                Ch12::new(crate::downscale::u64_to_u12(value))
882            }
883        }
884
885        impl Conversion<signed::Ch64, Ch16> {
886            /// Convert between types.
887            pub const fn conv(value: signed::Ch64) -> Ch16 {
888                let value = crate::convert::f64_to_i64(value.into_inner());
889                let value = crate::convert::i64_to_u64(value);
890
891                Ch16::new(crate::downscale::u64_to_u16(value))
892            }
893        }
894
895        impl Conversion<signed::Ch64, Ch24> {
896            /// Convert between types.
897            pub const fn conv(value: signed::Ch64) -> Ch24 {
898                let value = crate::convert::f64_to_i64(value.into_inner());
899                let value = crate::convert::i64_to_u64(value);
900
901                Ch24::new(crate::downscale::u64_to_u24(value))
902            }
903        }
904
905        impl Conversion<signed::Ch64, Ch32> {
906            /// Convert between types.
907            pub const fn conv(value: signed::Ch64) -> Ch32 {
908                let value = crate::downscale::f64_to_f32(value.into_inner());
909                let value = crate::convert::f32_to_i32(value);
910                let value = crate::convert::i32_to_u32(value);
911
912                Ch32::new(crate::convert::u32_to_f32(value))
913            }
914        }
915    }
916}
917
918#[cfg(feature = "signed")]
919mod signed {
920    use super::*;
921    use crate::signed::{Ch8, Ch12, Ch16, Ch24, Ch32, Ch64};
922
923    int_channel!(Ch8);
924    int_channel!(Ch12);
925    int_channel!(Ch16);
926    int_channel!(Ch24);
927    float_channel!(Ch32);
928    float_channel!(Ch64);
929
930    impl Inversion<Ch32> {
931        /// Invert the value.
932        pub const fn inv(self) -> Ch32 {
933            Ch32::new(-self.0.into_inner())
934        }
935    }
936
937    impl Inversion<Ch64> {
938        /// Invert the value.
939        pub const fn inv(self) -> Ch64 {
940            Ch64::new(-self.0.into_inner())
941        }
942    }
943
944    impl Inversion<Ch8> {
945        /// Invert the value.
946        pub const fn inv(self) -> Ch8 {
947            Ch8::new(-1 - self.0.into_inner())
948        }
949    }
950
951    impl Inversion<Ch12> {
952        /// Invert the value.
953        pub const fn inv(self) -> Ch12 {
954            Ch12::new(-1 - self.0.into_inner())
955        }
956    }
957
958    impl Inversion<Ch16> {
959        /// Invert the value.
960        pub const fn inv(self) -> Ch16 {
961            Ch16::new(-1 - self.0.into_inner())
962        }
963    }
964
965    impl Inversion<Ch24> {
966        /// Invert the value.
967        pub const fn inv(self) -> Ch24 {
968            Ch24::new(-1 - self.0.into_inner())
969        }
970    }
971
972    impl Negation<Ch8> {
973        /// Negate the value.
974        pub const fn neg(self) -> Ch8 {
975            Ch8::new(-1 - self.0.into_inner())
976        }
977    }
978
979    impl Negation<Ch12> {
980        /// Negate the value.
981        pub const fn neg(self) -> Ch12 {
982            Ch12::new(-1 - self.0.into_inner())
983        }
984    }
985
986    impl Negation<Ch16> {
987        /// Negate the value.
988        pub const fn neg(self) -> Ch16 {
989            Ch16::new(-1 - self.0.into_inner())
990        }
991    }
992
993    impl Negation<Ch24> {
994        /// Negate the value.
995        pub const fn neg(self) -> Ch24 {
996            Ch24::new(-1 - self.0.into_inner())
997        }
998    }
999
1000    impl Conversion<Ch8, Ch12> {
1001        /// Convert between types.
1002        pub const fn conv(value: Ch8) -> Ch12 {
1003            let value = crate::upscale::i8_to_i32(value.into_inner());
1004
1005            Ch12::new(crate::downscale::i32_to_i12(value))
1006        }
1007    }
1008
1009    impl Conversion<Ch8, Ch16> {
1010        /// Convert between types.
1011        pub const fn conv(value: Ch8) -> Ch16 {
1012            let value = crate::upscale::i8_to_i32(value.into_inner());
1013
1014            Ch16::new(crate::downscale::i32_to_i16(value))
1015        }
1016    }
1017
1018    impl Conversion<Ch8, Ch24> {
1019        /// Convert between types.
1020        pub const fn conv(value: Ch8) -> Ch24 {
1021            let value = crate::upscale::i8_to_i32(value.into_inner());
1022
1023            Ch24::new(crate::downscale::i32_to_i24(value))
1024        }
1025    }
1026
1027    impl Conversion<Ch8, Ch32> {
1028        /// Convert between types.
1029        pub const fn conv(value: Ch8) -> Ch32 {
1030            let value = crate::upscale::i8_to_i32(value.into_inner());
1031
1032            Ch32::new(crate::convert::i32_to_f32(value))
1033        }
1034    }
1035
1036    impl Conversion<Ch8, Ch64> {
1037        /// Convert between types.
1038        pub const fn conv(value: Ch8) -> Ch64 {
1039            let value = crate::upscale::i8_to_i64(value.into_inner());
1040
1041            Ch64::new(crate::convert::i64_to_f64(value))
1042        }
1043    }
1044
1045    impl Conversion<Ch12, Ch8> {
1046        /// Convert between types.
1047        pub const fn conv(value: Ch12) -> Ch8 {
1048            let value = crate::upscale::i12_to_i32(value.into_inner());
1049
1050            Ch8::new(crate::downscale::i32_to_i8(value))
1051        }
1052    }
1053
1054    impl Conversion<Ch12, Ch16> {
1055        /// Convert between types.
1056        pub const fn conv(value: Ch12) -> Ch16 {
1057            let value = crate::upscale::i12_to_i32(value.into_inner());
1058
1059            Ch16::new(crate::downscale::i32_to_i16(value))
1060        }
1061    }
1062
1063    impl Conversion<Ch12, Ch24> {
1064        /// Convert between types.
1065        pub const fn conv(value: Ch12) -> Ch24 {
1066            let value = crate::upscale::i12_to_i32(value.into_inner());
1067
1068            Ch24::new(crate::downscale::i32_to_i24(value))
1069        }
1070    }
1071
1072    impl Conversion<Ch12, Ch32> {
1073        /// Convert between types.
1074        pub const fn conv(value: Ch12) -> Ch32 {
1075            let value = crate::upscale::i12_to_i32(value.into_inner());
1076
1077            Ch32::new(crate::convert::i32_to_f32(value))
1078        }
1079    }
1080
1081    impl Conversion<Ch12, Ch64> {
1082        /// Convert between types.
1083        pub const fn conv(value: Ch12) -> Ch64 {
1084            let value = crate::upscale::i12_to_i64(value.into_inner());
1085
1086            Ch64::new(crate::convert::i64_to_f64(value))
1087        }
1088    }
1089
1090    impl Conversion<Ch16, Ch8> {
1091        /// Convert between types.
1092        pub const fn conv(value: Ch16) -> Ch8 {
1093            let value = crate::upscale::i16_to_i32(value.into_inner());
1094
1095            Ch8::new(crate::downscale::i32_to_i8(value))
1096        }
1097    }
1098
1099    impl Conversion<Ch16, Ch12> {
1100        /// Convert between types.
1101        pub const fn conv(value: Ch16) -> Ch12 {
1102            let value = crate::upscale::i16_to_i32(value.into_inner());
1103
1104            Ch12::new(crate::downscale::i32_to_i12(value))
1105        }
1106    }
1107
1108    impl Conversion<Ch16, Ch24> {
1109        /// Convert between types.
1110        pub const fn conv(value: Ch16) -> Ch24 {
1111            let value = crate::upscale::i16_to_i32(value.into_inner());
1112
1113            Ch24::new(crate::downscale::i32_to_i24(value))
1114        }
1115    }
1116
1117    impl Conversion<Ch16, Ch32> {
1118        /// Convert between types.
1119        pub const fn conv(value: Ch16) -> Ch32 {
1120            let value = crate::upscale::i16_to_i32(value.into_inner());
1121
1122            Ch32::new(crate::convert::i32_to_f32(value))
1123        }
1124    }
1125
1126    impl Conversion<Ch16, Ch64> {
1127        /// Convert between types.
1128        pub const fn conv(value: Ch16) -> Ch64 {
1129            let value = crate::upscale::i16_to_i64(value.into_inner());
1130
1131            Ch64::new(crate::convert::i64_to_f64(value))
1132        }
1133    }
1134
1135    impl Conversion<Ch24, Ch8> {
1136        /// Convert between types.
1137        pub const fn conv(value: Ch24) -> Ch8 {
1138            let value = crate::upscale::i24_to_i32(value.into_inner());
1139
1140            Ch8::new(crate::downscale::i32_to_i8(value))
1141        }
1142    }
1143
1144    impl Conversion<Ch24, Ch12> {
1145        /// Convert between types.
1146        pub const fn conv(value: Ch24) -> Ch12 {
1147            let value = crate::upscale::i24_to_i32(value.into_inner());
1148
1149            Ch12::new(crate::downscale::i32_to_i12(value))
1150        }
1151    }
1152
1153    impl Conversion<Ch24, Ch16> {
1154        /// Convert between types.
1155        pub const fn conv(value: Ch24) -> Ch16 {
1156            let value = crate::upscale::i24_to_i32(value.into_inner());
1157
1158            Ch16::new(crate::downscale::i32_to_i16(value))
1159        }
1160    }
1161
1162    impl Conversion<Ch24, Ch32> {
1163        /// Convert between types.
1164        pub const fn conv(value: Ch24) -> Ch32 {
1165            let value = crate::upscale::i24_to_i32(value.into_inner());
1166
1167            Ch32::new(crate::convert::i32_to_f32(value))
1168        }
1169    }
1170
1171    impl Conversion<Ch24, Ch64> {
1172        /// Convert between types.
1173        pub const fn conv(value: Ch24) -> Ch64 {
1174            let value = crate::upscale::i24_to_i64(value.into_inner());
1175
1176            Ch64::new(crate::convert::i64_to_f64(value))
1177        }
1178    }
1179
1180    impl Conversion<Ch32, Ch8> {
1181        /// Convert between types.
1182        pub const fn conv(value: Ch32) -> Ch8 {
1183            let value = crate::convert::f32_to_i32(value.into_inner());
1184
1185            Ch8::new(crate::downscale::i32_to_i8(value))
1186        }
1187    }
1188
1189    impl Conversion<Ch32, Ch12> {
1190        /// Convert between types.
1191        pub const fn conv(value: Ch32) -> Ch12 {
1192            let value = crate::convert::f32_to_i32(value.into_inner());
1193
1194            Ch12::new(crate::downscale::i32_to_i12(value))
1195        }
1196    }
1197
1198    impl Conversion<Ch32, Ch16> {
1199        /// Convert between types.
1200        pub const fn conv(value: Ch32) -> Ch16 {
1201            let value = crate::convert::f32_to_i32(value.into_inner());
1202
1203            Ch16::new(crate::downscale::i32_to_i16(value))
1204        }
1205    }
1206
1207    impl Conversion<Ch32, Ch24> {
1208        /// Convert between types.
1209        pub const fn conv(value: Ch32) -> Ch24 {
1210            let value = crate::convert::f32_to_i32(value.into_inner());
1211
1212            Ch24::new(crate::downscale::i32_to_i24(value))
1213        }
1214    }
1215
1216    impl Conversion<Ch32, Ch64> {
1217        /// Convert between types.
1218        pub const fn conv(value: Ch32) -> Ch64 {
1219            let value = crate::upscale::f32_to_f64(value.into_inner());
1220
1221            Ch64::new(value)
1222        }
1223    }
1224
1225    impl Conversion<Ch64, Ch8> {
1226        /// Convert between types.
1227        pub const fn conv(value: Ch64) -> Ch8 {
1228            let value = crate::convert::f64_to_i64(value.into_inner());
1229
1230            Ch8::new(crate::downscale::i64_to_i8(value))
1231        }
1232    }
1233
1234    impl Conversion<Ch64, Ch12> {
1235        /// Convert between types.
1236        pub const fn conv(value: Ch64) -> Ch12 {
1237            let value = crate::convert::f64_to_i64(value.into_inner());
1238
1239            Ch12::new(crate::downscale::i64_to_i12(value))
1240        }
1241    }
1242
1243    impl Conversion<Ch64, Ch16> {
1244        /// Convert between types.
1245        pub const fn conv(value: Ch64) -> Ch16 {
1246            let value = crate::convert::f64_to_i64(value.into_inner());
1247
1248            Ch16::new(crate::downscale::i64_to_i16(value))
1249        }
1250    }
1251
1252    impl Conversion<Ch64, Ch24> {
1253        /// Convert between types.
1254        pub const fn conv(value: Ch64) -> Ch24 {
1255            let value = crate::convert::f64_to_i64(value.into_inner());
1256
1257            Ch24::new(crate::downscale::i64_to_i24(value))
1258        }
1259    }
1260
1261    impl Conversion<Ch64, Ch32> {
1262        /// Convert between types.
1263        pub const fn conv(value: Ch64) -> Ch32 {
1264            let value = crate::downscale::f64_to_f32(value.into_inner());
1265
1266            Ch32::new(value)
1267        }
1268    }
1269
1270    #[cfg(feature = "unsigned")]
1271    mod unsigned {
1272        use super::*;
1273        use crate::unsigned;
1274
1275        impl Conversion<unsigned::Ch8, Ch8> {
1276            /// Convert between types.
1277            pub const fn conv(value: unsigned::Ch8) -> Ch8 {
1278                let value = crate::upscale::u8_to_u32(value.into_inner());
1279                let value = crate::convert::u32_to_i32(value);
1280
1281                Ch8::new(crate::downscale::i32_to_i8(value))
1282            }
1283        }
1284
1285        impl Conversion<unsigned::Ch12, Ch12> {
1286            /// Convert between types.
1287            pub const fn conv(value: unsigned::Ch12) -> Ch12 {
1288                let value = crate::upscale::u12_to_u32(value.into_inner());
1289                let value = crate::convert::u32_to_i32(value);
1290
1291                Ch12::new(crate::downscale::i32_to_i12(value))
1292            }
1293        }
1294
1295        impl Conversion<unsigned::Ch16, Ch16> {
1296            /// Convert between types.
1297            pub const fn conv(value: unsigned::Ch16) -> Ch16 {
1298                let value = crate::upscale::u16_to_u32(value.into_inner());
1299                let value = crate::convert::u32_to_i32(value);
1300
1301                Ch16::new(crate::downscale::i32_to_i16(value))
1302            }
1303        }
1304
1305        impl Conversion<unsigned::Ch24, Ch24> {
1306            /// Convert between types.
1307            pub const fn conv(value: unsigned::Ch24) -> Ch24 {
1308                let value = crate::upscale::u24_to_u32(value.into_inner());
1309                let value = crate::convert::u32_to_i32(value);
1310
1311                Ch24::new(crate::downscale::i32_to_i24(value))
1312            }
1313        }
1314
1315        impl Conversion<unsigned::Ch32, Ch32> {
1316            /// Convert between types.
1317            pub const fn conv(value: unsigned::Ch32) -> Ch32 {
1318                let value = crate::convert::f32_to_u32(value.into_inner());
1319                let value = crate::convert::u32_to_i32(value);
1320
1321                Ch32::new(crate::convert::i32_to_f32(value))
1322            }
1323        }
1324
1325        impl Conversion<unsigned::Ch64, Ch64> {
1326            /// Convert between types.
1327            pub const fn conv(value: unsigned::Ch64) -> Ch64 {
1328                let value = crate::convert::f64_to_u64(value.into_inner());
1329                let value = crate::convert::u64_to_i64(value);
1330
1331                Ch64::new(crate::convert::i64_to_f64(value))
1332            }
1333        }
1334
1335        impl Conversion<unsigned::Ch8, Ch12> {
1336            /// Convert between types.
1337            pub const fn conv(value: unsigned::Ch8) -> Ch12 {
1338                let value = crate::upscale::u8_to_u32(value.into_inner());
1339                let value = crate::convert::u32_to_i32(value);
1340
1341                Ch12::new(crate::downscale::i32_to_i12(value))
1342            }
1343        }
1344
1345        impl Conversion<unsigned::Ch8, Ch16> {
1346            /// Convert between types.
1347            pub const fn conv(value: unsigned::Ch8) -> Ch16 {
1348                let value = crate::upscale::u8_to_u32(value.into_inner());
1349                let value = crate::convert::u32_to_i32(value);
1350
1351                Ch16::new(crate::downscale::i32_to_i16(value))
1352            }
1353        }
1354
1355        impl Conversion<unsigned::Ch8, Ch24> {
1356            /// Convert between types.
1357            pub const fn conv(value: unsigned::Ch8) -> Ch24 {
1358                let value = crate::upscale::u8_to_u32(value.into_inner());
1359                let value = crate::convert::u32_to_i32(value);
1360
1361                Ch24::new(crate::downscale::i32_to_i24(value))
1362            }
1363        }
1364
1365        impl Conversion<unsigned::Ch8, Ch32> {
1366            /// Convert between types.
1367            pub const fn conv(value: unsigned::Ch8) -> Ch32 {
1368                let value = crate::upscale::u8_to_u32(value.into_inner());
1369                let value = crate::convert::u32_to_i32(value);
1370
1371                Ch32::new(crate::convert::i32_to_f32(value))
1372            }
1373        }
1374
1375        impl Conversion<unsigned::Ch8, Ch64> {
1376            /// Convert between types.
1377            pub const fn conv(value: unsigned::Ch8) -> Ch64 {
1378                let value = crate::upscale::u8_to_u64(value.into_inner());
1379                let value = crate::convert::u64_to_i64(value);
1380
1381                Ch64::new(crate::convert::i64_to_f64(value))
1382            }
1383        }
1384
1385        impl Conversion<unsigned::Ch12, Ch8> {
1386            /// Convert between types.
1387            pub const fn conv(value: unsigned::Ch12) -> Ch8 {
1388                let value = crate::upscale::u12_to_u32(value.into_inner());
1389                let value = crate::convert::u32_to_i32(value);
1390
1391                Ch8::new(crate::downscale::i32_to_i8(value))
1392            }
1393        }
1394
1395        impl Conversion<unsigned::Ch12, Ch16> {
1396            /// Convert between types.
1397            pub const fn conv(value: unsigned::Ch12) -> Ch16 {
1398                let value = crate::upscale::u12_to_u32(value.into_inner());
1399                let value = crate::convert::u32_to_i32(value);
1400
1401                Ch16::new(crate::downscale::i32_to_i16(value))
1402            }
1403        }
1404
1405        impl Conversion<unsigned::Ch12, Ch24> {
1406            /// Convert between types.
1407            pub const fn conv(value: unsigned::Ch12) -> Ch24 {
1408                let value = crate::upscale::u12_to_u32(value.into_inner());
1409                let value = crate::convert::u32_to_i32(value);
1410
1411                Ch24::new(crate::downscale::i32_to_i24(value))
1412            }
1413        }
1414
1415        impl Conversion<unsigned::Ch12, Ch32> {
1416            /// Convert between types.
1417            pub const fn conv(value: unsigned::Ch12) -> Ch32 {
1418                let value = crate::upscale::u12_to_u32(value.into_inner());
1419                let value = crate::convert::u32_to_i32(value);
1420
1421                Ch32::new(crate::convert::i32_to_f32(value))
1422            }
1423        }
1424
1425        impl Conversion<unsigned::Ch12, Ch64> {
1426            /// Convert between types.
1427            pub const fn conv(value: unsigned::Ch12) -> Ch64 {
1428                let value = crate::upscale::u12_to_u64(value.into_inner());
1429                let value = crate::convert::u64_to_i64(value);
1430
1431                Ch64::new(crate::convert::i64_to_f64(value))
1432            }
1433        }
1434
1435        impl Conversion<unsigned::Ch16, Ch8> {
1436            /// Convert between types.
1437            pub const fn conv(value: unsigned::Ch16) -> Ch8 {
1438                let value = crate::upscale::u16_to_u32(value.into_inner());
1439                let value = crate::convert::u32_to_i32(value);
1440
1441                Ch8::new(crate::downscale::i32_to_i8(value))
1442            }
1443        }
1444
1445        impl Conversion<unsigned::Ch16, Ch12> {
1446            /// Convert between types.
1447            pub const fn conv(value: unsigned::Ch16) -> Ch12 {
1448                let value = crate::upscale::u16_to_u32(value.into_inner());
1449                let value = crate::convert::u32_to_i32(value);
1450
1451                Ch12::new(crate::downscale::i32_to_i12(value))
1452            }
1453        }
1454
1455        impl Conversion<unsigned::Ch16, Ch24> {
1456            /// Convert between types.
1457            pub const fn conv(value: unsigned::Ch16) -> Ch24 {
1458                let value = crate::upscale::u16_to_u32(value.into_inner());
1459                let value = crate::convert::u32_to_i32(value);
1460
1461                Ch24::new(crate::downscale::i32_to_i24(value))
1462            }
1463        }
1464
1465        impl Conversion<unsigned::Ch16, Ch32> {
1466            /// Convert between types.
1467            pub const fn conv(value: unsigned::Ch16) -> Ch32 {
1468                let value = crate::upscale::u16_to_u32(value.into_inner());
1469                let value = crate::convert::u32_to_i32(value);
1470
1471                Ch32::new(crate::convert::i32_to_f32(value))
1472            }
1473        }
1474
1475        impl Conversion<unsigned::Ch16, Ch64> {
1476            /// Convert between types.
1477            pub const fn conv(value: unsigned::Ch16) -> Ch64 {
1478                let value = crate::upscale::u16_to_u64(value.into_inner());
1479                let value = crate::convert::u64_to_i64(value);
1480
1481                Ch64::new(crate::convert::i64_to_f64(value))
1482            }
1483        }
1484
1485        impl Conversion<unsigned::Ch24, Ch8> {
1486            /// Convert between types.
1487            pub const fn conv(value: unsigned::Ch24) -> Ch8 {
1488                let value = crate::upscale::u24_to_u32(value.into_inner());
1489                let value = crate::convert::u32_to_i32(value);
1490
1491                Ch8::new(crate::downscale::i32_to_i8(value))
1492            }
1493        }
1494
1495        impl Conversion<unsigned::Ch24, Ch12> {
1496            /// Convert between types.
1497            pub const fn conv(value: unsigned::Ch24) -> Ch12 {
1498                let value = crate::upscale::u24_to_u32(value.into_inner());
1499                let value = crate::convert::u32_to_i32(value);
1500
1501                Ch12::new(crate::downscale::i32_to_i12(value))
1502            }
1503        }
1504
1505        impl Conversion<unsigned::Ch24, Ch16> {
1506            /// Convert between types.
1507            pub const fn conv(value: unsigned::Ch24) -> Ch16 {
1508                let value = crate::upscale::u24_to_u32(value.into_inner());
1509                let value = crate::convert::u32_to_i32(value);
1510
1511                Ch16::new(crate::downscale::i32_to_i16(value))
1512            }
1513        }
1514
1515        impl Conversion<unsigned::Ch24, Ch32> {
1516            /// Convert between types.
1517            pub const fn conv(value: unsigned::Ch24) -> Ch32 {
1518                let value = crate::upscale::u24_to_u32(value.into_inner());
1519                let value = crate::convert::u32_to_i32(value);
1520
1521                Ch32::new(crate::convert::i32_to_f32(value))
1522            }
1523        }
1524
1525        impl Conversion<unsigned::Ch24, Ch64> {
1526            /// Convert between types.
1527            pub const fn conv(value: unsigned::Ch24) -> Ch64 {
1528                let value = crate::upscale::u24_to_u64(value.into_inner());
1529                let value = crate::convert::u64_to_i64(value);
1530
1531                Ch64::new(crate::convert::i64_to_f64(value))
1532            }
1533        }
1534
1535        impl Conversion<unsigned::Ch32, Ch8> {
1536            /// Convert between types.
1537            pub const fn conv(value: unsigned::Ch32) -> Ch8 {
1538                let value = crate::convert::f32_to_u32(value.into_inner());
1539                let value = crate::convert::u32_to_i32(value);
1540
1541                Ch8::new(crate::downscale::i32_to_i8(value))
1542            }
1543        }
1544
1545        impl Conversion<unsigned::Ch32, Ch12> {
1546            /// Convert between types.
1547            pub const fn conv(value: unsigned::Ch32) -> Ch12 {
1548                let value = crate::convert::f32_to_u32(value.into_inner());
1549                let value = crate::convert::u32_to_i32(value);
1550
1551                Ch12::new(crate::downscale::i32_to_i12(value))
1552            }
1553        }
1554
1555        impl Conversion<unsigned::Ch32, Ch16> {
1556            /// Convert between types.
1557            pub const fn conv(value: unsigned::Ch32) -> Ch16 {
1558                let value = crate::convert::f32_to_u32(value.into_inner());
1559                let value = crate::convert::u32_to_i32(value);
1560
1561                Ch16::new(crate::downscale::i32_to_i16(value))
1562            }
1563        }
1564
1565        impl Conversion<unsigned::Ch32, Ch24> {
1566            /// Convert between types.
1567            pub const fn conv(value: unsigned::Ch32) -> Ch24 {
1568                let value = crate::convert::f32_to_u32(value.into_inner());
1569                let value = crate::convert::u32_to_i32(value);
1570
1571                Ch24::new(crate::downscale::i32_to_i24(value))
1572            }
1573        }
1574
1575        impl Conversion<unsigned::Ch32, Ch64> {
1576            /// Convert between types.
1577            pub const fn conv(value: unsigned::Ch32) -> Ch64 {
1578                let value = crate::upscale::f32_to_f64(value.into_inner());
1579                let value = crate::convert::f64_to_u64(value);
1580                let value = crate::convert::u64_to_i64(value);
1581
1582                Ch64::new(crate::convert::i64_to_f64(value))
1583            }
1584        }
1585
1586        impl Conversion<unsigned::Ch64, Ch8> {
1587            /// Convert between types.
1588            pub const fn conv(value: unsigned::Ch64) -> Ch8 {
1589                let value = crate::convert::f64_to_u64(value.into_inner());
1590                let value = crate::convert::u64_to_i64(value);
1591
1592                Ch8::new(crate::downscale::i64_to_i8(value))
1593            }
1594        }
1595
1596        impl Conversion<unsigned::Ch64, Ch12> {
1597            /// Convert between types.
1598            pub const fn conv(value: unsigned::Ch64) -> Ch12 {
1599                let value = crate::convert::f64_to_u64(value.into_inner());
1600                let value = crate::convert::u64_to_i64(value);
1601
1602                Ch12::new(crate::downscale::i64_to_i12(value))
1603            }
1604        }
1605
1606        impl Conversion<unsigned::Ch64, Ch16> {
1607            /// Convert between types.
1608            pub const fn conv(value: unsigned::Ch64) -> Ch16 {
1609                let value = crate::convert::f64_to_u64(value.into_inner());
1610                let value = crate::convert::u64_to_i64(value);
1611
1612                Ch16::new(crate::downscale::i64_to_i16(value))
1613            }
1614        }
1615
1616        impl Conversion<unsigned::Ch64, Ch24> {
1617            /// Convert between types.
1618            pub const fn conv(value: unsigned::Ch64) -> Ch24 {
1619                let value = crate::convert::f64_to_u64(value.into_inner());
1620                let value = crate::convert::u64_to_i64(value);
1621
1622                Ch24::new(crate::downscale::i64_to_i24(value))
1623            }
1624        }
1625
1626        impl Conversion<unsigned::Ch64, Ch32> {
1627            /// Convert between types.
1628            pub const fn conv(value: unsigned::Ch64) -> Ch32 {
1629                let value = crate::downscale::f64_to_f32(value.into_inner());
1630                let value = crate::convert::f32_to_u32(value);
1631                let value = crate::convert::u32_to_i32(value);
1632
1633                Ch32::new(crate::convert::i32_to_f32(value))
1634            }
1635        }
1636    }
1637}
p_chan/ops.rs

p_chan/
ops.rs
