Mercurial > repos > alg_tools / file comparison

comparison: src/linops.rs

src/linops.rs

branch
dev
changeset 133
2b13f8a0c8ba
parent 130
0a689881b0f1
child 139
f78885441218
equal deleted inserted replaced
132:89371dc4d637 133:2b13f8a0c8ba
528 <S::Codomain as Add<T::Codomain>>::Output: Space, 528 <S::Codomain as Add<T::Codomain>>::Output: Space,
529 { 529 {
530 type Codomain = <S::Codomain as Add<T::Codomain>>::Output; 530 type Codomain = <S::Codomain as Add<T::Codomain>>::Output;
531 531
532 fn apply<I: Instance<Pair<A, B>>>(&self, x: I) -> Self::Codomain { 532 fn apply<I: Instance<Pair<A, B>>>(&self, x: I) -> Self::Codomain {
533 let Pair(a, b) = x.decompose(); 533 x.eval_decompose(|Pair(a, b)| self.0.apply(a) + self.1.apply(b))
534 self.0.apply(a) + self.1.apply(b)
535 } 534 }
536 } 535 }
537 536
538 impl<A, B, S, T> Linear<Pair<A, B>> for RowOp<S, T> 537 impl<A, B, S, T> Linear<Pair<A, B>> for RowOp<S, T>
539 where 538 where
554 T: GEMV<F, V, Y>, 553 T: GEMV<F, V, Y>,
555 F: Num, 554 F: Num,
556 Self: Linear<Pair<U, V>, Codomain = Y>, 555 Self: Linear<Pair<U, V>, Codomain = Y>,
557 { 556 {
558 fn gemv<I: Instance<Pair<U, V>>>(&self, y: &mut Y, α: F, x: I, β: F) { 557 fn gemv<I: Instance<Pair<U, V>>>(&self, y: &mut Y, α: F, x: I, β: F) {
559 let Pair(u, v) = x.decompose(); 558 x.eval_decompose(|Pair(u, v)| {
560 self.0.gemv(y, α, u, β); 559 self.0.gemv(y, α, u, β);
561 self.1.gemv(y, α, v, F::ONE); 560 self.1.gemv(y, α, v, F::ONE);
561 })
562 } 562 }
563 563
564 fn apply_mut<I: Instance<Pair<U, V>>>(&self, y: &mut Y, x: I) { 564 fn apply_mut<I: Instance<Pair<U, V>>>(&self, y: &mut Y, x: I) {
565 let Pair(u, v) = x.decompose(); 565 x.eval_decompose(|Pair(u, v)| {
566 self.0.apply_mut(y, u); 566 self.0.apply_mut(y, u);
567 self.1.apply_add(y, v); 567 self.1.apply_add(y, v);
568 })
568 } 569 }
569 570
570 /// Computes `y += Ax`, where `A` is `Self` 571 /// Computes `y += Ax`, where `A` is `Self`
571 fn apply_add<I: Instance<Pair<U, V>>>(&self, y: &mut Y, x: I) { 572 fn apply_add<I: Instance<Pair<U, V>>>(&self, y: &mut Y, x: I) {
572 let Pair(u, v) = x.decompose(); 573 x.eval_decompose(|Pair(u, v)| {
573 self.0.apply_add(y, u); 574 self.0.apply_add(y, u);
574 self.1.apply_add(y, v); 575 self.1.apply_add(y, v);
576 })
575 } 577 }
576 } 578 }
577 579
578 /// “Column operator” $(S; T)$; $(S; T)x=(Sx, Tx)$. 580 /// “Column operator” $(S; T)$; $(S; T)x=(Sx, Tx)$.
579 #[derive(Clone, Copy, Debug, Serialize, Eq, PartialEq)] 581 #[derive(Clone, Copy, Debug, Serialize, Eq, PartialEq)]
586 T: Mapping<A>, 588 T: Mapping<A>,
587 { 589 {
588 type Codomain = Pair<S::Codomain, T::Codomain>; 590 type Codomain = Pair<S::Codomain, T::Codomain>;
589 591
590 fn apply<I: Instance<A>>(&self, a: I) -> Self::Codomain { 592 fn apply<I: Instance<A>>(&self, a: I) -> Self::Codomain {
591 Pair(self.0.apply(a.ref_instance()), self.1.apply(a)) 593 Pair(a.eval_ref_decompose(|r| self.0.apply(r)), self.1.apply(a))
592 } 594 }
593 } 595 }
594 596
595 impl<A, S, T> Linear<A> for ColOp<S, T> 597 impl<A, S, T> Linear<A> for ColOp<S, T>
596 where 598 where
607 T: GEMV<F, X, B>, 609 T: GEMV<F, X, B>,
608 F: Num, 610 F: Num,
609 Self: Linear<X, Codomain = Pair<A, B>>, 611 Self: Linear<X, Codomain = Pair<A, B>>,
610 { 612 {
611 fn gemv<I: Instance<X>>(&self, y: &mut Pair<A, B>, α: F, x: I, β: F) { 613 fn gemv<I: Instance<X>>(&self, y: &mut Pair<A, B>, α: F, x: I, β: F) {
612 self.0.gemv(&mut y.0, α, x.ref_instance(), β); 614 x.eval_ref_decompose(|r| self.0.gemv(&mut y.0, α, r, β));
613 self.1.gemv(&mut y.1, α, x, β); 615 self.1.gemv(&mut y.1, α, x, β);
614 } 616 }
615 617
616 fn apply_mut<I: Instance<X>>(&self, y: &mut Pair<A, B>, x: I) { 618 fn apply_mut<I: Instance<X>>(&self, y: &mut Pair<A, B>, x: I) {
617 self.0.apply_mut(&mut y.0, x.ref_instance()); 619 x.eval_ref_decompose(|r| self.0.apply_mut(&mut y.0, r));
618 self.1.apply_mut(&mut y.1, x); 620 self.1.apply_mut(&mut y.1, x);
619 } 621 }
620 622
621 /// Computes `y += Ax`, where `A` is `Self` 623 /// Computes `y += Ax`, where `A` is `Self`
622 fn apply_add<I: Instance<X>>(&self, y: &mut Pair<A, B>, x: I) { 624 fn apply_add<I: Instance<X>>(&self, y: &mut Pair<A, B>, x: I) {
623 self.0.apply_add(&mut y.0, x.ref_instance()); 625 x.eval_ref_decompose(|r| self.0.apply_add(&mut y.0, r));
624 self.1.apply_add(&mut y.1, x); 626 self.1.apply_add(&mut y.1, x);
625 } 627 }
626 } 628 }
627 629
628 impl<A, B, Yʹ, S, T> Adjointable<Pair<A, B>, Yʹ> for RowOp<S, T> 630 impl<A, B, Yʹ, S, T> Adjointable<Pair<A, B>, Yʹ> for RowOp<S, T>
730 T: Mapping<B>, 732 T: Mapping<B>,
731 { 733 {
732 type Codomain = Pair<S::Codomain, T::Codomain>; 734 type Codomain = Pair<S::Codomain, T::Codomain>;
733 735
734 fn apply<I: Instance<Pair<A, B>>>(&self, x: I) -> Self::Codomain { 736 fn apply<I: Instance<Pair<A, B>>>(&self, x: I) -> Self::Codomain {
735 let Pair(a, b) = x.decompose(); 737 x.eval_decompose(|Pair(a, b)| Pair(self.0.apply(a), self.1.apply(b)))
736 Pair(self.0.apply(a), self.1.apply(b))
737 } 738 }
738 } 739 }
739 740
740 impl<A, B, S, T> Linear<Pair<A, B>> for DiagOp<S, T> 741 impl<A, B, S, T> Linear<Pair<A, B>> for DiagOp<S, T>
741 where 742 where
756 T: GEMV<F, V, B>, 757 T: GEMV<F, V, B>,
757 F: Num, 758 F: Num,
758 Self: Linear<Pair<U, V>, Codomain = Pair<A, B>>, 759 Self: Linear<Pair<U, V>, Codomain = Pair<A, B>>,
759 { 760 {
760 fn gemv<I: Instance<Pair<U, V>>>(&self, y: &mut Pair<A, B>, α: F, x: I, β: F) { 761 fn gemv<I: Instance<Pair<U, V>>>(&self, y: &mut Pair<A, B>, α: F, x: I, β: F) {
761 let Pair(u, v) = x.decompose(); 762 x.eval_decompose(|Pair(u, v)| {
762 self.0.gemv(&mut y.0, α, u, β); 763 self.0.gemv(&mut y.0, α, u, β);
763 self.1.gemv(&mut y.1, α, v, β); 764 self.1.gemv(&mut y.1, α, v, β);
765 })
764 } 766 }
765 767
766 fn apply_mut<I: Instance<Pair<U, V>>>(&self, y: &mut Pair<A, B>, x: I) { 768 fn apply_mut<I: Instance<Pair<U, V>>>(&self, y: &mut Pair<A, B>, x: I) {
767 let Pair(u, v) = x.decompose(); 769 x.eval_decompose(|Pair(u, v)| {
768 self.0.apply_mut(&mut y.0, u); 770 self.0.apply_mut(&mut y.0, u);
769 self.1.apply_mut(&mut y.1, v); 771 self.1.apply_mut(&mut y.1, v);
772 })
770 } 773 }
771 774
772 /// Computes `y += Ax`, where `A` is `Self` 775 /// Computes `y += Ax`, where `A` is `Self`
773 fn apply_add<I: Instance<Pair<U, V>>>(&self, y: &mut Pair<A, B>, x: I) { 776 fn apply_add<I: Instance<Pair<U, V>>>(&self, y: &mut Pair<A, B>, x: I) {
774 let Pair(u, v) = x.decompose(); 777 x.eval_decompose(|Pair(u, v)| {
775 self.0.apply_add(&mut y.0, u); 778 self.0.apply_add(&mut y.0, u);
776 self.1.apply_add(&mut y.1, v); 779 self.1.apply_add(&mut y.1, v);
780 })
777 } 781 }
778 } 782 }
779 783
780 impl<A, B, Xʹ, Yʹ, R, S, T> Adjointable<Pair<A, B>, Pair<Xʹ, Yʹ>> for DiagOp<S, T> 784 impl<A, B, Xʹ, Yʹ, R, S, T> Adjointable<Pair<A, B>, Pair<Xʹ, Yʹ>> for DiagOp<S, T>
781 where 785 where

Mercurial Repository: alg_tools

mercurial