feanor_math/
delegate.rs

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

feanor_math/
delegate.rs
