feanor_math/
delegate.rs

1use std::marker::PhantomData;
2
3use crate::divisibility::PreparedDivisor;
4use crate::pid::EuclideanRing;
5use crate::pid::PrincipalIdealRing;
6use crate::ring::*;
7use crate::homomorphism::*;
8use crate::divisibility::DivisibilityRing;
9use crate::rings::extension::FreeAlgebra;
10use crate::rings::{zn::ZnRing, finite::FiniteRing};
11use crate::integer::{IntegerRingStore, IntegerRing};
12use crate::serialization::SerializableElementRing;
13use crate::specialization::*;
14
15///
16/// Trait to simplify implementing newtype-pattern for rings.
17/// When you want to create a ring that just wraps another ring,
18/// possibly adding some functionality, you can implement `DelegateRing`
19/// instead of `RingBase`, and just provide how to map elements in the new
20/// ring to the wrapped ring and vice versa.
21/// 
22/// # Conditional Implementations
23/// 
24/// Some special ring traits (e.g. [`DivisibilityRing`]) are immediately implemented 
25/// for `R: DelegateRing` as soon as `R::Base: SpecialRingTrait`. However, this 
26/// of course prevents any implementation fo [`DelegateRing`] to provide a custom 
27/// implementation (except for specialization in some cases), due to conflicting 
28/// trait impls. Hence, for other traits, we use marker traits to mark an implementation 
29/// `R` of [`DelegateRing`] to also automatically implement a special ring trait as soon 
30/// as `R::Base: SpecialRingTrait`. These cases are currently
31///  - [`DelegateRingImplFiniteRing`] for automatic implementations of [`FiniteRing`] and
32///    [`FiniteRingSpecializable`].
33///  - [`DelegateRingImplEuclideanRing`] for automatic implementations of [`PrincipalIdealRing`]
34///    and [`EuclideanRing`]
35/// 
36/// # Example
37/// 
38/// ```
39/// # use feanor_math::ring::*;
40/// # use feanor_math::homomorphism::*;
41/// # use feanor_math::primitive_int::*;
42/// # use feanor_math::delegate::*;
43/// # use feanor_math::{assert_el_eq, impl_eq_based_self_iso};
44/// 
45/// #[derive(PartialEq, Clone)]
46/// struct MyI32Ring;
47/// struct MyI32RingEl(i32);
48/// 
49/// impl DelegateRing for MyI32Ring {
50/// 
51///     type Base = StaticRingBase<i32>;
52///     type Element = MyI32RingEl;
53/// 
54///     fn get_delegate(&self) -> &Self::Base {
55///         StaticRing::<i32>::RING.get_ring()
56///     }
57/// 
58///     fn delegate_ref<'a>(&self, MyI32RingEl(el): &'a MyI32RingEl) -> &'a i32 {
59///         el
60///     }
61/// 
62///     fn delegate_mut<'a>(&self, MyI32RingEl(el): &'a mut MyI32RingEl) -> &'a mut i32 {
63///         el
64///     }
65/// 
66///     fn delegate(&self, MyI32RingEl(el): MyI32RingEl) -> i32 {
67///         el
68///     }
69/// 
70///     fn postprocess_delegate_mut(&self, _: &mut MyI32RingEl) {
71///         // sometimes it might be necessary to fix some data of `Self::Element`
72///         // if the underlying `Self::Base::Element` was modified via `delegate_mut()`;
73///         // this is not the case here, so leave empty
74///     }
75/// 
76///     fn rev_delegate(&self, el: i32) -> MyI32RingEl {
77///         MyI32RingEl(el)
78///     }
79/// }
80/// 
81/// // you will have to implement `CanIsoFromTo<Self>`
82/// impl_eq_based_self_iso!{ MyI32Ring }
83/// 
84/// let ring = RingValue::from(MyI32Ring);
85/// assert_el_eq!(ring, ring.int_hom().map(1), ring.one());
86/// ```
87/// An example when special ring traits are automatically implemented is 
88/// given by the following.
89/// ```
90/// # use feanor_math::ring::*;
91/// # use feanor_math::homomorphism::*;
92/// # use feanor_math::delegate::*;
93/// # use feanor_math::{assert_el_eq, impl_eq_based_self_iso};
94/// 
95/// struct BoringRingWrapper<R>(R);
96/// 
97/// impl<R> PartialEq for BoringRingWrapper<R>
98///     where R: RingStore
99/// {
100///     fn eq(&self, other: &Self) -> bool {
101///         self.0.get_ring() == other.0.get_ring()
102///     }
103/// }
104/// 
105/// impl<R> DelegateRing for BoringRingWrapper<R>
106///     where R: RingStore
107/// {
108///     type Base = R::Type;
109///     type Element = El<R>;
110/// 
111///     fn get_delegate(&self) -> &Self::Base {
112///         self.0.get_ring()
113///     }
114/// 
115///     fn delegate(&self, el: Self::Element) -> <Self::Base as RingBase>::Element { el }
116///     fn delegate_mut<'a>(&self, el: &'a mut Self::Element) -> &'a mut <Self::Base as RingBase>::Element { el }
117///     fn delegate_ref<'a>(&self, el: &'a Self::Element) -> &'a <Self::Base as RingBase>::Element { el }
118///     fn rev_delegate(&self, el: <Self::Base as RingBase>::Element) -> Self::Element { el }
119/// }
120/// ```
121/// [`DivisibilityRing`] is automatically implemented (but can be specialized):
122/// ```
123/// # use feanor_math::ring::*;
124/// # use feanor_math::homomorphism::*;
125/// # use feanor_math::divisibility::*;
126/// # use feanor_math::delegate::*;
127/// # use feanor_math::{assert_el_eq, impl_eq_based_self_iso};
128/// #
129/// # struct BoringRingWrapper<R>(R);
130/// # 
131/// # impl<R> PartialEq for BoringRingWrapper<R>
132/// #     where R: RingStore
133/// # {
134/// #     fn eq(&self, other: &Self) -> bool {
135/// #         self.0.get_ring() == other.0.get_ring()
136/// #     }
137/// # }
138/// # 
139/// # impl<R> DelegateRing for BoringRingWrapper<R>
140/// #     where R: RingStore
141/// # {
142/// #     type Base = R::Type;
143/// #     type Element = El<R>;
144/// # 
145/// #     fn get_delegate(&self) -> &Self::Base {
146/// #         self.0.get_ring()
147/// #     }
148/// # 
149/// #     fn delegate(&self, el: Self::Element) -> <Self::Base as RingBase>::Element { el }
150/// #     fn delegate_mut<'a>(&self, el: &'a mut Self::Element) -> &'a mut <Self::Base as RingBase>::Element { el }
151/// #     fn delegate_ref<'a>(&self, el: &'a Self::Element) -> &'a <Self::Base as RingBase>::Element { el }
152/// #     fn rev_delegate(&self, el: <Self::Base as RingBase>::Element) -> Self::Element { el }
153/// # }
154/// fn divide_in_wrapped_ring<R>(base_ring: R)
155///     where R: RingStore,
156///         R::Type: DivisibilityRing
157/// {
158///     let wrapped_ring = BoringRingWrapper(base_ring);
159///     assert!(wrapped_ring.checked_div(&wrapped_ring.one(), &wrapped_ring.one()).is_some());
160/// }
161/// ```
162/// [`FiniteRing`] for example is not automatically implemented:
163/// ```compile_fail
164/// # use feanor_math::ring::*;
165/// # use feanor_math::homomorphism::*;
166/// # use feanor_math::rings::finite::*;
167/// # use feanor_math::integer::*;
168/// # use feanor_math::delegate::*;
169/// # use feanor_math::{assert_el_eq, impl_eq_based_self_iso};
170/// #
171/// # impl<R> PartialEq for BoringRingWrapper<R>
172/// #     where R: RingStore
173/// # {
174/// #     fn eq(&self, other: &Self) -> bool {
175/// #         self.0.get_ring() == other.0.get_ring()
176/// #     }
177/// # }
178/// #
179/// # struct BoringRingWrapper<R>(R);
180/// # 
181/// # impl<R> DelegateRing for BoringRingWrapper<R>
182/// #     where R: RingStore
183/// # {
184/// #     type Base = R::Type;
185/// #     type Element = El<R>;
186/// # 
187/// #     fn get_delegate(&self) -> &Self::Base {
188/// #         self.0.get_ring()
189/// #     }
190/// # 
191/// #     fn delegate(&self, el: Self::Element) -> <Self::Base as RingBase>::Element { el }
192/// #     fn delegate_mut<'a>(&self, el: &'a mut Self::Element) -> &'a mut <Self::Base as RingBase>::Element { el }
193/// #     fn delegate_ref<'a>(&self, el: &'a Self::Element) -> &'a <Self::Base as RingBase>::Element { el }
194/// #     fn rev_delegate(&self, el: <Self::Base as RingBase>::Element) -> Self::Element { el }
195/// # }
196/// fn size_of_wrapped_ring<R>(base_ring: R)
197///     where R: RingStore,
198///         R::Type: FiniteRing
199/// {
200///     let wrapped_ring = BoringRingWrapper(base_ring);
201///     assert!(wrapped_ring.size(BigIntRing::RING).is_some());
202/// }
203/// ```
204/// But we can add a delegate-implementation of [`FiniteRing`] by adding the marker trait [`DelegateRingImplFiniteRing`]:
205/// ```
206/// # use feanor_math::ring::*;
207/// # use feanor_math::homomorphism::*;
208/// # use feanor_math::rings::finite::*;
209/// # use feanor_math::integer::*;
210/// # use feanor_math::delegate::*;
211/// # use feanor_math::{assert_el_eq, impl_eq_based_self_iso};
212/// #
213/// # impl<R> PartialEq for BoringRingWrapper<R>
214/// #     where R: RingStore
215/// # {
216/// #     fn eq(&self, other: &Self) -> bool {
217/// #         self.0.get_ring() == other.0.get_ring()
218/// #     }
219/// # }
220/// # 
221/// # struct BoringRingWrapper<R>(R);
222/// # 
223/// # impl<R> DelegateRing for BoringRingWrapper<R>
224/// #     where R: RingStore
225/// # {
226/// #     type Base = R::Type;
227/// #     type Element = El<R>;
228/// # 
229/// #     fn get_delegate(&self) -> &Self::Base {
230/// #         self.0.get_ring()
231/// #     }
232/// # 
233/// #     fn delegate(&self, el: Self::Element) -> <Self::Base as RingBase>::Element { el }
234/// #     fn delegate_mut<'a>(&self, el: &'a mut Self::Element) -> &'a mut <Self::Base as RingBase>::Element { el }
235/// #     fn delegate_ref<'a>(&self, el: &'a Self::Element) -> &'a <Self::Base as RingBase>::Element { el }
236/// #     fn rev_delegate(&self, el: <Self::Base as RingBase>::Element) -> Self::Element { el }
237/// # }
238/// impl<R> DelegateRingImplFiniteRing for BoringRingWrapper<R>
239///     where R: RingStore
240/// {}
241/// 
242/// fn size_of_wrapped_ring<R>(base_ring: R)
243///     where R: RingStore,
244///         R::Type: FiniteRing
245/// {
246///     let wrapped_ring = BoringRingWrapper(base_ring);
247///     assert!(wrapped_ring.size(BigIntRing::RING).is_some());
248/// }
249/// ```
250/// 
251pub trait DelegateRing: PartialEq {
252
253    type Base: ?Sized + RingBase;
254    type Element;
255
256    fn get_delegate(&self) -> &Self::Base;
257    fn delegate_ref<'a>(&self, el: &'a Self::Element) -> &'a <Self::Base as RingBase>::Element;
258    fn delegate_mut<'a>(&self, el: &'a mut Self::Element) -> &'a mut <Self::Base as RingBase>::Element;
259    fn delegate(&self, el: Self::Element) -> <Self::Base as RingBase>::Element;
260    fn rev_delegate(&self, el: <Self::Base as RingBase>::Element) -> Self::Element;
261    
262    fn postprocess_delegate_mut(&self, el: &mut Self::Element) {
263        *el = self.rev_delegate(self.get_delegate().clone_el(self.delegate_ref(el)));
264    }
265
266    ///
267    /// Necessary in some locations to satisfy the type system
268    /// 
269    fn element_cast(&self, el: Self::Element) -> <Self as RingBase>::Element {
270        el
271    }
272
273    ///
274    /// Necessary in some locations to satisfy the type system
275    /// 
276    fn rev_element_cast(&self, el: <Self as RingBase>::Element) -> Self::Element {
277        el
278    }
279
280    ///
281    /// Necessary in some locations to satisfy the type system
282    /// 
283    fn rev_element_cast_ref<'a>(&self, el: &'a <Self as RingBase>::Element) -> &'a Self::Element {
284        el
285    }
286}
287
288impl<R: DelegateRing + PartialEq + ?Sized> RingBase for R {
289
290    type Element = <Self as DelegateRing>::Element;
291
292    default fn clone_el(&self, val: &Self::Element) -> Self::Element {
293        self.rev_delegate(self.get_delegate().clone_el(self.delegate_ref(val)))
294    }
295    
296    default fn add_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element) {
297        self.get_delegate().add_assign_ref(self.delegate_mut(lhs), self.delegate_ref(rhs));
298        self.postprocess_delegate_mut(lhs);
299    }
300
301    default fn add_assign(&self, lhs: &mut Self::Element, rhs: Self::Element) {
302        self.get_delegate().add_assign(self.delegate_mut(lhs), self.delegate(rhs));
303        self.postprocess_delegate_mut(lhs);
304    }
305
306    default fn sub_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element) {
307        self.get_delegate().sub_assign_ref(self.delegate_mut(lhs), self.delegate_ref(rhs));
308        self.postprocess_delegate_mut(lhs);
309    }
310
311    default fn sub_self_assign(&self, lhs: &mut Self::Element, rhs: Self::Element) {
312        self.get_delegate().sub_self_assign(self.delegate_mut(lhs), self.delegate(rhs));
313        self.postprocess_delegate_mut(lhs);
314    }
315
316    default fn sub_self_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element) {
317        self.get_delegate().sub_self_assign_ref(self.delegate_mut(lhs), self.delegate_ref(rhs));
318        self.postprocess_delegate_mut(lhs);
319    }
320
321    default fn negate_inplace(&self, lhs: &mut Self::Element) {
322        self.get_delegate().negate_inplace(self.delegate_mut(lhs));
323        self.postprocess_delegate_mut(lhs);
324    }
325
326    default fn mul_assign(&self, lhs: &mut Self::Element, rhs: Self::Element) {
327        self.get_delegate().mul_assign(self.delegate_mut(lhs), self.delegate(rhs));
328        self.postprocess_delegate_mut(lhs);
329    }
330
331    default fn mul_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element) {
332        self.get_delegate().mul_assign_ref(self.delegate_mut(lhs), self.delegate_ref(rhs));
333        self.postprocess_delegate_mut(lhs);
334    }
335
336    default fn square(&self, value: &mut Self::Element) {
337        self.get_delegate().square(self.delegate_mut(value));
338        self.postprocess_delegate_mut(value);
339    }
340
341    default fn zero(&self) -> Self::Element {
342        self.rev_delegate(self.get_delegate().zero())
343    }
344
345    default fn one(&self) -> Self::Element {
346        self.rev_delegate(self.get_delegate().one())
347    }
348
349    default fn neg_one(&self) -> Self::Element {
350        self.rev_delegate(self.get_delegate().neg_one())
351    }
352
353    default fn from_int(&self, value: i32) -> Self::Element {
354        self.rev_delegate(self.get_delegate().from_int(value))
355    }
356
357    default fn eq_el(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool {
358        self.get_delegate().eq_el(self.delegate_ref(lhs), self.delegate_ref(rhs))
359    }
360
361    default fn is_zero(&self, value: &Self::Element) -> bool {
362        self.get_delegate().is_zero(self.delegate_ref(value))
363    }
364
365    default fn is_one(&self, value: &Self::Element) -> bool {
366        self.get_delegate().is_one(self.delegate_ref(value))
367    }
368
369    default fn is_neg_one(&self, value: &Self::Element) -> bool {
370        self.get_delegate().is_neg_one(self.delegate_ref(value))
371    }
372
373    default fn is_commutative(&self) -> bool {
374        self.get_delegate().is_commutative()
375    }
376
377    default fn is_noetherian(&self) -> bool {
378        self.get_delegate().is_noetherian()
379    }
380
381    default fn dbg<'a>(&self, value: &Self::Element, out: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {
382        self.get_delegate().dbg(self.delegate_ref(value), out)
383    }
384
385    default fn dbg_within<'a>(&self, value: &Self::Element, out: &mut std::fmt::Formatter<'a>, env: EnvBindingStrength) -> std::fmt::Result {
386        self.get_delegate().dbg_within(self.delegate_ref(value), out, env)
387    }
388
389    default fn negate(&self, value: Self::Element) -> Self::Element {
390        self.rev_delegate(self.get_delegate().negate(self.delegate(value)))
391    }
392    
393    default fn sub_assign(&self, lhs: &mut Self::Element, rhs: Self::Element) {
394        self.get_delegate().sub_assign(self.delegate_mut(lhs), self.delegate(rhs));
395        self.postprocess_delegate_mut(lhs);
396    }
397
398    default fn add_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element {
399        self.rev_delegate(self.get_delegate().add_ref(self.delegate_ref(lhs), self.delegate_ref(rhs)))
400    }
401
402    default fn add_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element {
403        self.rev_delegate(self.get_delegate().add_ref_fst(self.delegate_ref(lhs), self.delegate(rhs)))
404    }
405
406    default fn add_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element {
407        self.rev_delegate(self.get_delegate().add_ref_snd(self.delegate(lhs), self.delegate_ref(rhs)))
408    }
409
410    default fn add(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element {
411        self.rev_delegate(self.get_delegate().add(self.delegate(lhs), self.delegate(rhs)))
412    }
413
414    default fn sub_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element {
415        self.rev_delegate(self.get_delegate().sub_ref(self.delegate_ref(lhs), self.delegate_ref(rhs)))
416    }
417
418    default fn sub_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element {
419        self.rev_delegate(self.get_delegate().sub_ref_fst(self.delegate_ref(lhs), self.delegate(rhs)))
420    }
421
422    default fn sub_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element {
423        self.rev_delegate(self.get_delegate().sub_ref_snd(self.delegate(lhs), self.delegate_ref(rhs)))
424    }
425
426    default fn sub(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element {
427        self.rev_delegate(self.get_delegate().sub(self.delegate(lhs), self.delegate(rhs)))
428    }
429
430    default fn mul_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element {
431        self.rev_delegate(self.get_delegate().mul_ref(self.delegate_ref(lhs), self.delegate_ref(rhs)))
432    }
433
434    default fn mul_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element {
435        self.rev_delegate(self.get_delegate().mul_ref_fst(self.delegate_ref(lhs), self.delegate(rhs)))
436    }
437
438    default fn mul_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element {
439        self.rev_delegate(self.get_delegate().mul_ref_snd(self.delegate(lhs), self.delegate_ref(rhs)))
440    }
441
442    default fn mul(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element {
443        self.rev_delegate(self.get_delegate().mul(self.delegate(lhs), self.delegate(rhs)))
444    }
445    
446    default fn is_approximate(&self) -> bool { self.get_delegate().is_approximate() }
447
448    default fn mul_assign_int(&self, lhs: &mut Self::Element, rhs: i32) {
449        self.get_delegate().mul_assign_int(self.delegate_mut(lhs), rhs);
450        self.postprocess_delegate_mut(lhs);
451    }
452
453    default fn mul_int(&self, lhs: Self::Element, rhs: i32) -> Self::Element {
454        self.rev_delegate(self.get_delegate().mul_int(self.delegate(lhs), rhs))
455    }
456
457    default fn mul_int_ref(&self, lhs: &Self::Element, rhs: i32) -> Self::Element {
458        self.rev_delegate(self.get_delegate().mul_int_ref(self.delegate_ref(lhs), rhs))
459    }
460    
461    default fn pow_gen<S: IntegerRingStore>(&self, x: Self::Element, power: &El<S>, integers: S) -> Self::Element 
462        where S::Type: IntegerRing
463    {
464        self.rev_delegate(self.get_delegate().pow_gen(self.delegate(x), power, integers))
465    }
466
467    default fn characteristic<I: IntegerRingStore + Copy>(&self, ZZ: I) -> Option<El<I>>
468        where I::Type: IntegerRing
469    {
470        self.get_delegate().characteristic(ZZ)
471    }
472}
473
474impl<R: DelegateRing + ?Sized> DivisibilityRing for R
475    where R::Base: DivisibilityRing
476{
477    type PreparedDivisorData = PreparedDivisor<R::Base>;
478
479    default fn checked_left_div(&self, lhs: &Self::Element, rhs: &Self::Element) -> Option<Self::Element> {
480        self.get_delegate().checked_left_div(self.delegate_ref(lhs), self.delegate_ref(rhs))
481            .map(|x| self.rev_delegate(x))
482    }
483
484    default fn balance_factor<'a, I>(&self, elements: I) -> Option<Self::Element>
485        where I: Iterator<Item = &'a Self::Element>,
486            Self: 'a
487    {
488        self.get_delegate().balance_factor(elements.map(|x| self.delegate_ref(x))).map(|c| self.rev_delegate(c))
489    }
490
491    fn prepare_divisor(&self, x: Self::Element) -> PreparedDivisor<Self> {
492        let prepared = self.get_delegate().prepare_divisor(self.delegate(x));
493        PreparedDivisor {
494            element: self.rev_delegate(self.get_delegate().clone_el(&prepared.element)),
495            data: prepared
496        }
497    }
498
499    default fn checked_left_div_prepared(&self, lhs: &Self::Element, rhs: &PreparedDivisor<Self>) -> Option<Self::Element> {
500        self.get_delegate().checked_left_div_prepared(self.delegate_ref(lhs), &rhs.data)
501            .map(|res| self.rev_delegate(res))
502    }
503
504    default fn divides_left_prepared(&self, lhs: &Self::Element, rhs: &PreparedDivisor<Self>) -> bool {
505        self.checked_left_div_prepared(lhs, rhs).is_some()
506    }
507}
508
509impl<R: DelegateRing + ?Sized> SerializableElementRing for R
510    where R::Base: DivisibilityRing + SerializableElementRing
511{
512    default fn serialize<S>(&self, el: &Self::Element, serializer: S) -> Result<S::Ok, S::Error>
513        where S: serde::Serializer
514    {
515        self.get_delegate().serialize(self.delegate_ref(el), serializer)
516    }
517
518    default fn deserialize<'de, D>(&self, deserializer: D) -> Result<Self::Element, D::Error>
519        where D: serde::Deserializer<'de>
520    {
521        self.get_delegate().deserialize(deserializer).map(|x| self.rev_delegate(x))
522    }
523}
524
525pub struct DelegateFiniteRingElementsIter<'a, R: ?Sized>
526    where R: DelegateRing, R::Base: FiniteRing
527{
528    ring: &'a R,
529    base: <R::Base as FiniteRing>::ElementsIter<'a>
530}
531
532impl<'a, R: ?Sized> Clone for DelegateFiniteRingElementsIter<'a, R>
533    where R: DelegateRing, R::Base: FiniteRing
534{
535    fn clone(&self) -> Self {
536        Self { ring: self.ring, base: self.base.clone() }
537    }
538}
539
540impl<'a, R: ?Sized> Iterator for DelegateFiniteRingElementsIter<'a, R>
541    where R: DelegateRing, R::Base: FiniteRing
542{
543    type Item = <R as RingBase>::Element;
544
545    fn next(&mut self) -> Option<Self::Item> {
546        self.base.next().map(|x| self.ring.rev_delegate(x))
547    }
548}
549
550///
551/// Marks a [`DelegateRing`] `R` to be considered in the blanket implementation
552/// `R: FiniteRing where R::Base: FiniteRing`.
553/// 
554/// We don't want to implement `R: FiniteRing` for any `DelegateRing` `R`, since
555/// some ring newtypes want to have control of when the ring is [`FiniteRing`].
556/// 
557pub trait DelegateRingImplFiniteRing: DelegateRing {}
558
559impl<R: DelegateRingImplFiniteRing + ?Sized> FiniteRing for R
560    where R::Base: FiniteRing
561{
562    type ElementsIter<'a> = DelegateFiniteRingElementsIter<'a, R>
563        where R: 'a;
564
565    fn elements<'a>(&'a self) -> Self::ElementsIter<'a> {
566        DelegateFiniteRingElementsIter {
567            ring: self,
568            base: self.get_delegate().elements()
569        }
570    }
571    
572    default fn random_element<G: FnMut() -> u64>(&self, rng: G) -> <R as RingBase>::Element {
573        self.element_cast(self.rev_delegate(self.get_delegate().random_element(rng)))
574    }
575
576    default fn size<I: IntegerRingStore + Copy>(&self, ZZ: I) -> Option<El<I>>
577        where I::Type: IntegerRing
578    {
579        self.get_delegate().size(ZZ)
580    }
581}
582
583impl<R: DelegateRing + ?Sized> HashableElRing for R 
584    where R::Base: HashableElRing
585{
586    default fn hash<H: std::hash::Hasher>(&self, el: &Self::Element, h: &mut H) {
587        self.get_delegate().hash(self.delegate_ref(el), h)
588    }
589}
590
591///
592/// Marks a [`DelegateRing`] `R` to be considered in the blanket implementation
593/// `R: EuclideanRing where R::Base: EuclideanRing` and 
594/// `R: PrincipalIdealRing where R::Base: PrincipalIdealRing`.
595/// 
596/// We don't want to implement `R: EuclideanRing` for any `DelegateRing` `R`, since
597/// some ring newtypes want to have control of when the ring is [`EuclideanRing`].
598/// 
599pub trait DelegateRingImplEuclideanRing: DelegateRing {}
600
601impl<R: DelegateRingImplEuclideanRing + ?Sized> PrincipalIdealRing for R
602    where R::Base: PrincipalIdealRing
603{
604    default fn checked_div_min(&self, lhs: &Self::Element, rhs: &Self::Element) -> Option<Self::Element> {
605        self.get_delegate().checked_div_min(self.delegate_ref(lhs), self.delegate_ref(rhs)).map(|res| self.rev_delegate(res))
606    }
607
608    default fn extended_ideal_gen(&self, lhs: &Self::Element, rhs: &Self::Element) -> (Self::Element, Self::Element, Self::Element) {
609        let (s, t, d) = self.get_delegate().extended_ideal_gen(self.delegate_ref(self.rev_element_cast_ref(lhs)), self.delegate_ref(self.rev_element_cast_ref(rhs)));
610        return (self.element_cast(self.rev_delegate(s)), self.element_cast(self.rev_delegate(t)), self.element_cast(self.rev_delegate(d)));
611    }
612
613    default fn ideal_gen(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element {
614        self.element_cast(self.rev_delegate(self.get_delegate().ideal_gen(self.delegate_ref(self.rev_element_cast_ref(lhs)), self.delegate_ref(self.rev_element_cast_ref(rhs)))))
615    }
616}
617
618impl<R: DelegateRingImplEuclideanRing + ?Sized> EuclideanRing for R
619    where R::Base: EuclideanRing
620{
621    default fn euclidean_div_rem(&self, lhs: Self::Element, rhs: &Self::Element) -> (Self::Element, Self::Element) {
622        let (q, r) = self.get_delegate().euclidean_div_rem(self.delegate(lhs), self.delegate_ref(rhs));
623        return (self.rev_delegate(q), self.rev_delegate(r));
624    }
625
626    fn euclidean_deg(&self, val: &Self::Element) -> Option<usize> {
627        self.get_delegate().euclidean_deg(self.delegate_ref(val))
628    }
629
630    fn euclidean_div(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element {
631        self.rev_delegate(self.get_delegate().euclidean_div(self.delegate(lhs), self.delegate_ref(rhs)))
632    }
633
634    fn euclidean_rem(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element {
635        self.rev_delegate(self.get_delegate().euclidean_rem(self.delegate(lhs), self.delegate_ref(rhs)))
636    }
637}
638
639impl<R> FiniteRingSpecializable for R
640    where R: DelegateRingImplFiniteRing + ?Sized,
641        R::Base: FiniteRingSpecializable
642{
643    fn specialize<O: FiniteRingOperation<Self>>(op: O) -> Result<O::Output, ()> {
644        struct OpWrapper<R, O>
645            where R: DelegateRingImplFiniteRing + ?Sized,
646                R::Base: FiniteRingSpecializable,
647                O: FiniteRingOperation<R>
648        {
649            operation: O,
650            ring: PhantomData<Box<R>>
651        }
652
653        impl<R, O> FiniteRingOperation<R::Base> for OpWrapper<R, O>
654            where R: DelegateRingImplFiniteRing + ?Sized,
655                R::Base: FiniteRingSpecializable,
656                O: FiniteRingOperation<R>
657        {
658            type Output = O::Output;
659            fn execute(self) -> Self::Output where R::Base: FiniteRing {
660                self.operation.execute()
661            }
662        }
663
664        <R::Base as FiniteRingSpecializable>::specialize(OpWrapper { operation: op, ring: PhantomData })
665    }
666}
667
668impl<R: DelegateRingImplFiniteRing + ?Sized> ZnRing for R
669    where R::Base: ZnRing, 
670        Self: PrincipalIdealRing,
671        R: CanHomFrom<<R::Base as ZnRing>::IntegerRingBase>
672{
673    type IntegerRingBase = <R::Base as ZnRing>::IntegerRingBase;
674    type IntegerRing = <R::Base as ZnRing>::IntegerRing;
675
676    default fn integer_ring(&self) -> &Self::IntegerRing {
677        self.get_delegate().integer_ring()
678    }
679
680    default fn modulus(&self) -> &El<Self::IntegerRing> {
681        self.get_delegate().modulus()
682    }
683
684    default fn smallest_positive_lift(&self, el: Self::Element) -> El<Self::IntegerRing> {
685        self.get_delegate().smallest_positive_lift(self.delegate(self.rev_element_cast(el)))
686    }
687
688    default fn smallest_lift(&self, el: Self::Element) -> El<Self::IntegerRing> {
689        self.get_delegate().smallest_lift(self.delegate(self.rev_element_cast(el)))
690    }
691
692    default fn from_int_promise_reduced(&self, x: El<Self::IntegerRing>) -> Self::Element {
693        self.element_cast(self.rev_delegate(self.get_delegate().from_int_promise_reduced(x)))
694    }
695}
696
697impl<R> RingExtension for R 
698    where R: DelegateRing,
699        R::Base: RingExtension
700{
701    type BaseRing = <R::Base as RingExtension>::BaseRing;
702
703    fn base_ring<'a>(&'a self) -> &'a Self::BaseRing {
704        self.get_delegate().base_ring()
705    }
706
707    fn from(&self, x: El<Self::BaseRing>) -> Self::Element {
708        self.rev_delegate(self.get_delegate().from(x))
709    }
710}
711
712impl<R> FreeAlgebra for R 
713    where R: DelegateRing,
714        <R as DelegateRing>::Base: FreeAlgebra
715{
716    type VectorRepresentation<'a> = <<R as DelegateRing>::Base as FreeAlgebra>::VectorRepresentation<'a>
717        where Self: 'a;
718
719    default fn canonical_gen(&self) -> Self::Element {
720        self.rev_delegate(self.get_delegate().canonical_gen())
721    }
722
723    default fn from_canonical_basis<V>(&self, vec: V) -> Self::Element
724        where V: IntoIterator<Item = El<Self::BaseRing>>,
725            V::IntoIter: DoubleEndedIterator
726    {
727        self.rev_delegate(self.get_delegate().from_canonical_basis(vec.into_iter().map(|x| x)))
728    }
729
730    default fn rank(&self) -> usize {
731        self.get_delegate().rank()
732    }
733
734    default fn wrt_canonical_basis<'a>(&'a self, el: &'a Self::Element) -> Self::VectorRepresentation<'a> {
735        self.get_delegate().wrt_canonical_basis(self.delegate_ref(el))
736    }
737}
738
739#[stability::unstable(feature = "enable")]
740pub struct WrapHom<'a, R>
741    where R: DelegateRing
742{
743    to: RingRef<'a, R>,
744    from: RingRef<'a, R::Base>
745}
746
747impl<'a, R> WrapHom<'a, R>
748    where R: DelegateRing
749{
750    #[stability::unstable(feature = "enable")]
751    pub fn new(ring: &'a R) -> Self {
752        Self {
753            to: RingRef::new(ring),
754            from: RingRef::new(ring.get_delegate())
755        }
756    }
757}
758
759impl<'a, R> Homomorphism<<R as DelegateRing>::Base, R> for WrapHom<'a, R>
760    where R: DelegateRing
761{
762    type DomainStore = RingRef<'a, <R as DelegateRing>::Base>;
763    type CodomainStore = RingRef<'a, R>;
764
765    fn domain<'b>(&'b self) -> &'b Self::DomainStore {
766        &self.from
767    }
768
769    fn codomain<'b>(&'b self) -> &'b Self::CodomainStore {
770        &self.to
771    }
772
773    fn map(&self, x: <<R as DelegateRing>::Base as RingBase>::Element) -> <R as RingBase>::Element {
774        self.to.get_ring().element_cast(self.to.get_ring().rev_delegate(x))
775    }
776}
777
778#[stability::unstable(feature = "enable")]
779pub struct UnwrapHom<'a, R>
780    where R: DelegateRing
781{
782    from: RingRef<'a, R>,
783    to: RingRef<'a, R::Base>
784}
785
786impl<'a, R> UnwrapHom<'a, R>
787    where R: DelegateRing
788{
789    #[stability::unstable(feature = "enable")]
790    pub fn new(ring: &'a R) -> Self {
791        Self {
792            from: RingRef::new(ring),
793            to: RingRef::new(ring.get_delegate())
794        }
795    }
796}
797
798impl<'a, R> Homomorphism<R, <R as DelegateRing>::Base> for UnwrapHom<'a, R>
799    where R: DelegateRing
800{
801    type DomainStore = RingRef<'a, R>;
802    type CodomainStore = RingRef<'a, <R as DelegateRing>::Base>;
803
804    fn domain<'b>(&'b self) -> &'b Self::DomainStore {
805        &self.from
806    }
807
808    fn codomain<'b>(&'b self) -> &'b Self::CodomainStore {
809        &self.to
810    }
811
812    fn map(&self, x: <R as RingBase>::Element) -> <<R as DelegateRing>::Base as RingBase>::Element {
813        self.from.get_ring().delegate(self.from.get_ring().rev_element_cast(x))
814    }
815}
feanor_math/delegate.rs

feanor_math/
delegate.rs
