00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 namespace TooN {
00034
00035
00055 template<int Size=Dynamic, typename Precision=DefaultPrecision, typename Base=Internal::VBase>
00056 struct DiagonalMatrix {
00057 public:
00058 inline DiagonalMatrix() {}
00059 inline DiagonalMatrix(int size_in) : my_vector(size_in) {}
00060 inline DiagonalMatrix(Precision* data) : my_vector(data) {}
00061 inline DiagonalMatrix(Precision* data, int size_in) : my_vector(data,size_in) {}
00062 inline DiagonalMatrix(Precision* data_in, int size_in, int stride_in, Internal::Slicing)
00063 : my_vector(data_in, size_in, stride_in, Internal::Slicing() ) {}
00064
00065
00066
00067
00068 template <class Op>
00069 inline DiagonalMatrix(const Operator<Op>& op)
00070 : my_vector (op)
00071 {
00072 op.eval(my_vector);
00073 }
00074
00075
00076 template<int Size2, typename Precision2, typename Base2>
00077 inline DiagonalMatrix(const Vector<Size2,Precision2,Base2>& from)
00078 : my_vector(from.size())
00079 {
00080 my_vector=from;
00081 }
00082
00083
00084 Precision& operator[](int i){return my_vector[i];}
00085 const Precision& operator[](int i) const {return my_vector[i];}
00086
00087 typename Vector<Size, Precision, Base>::as_slice_type diagonal_slice() {
00088 return my_vector.as_slice();
00089 }
00090
00091
00092 Vector<Size,Precision,Base> my_vector;
00093 };
00094
00095
00096 template<int S1, typename P1, typename B1, int S2, typename P2, typename B2>
00097 inline Vector<Internal::Sizer<S1,S2>::size, typename Internal::MultiplyType<P1,P2>::type>
00098 operator*(const DiagonalMatrix<S1,P1,B1>& d, const Vector<S2,P2,B2>& v){
00099 return diagmult(d.my_vector,v);
00100 }
00101
00102 template<int S1, typename P1, typename B1, int S2, typename P2, typename B2>
00103 inline Vector<Internal::Sizer<S1,S2>::size, typename Internal::MultiplyType<P1,P2>::type>
00104 operator*( const Vector<S1,P1,B1>& v, const DiagonalMatrix<S2,P2,B2>& d){
00105 return diagmult(v,d.my_vector);
00106 }
00107
00108
00109 template<int S1, typename P1, typename B1, int S2, typename P2, typename B2>
00110 inline DiagonalMatrix<Internal::Sizer<S1,S2>::size, typename Internal::MultiplyType<P1,P2>::type>
00111 operator*( const DiagonalMatrix<S1,P1,B1>& d1, const DiagonalMatrix<S2,P2,B2>& d2){
00112 SizeMismatch<S1,S2>::test(d1.my_vector.size(),d2.my_vector.size());
00113 return Operator<Internal::VPairwise<Internal::Multiply,S1,P1,B1,S2,P2,B2> >(d1.my_vector,d2.my_vector);
00114 }
00115
00116 template<int R, int C, int Size, typename P1, typename P2, typename B1, typename B2>
00117 Matrix<R, C, typename Internal::MultiplyType<P1,P2>::type>
00118 operator* (const Matrix<R, C, P1, B1>& m, const DiagonalMatrix<Size, P2, B2>& d){
00119 return diagmult(m,d.my_vector);
00120 }
00121
00122 template<int R, int C, typename P1, typename B1, int Size, typename P2, typename B2>
00123 Matrix<R, C, typename Internal::MultiplyType<P1,P2>::type>
00124 operator* (const DiagonalMatrix<Size,P1,B1>& d, const Matrix<R,C,P2,B2>& m)
00125 {
00126 return diagmult(d.my_vector, m);
00127 }
00128
00129 }