spirix/operators/
circle_rust.rs

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

spirix/operators/
circle_rust.rs
