1 ///////////////////////////////////////////////////////////////////////////////
2 //                                                                           //
3 // The Template Matrix/Vector Library for C++ was created by Mike Jarvis     //
4 // Copyright (C) 1998 - 2016                                                 //
5 // All rights reserved                                                       //
6 //                                                                           //
7 // The project is hosted at https://code.google.com/p/tmv-cpp/               //
8 // where you can find the current version and current documention.           //
9 //                                                                           //
10 // For concerns or problems with the software, Mike may be contacted at      //
11 // mike_jarvis17 [at] gmail.                                                 //
12 //                                                                           //
13 // This software is licensed under a FreeBSD license.  The file              //
14 // TMV_LICENSE should have bee included with this distribution.              //
15 // It not, you can get a copy from https://code.google.com/p/tmv-cpp/.       //
16 //                                                                           //
17 // Essentially, you can use this software however you want provided that     //
18 // you include the TMV_LICENSE file in any distribution that uses it.        //
19 //                                                                           //
20 ///////////////////////////////////////////////////////////////////////////////
21 
22 
23 #ifndef TMV_TriMatrixArithFunc_H
24 #define TMV_TriMatrixArithFunc_H
25 
26 #include "tmv/TMV_BaseTriMatrix.h"
27 #include "tmv/TMV_Array.h"
28 
29 #define CT std::complex<T>
30 
31 namespace tmv {
32 
33     // y (+)= alpha * A * x
34     template <bool add, typename T, typename Ta, typename Tx>
35     void MultMV(
36         const T alpha, const GenUpperTriMatrix<Ta>& A,
37         const GenVector<Tx>& x, VectorView<T> y);
38     template <bool add, typename T, typename Ta, typename Tx>
39     void MultMV(
40         const T alpha, const GenLowerTriMatrix<Ta>& A,
41         const GenVector<Tx>& x, VectorView<T> y);
42 
43     // A = alpha * A
44     template <typename T>
45     void MultXM(const T alpha, UpperTriMatrixView<T> A);
46     template <typename T>
MultXM(const T alpha,LowerTriMatrixView<T> A)47     inline void MultXM(const T alpha, LowerTriMatrixView<T> A)
48     { MultXM(alpha,A.transpose()); }
49 
50     // B += alpha * A
51     template <typename T, typename Ta>
52     void AddMM(
53         const T alpha, const GenUpperTriMatrix<Ta>& A,
54         UpperTriMatrixView<T> B);
55     template <typename T, typename Ta>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,LowerTriMatrixView<T> B)56     inline void AddMM(
57         const T alpha, const GenLowerTriMatrix<Ta>& A,
58         LowerTriMatrixView<T> B)
59     { AddMM(alpha,A.transpose(),B.transpose()); }
60     template <typename T, typename Ta>
AddMM(const T alpha,const GenUpperTriMatrix<Ta> & A,MatrixView<T> B)61     inline void AddMM(
62         const T alpha, const GenUpperTriMatrix<Ta>& A,
63         MatrixView<T> B)
64     { AddMM(alpha,A,B.upperTri()); }
65     template <typename T, typename Ta>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,MatrixView<T> B)66     inline void AddMM(
67         const T alpha, const GenLowerTriMatrix<Ta>& A,
68         MatrixView<T> B)
69     { AddMM(alpha,A.transpose(),B.lowerTri().transpose()); }
70     // C = alpha * A + beta * B
71     template <typename T, typename Ta, typename Tb>
72     void AddMM(
73         const T alpha, const GenUpperTriMatrix<Ta>& A,
74         const T beta, const GenUpperTriMatrix<Tb>& B,
75         UpperTriMatrixView<T> C);
76     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const T beta,const GenLowerTriMatrix<Tb> & B,LowerTriMatrixView<T> C)77     inline void AddMM(
78         const T alpha, const GenLowerTriMatrix<Ta>& A,
79         const T beta, const GenLowerTriMatrix<Tb>& B,
80         LowerTriMatrixView<T> C)
81     { AddMM(alpha,A.transpose(),beta,B.transpose(),C.transpose()); }
82     template <typename T, typename Ta, typename Tb>
83     void AddMM(
84         const T alpha, const GenUpperTriMatrix<Ta>& A,
85         const T beta, const GenMatrix<Tb>& B, MatrixView<T> C);
86     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenMatrix<Ta> & A,const T beta,const GenUpperTriMatrix<Tb> & B,MatrixView<T> C)87     inline void AddMM(
88         const T alpha, const GenMatrix<Ta>& A,
89         const T beta, const GenUpperTriMatrix<Tb>& B, MatrixView<T> C)
90     { AddMM(beta,B,alpha,A,C); }
91     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const T beta,const GenMatrix<Tb> & B,MatrixView<T> C)92     inline void AddMM(
93         const T alpha, const GenLowerTriMatrix<Ta>& A,
94         const T beta, const GenMatrix<Tb>& B, MatrixView<T> C)
95     { AddMM(alpha,A.transpose(),beta,B.transpose(),C.transpose()); }
96     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenMatrix<Ta> & A,const T beta,const GenLowerTriMatrix<Tb> & B,MatrixView<T> C)97     inline void AddMM(
98         const T alpha, const GenMatrix<Ta>& A,
99         const T beta, const GenLowerTriMatrix<Tb>& B, MatrixView<T> C)
100     { AddMM(beta,B.transpose(),alpha,A.transpose(),C.transpose()); }
101     template <typename T, typename Ta, typename Tb>
102     void AddMM(
103         const T alpha, const GenUpperTriMatrix<Ta>& A,
104         const T beta, const GenLowerTriMatrix<Tb>& B, MatrixView<T> C);
105     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const T beta,const GenUpperTriMatrix<Tb> & B,MatrixView<T> C)106     inline void AddMM(
107         const T alpha, const GenLowerTriMatrix<Ta>& A,
108         const T beta, const GenUpperTriMatrix<Tb>& B, MatrixView<T> C)
109     { AddMM(beta,B,alpha,A,C); }
110 
111     // C (+)= alpha * A * B
112     template <bool add, typename T, typename Ta, typename Tb>
113     void MultMM(
114         const T alpha, const GenUpperTriMatrix<Ta>& A,
115         const GenMatrix<Tb>& B, MatrixView<T> C);
116     template <bool add, typename T, typename Ta, typename Tb>
117     void MultMM(
118         const T alpha, const GenLowerTriMatrix<Ta>& A,
119         const GenMatrix<Tb>& B, MatrixView<T> C);
120     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenMatrix<Ta> & A,const GenUpperTriMatrix<Tb> & B,MatrixView<T> C)121     inline void MultMM(
122         const T alpha, const GenMatrix<Ta>& A,
123         const GenUpperTriMatrix<Tb>& B, MatrixView<T> C)
124     { MultMM<add>(alpha,B.transpose(),A.transpose(),C.transpose()); }
125     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenMatrix<Ta> & A,const GenLowerTriMatrix<Tb> & B,MatrixView<T> C)126     inline void MultMM(
127         const T alpha, const GenMatrix<Ta>& A,
128         const GenLowerTriMatrix<Tb>& B, MatrixView<T> C)
129     { MultMM<add>(alpha,B.transpose(),A.transpose(),C.transpose()); }
130 
131     template <bool add, typename T, typename Ta, typename Tb>
132     void MultMM(
133         const T alpha, const GenUpperTriMatrix<Ta>& A,
134         const GenUpperTriMatrix<Tb>& B, UpperTriMatrixView<T> C);
135     template <bool add, typename T, typename Ta, typename Tb>
136     void MultMM(
137         const T alpha, const GenUpperTriMatrix<Ta>& A,
138         const GenLowerTriMatrix<Tb>& B, MatrixView<T> C);
139     template <bool add, typename T, typename Ta, typename Tb>
140     void MultMM(
141         const T alpha, const GenLowerTriMatrix<Ta>& A,
142         const GenUpperTriMatrix<Tb>& B, MatrixView<T> C);
143     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const GenLowerTriMatrix<Tb> & B,LowerTriMatrixView<T> C)144     inline void MultMM(
145         const T alpha, const GenLowerTriMatrix<Ta>& A,
146         const GenLowerTriMatrix<Tb>& B, LowerTriMatrixView<T> C)
147     { MultMM<add>(alpha,B.transpose(),A.transpose(),C.transpose()); }
148 
149     template <bool add, typename T, typename Ta, typename Tb>
150     void ElemMultMM(
151         const T alpha, const GenUpperTriMatrix<Ta>& A,
152         const GenUpperTriMatrix<Tb>& B, UpperTriMatrixView<T> C);
153     template <bool add, typename T, typename Ta, typename Tb>
ElemMultMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const GenLowerTriMatrix<Tb> & B,LowerTriMatrixView<T> C)154     inline void ElemMultMM(
155         const T alpha, const GenLowerTriMatrix<Ta>& A,
156         const GenLowerTriMatrix<Tb>& B, LowerTriMatrixView<T> C)
157     { ElemMultMM<add>(alpha,A.transpose(),B.transpose(),C.transpose()); }
158 
159     template <typename T>
160     class UpperTriMatrixComposite : public GenUpperTriMatrix<T>
161     {
162     public:
163 
UpperTriMatrixComposite()164         inline UpperTriMatrixComposite() {}
UpperTriMatrixComposite(const UpperTriMatrixComposite<T> &)165         inline UpperTriMatrixComposite(const UpperTriMatrixComposite<T>&) {}
~UpperTriMatrixComposite()166         virtual inline ~UpperTriMatrixComposite() {}
167         const T* cptr() const;
168         ptrdiff_t stepi() const;
169         ptrdiff_t stepj() const;
ct()170         inline ConjType ct() const { return NonConj; }
171 
172     private:
173         mutable AlignedArray<T> itsm;
174     };
175 
176     template <typename T>
177     class LowerTriMatrixComposite : public GenLowerTriMatrix<T>
178     {
179     public:
180 
LowerTriMatrixComposite()181         inline LowerTriMatrixComposite() {}
LowerTriMatrixComposite(const LowerTriMatrixComposite<T> &)182         inline LowerTriMatrixComposite(const LowerTriMatrixComposite<T>&) {}
~LowerTriMatrixComposite()183         virtual inline ~LowerTriMatrixComposite() {}
184         const T* cptr() const;
185         ptrdiff_t stepi() const;
186         ptrdiff_t stepj() const;
ct()187         inline ConjType ct() const { return NonConj; }
188 
189     private:
190         mutable AlignedArray<T> itsm;
191     };
192 
193     // Specialize allowed complex combinations:
194     template <bool add, typename T, typename Ta, typename Tx>
MultMV(const T alpha,const GenUpperTriMatrix<Ta> & A,const GenVector<Tx> & x,VectorView<CT> y)195     inline void MultMV(
196         const T alpha, const GenUpperTriMatrix<Ta>& A,
197         const GenVector<Tx>& x, VectorView<CT> y)
198     { MultMV<add>(CT(alpha),A,x,y); }
199     template <bool add, typename T, typename Ta, typename Tx>
MultMV(const T alpha,const GenLowerTriMatrix<Ta> & A,const GenVector<Tx> & x,VectorView<CT> y)200     inline void MultMV(
201         const T alpha, const GenLowerTriMatrix<Ta>& A,
202         const GenVector<Tx>& x, VectorView<CT> y)
203     { MultMV<add>(CT(alpha),A,x,y); }
204 
205     template <typename T>
MultXM(const T alpha,UpperTriMatrixView<CT> A)206     inline void MultXM(const T alpha, UpperTriMatrixView<CT> A)
207     { MultXM(CT(alpha),A); }
208     template <typename T>
MultXM(const T alpha,LowerTriMatrixView<CT> A)209     inline void MultXM(const T alpha, LowerTriMatrixView<CT> A)
210     { MultXM(CT(alpha),A); }
211 
212     template <typename T, typename Ta>
AddMM(const T alpha,const GenUpperTriMatrix<Ta> & A,UpperTriMatrixView<CT> B)213     inline void AddMM(
214         const T alpha, const GenUpperTriMatrix<Ta>& A,
215         UpperTriMatrixView<CT> B)
216     { AddMM(CT(alpha),A,B); }
217     template <typename T, typename Ta>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,LowerTriMatrixView<CT> B)218     inline void AddMM(
219         const T alpha, const GenLowerTriMatrix<Ta>& A,
220         LowerTriMatrixView<CT> B)
221     { AddMM(CT(alpha),A,B); }
222     template <typename T, typename Ta>
AddMM(const T alpha,const GenUpperTriMatrix<Ta> & A,MatrixView<CT> B)223     inline void AddMM(
224         const T alpha, const GenUpperTriMatrix<Ta>& A, MatrixView<CT> B)
225     { AddMM(CT(alpha),A,B); }
226     template <typename T, typename Ta>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,MatrixView<CT> B)227     inline void AddMM(
228         const T alpha, const GenLowerTriMatrix<Ta>& A, MatrixView<CT> B)
229     { AddMM(CT(alpha),A,B); }
230     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenUpperTriMatrix<Ta> & A,const T beta,const GenUpperTriMatrix<Tb> & B,UpperTriMatrixView<CT> C)231     inline void AddMM(
232         const T alpha, const GenUpperTriMatrix<Ta>& A,
233         const T beta, const GenUpperTriMatrix<Tb>& B,
234         UpperTriMatrixView<CT> C)
235     { AddMM(CT(alpha),A,CT(beta),B,C); }
236     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const T beta,const GenLowerTriMatrix<Tb> & B,LowerTriMatrixView<CT> C)237     inline void AddMM(
238         const T alpha, const GenLowerTriMatrix<Ta>& A,
239         const T beta, const GenLowerTriMatrix<Tb>& B,
240         LowerTriMatrixView<CT> C)
241     { AddMM(CT(alpha),A,CT(beta),B,C); }
242     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenUpperTriMatrix<Ta> & A,const T beta,const GenMatrix<Tb> & B,MatrixView<CT> C)243     inline void AddMM(
244         const T alpha, const GenUpperTriMatrix<Ta>& A,
245         const T beta, const GenMatrix<Tb>& B, MatrixView<CT> C)
246     { AddMM(CT(alpha),A,CT(beta),B,C); }
247     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenMatrix<Ta> & A,const T beta,const GenUpperTriMatrix<Tb> & B,MatrixView<CT> C)248     inline void AddMM(
249         const T alpha, const GenMatrix<Ta>& A,
250         const T beta, const GenUpperTriMatrix<Tb>& B, MatrixView<CT> C)
251     { AddMM(CT(alpha),A,CT(beta),B,C); }
252     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const T beta,const GenMatrix<Tb> & B,MatrixView<CT> C)253     inline void AddMM(
254         const T alpha, const GenLowerTriMatrix<Ta>& A,
255         const T beta, const GenMatrix<Tb>& B, MatrixView<CT> C)
256     { AddMM(CT(alpha),A,CT(beta),B,C); }
257     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenMatrix<Ta> & A,const T beta,const GenLowerTriMatrix<Tb> & B,MatrixView<CT> C)258     inline void AddMM(
259         const T alpha, const GenMatrix<Ta>& A,
260         const T beta, const GenLowerTriMatrix<Tb>& B, MatrixView<CT> C)
261     { AddMM(CT(alpha),A,CT(beta),B,C); }
262     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenUpperTriMatrix<Ta> & A,const T beta,const GenLowerTriMatrix<Tb> & B,MatrixView<CT> C)263     inline void AddMM(
264         const T alpha, const GenUpperTriMatrix<Ta>& A,
265         const T beta, const GenLowerTriMatrix<Tb>& B, MatrixView<CT> C)
266     { AddMM(CT(alpha),A,CT(beta),B,C); }
267     template <typename T, typename Ta, typename Tb>
AddMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const T beta,const GenUpperTriMatrix<Tb> & B,MatrixView<CT> C)268     inline void AddMM(
269         const T alpha, const GenLowerTriMatrix<Ta>& A,
270         const T beta, const GenUpperTriMatrix<Tb>& B, MatrixView<CT> C)
271     { AddMM(CT(alpha),A,CT(beta),B,C); }
272     template <typename T>
AddMM(const CT alpha,const GenUpperTriMatrix<CT> & A,const CT beta,const GenUpperTriMatrix<T> & B,UpperTriMatrixView<CT> C)273     inline void AddMM(
274         const CT alpha, const GenUpperTriMatrix<CT>& A,
275         const CT beta, const GenUpperTriMatrix<T>& B,
276         UpperTriMatrixView<CT> C)
277     { AddMM(beta,B,alpha,A,C); }
278 
279     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenUpperTriMatrix<Ta> & A,const GenMatrix<Tb> & B,MatrixView<CT> C)280     inline void MultMM(
281         const T alpha, const GenUpperTriMatrix<Ta>& A,
282         const GenMatrix<Tb>& B, MatrixView<CT> C)
283     { MultMM<add>(CT(alpha),A,B,C); }
284     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const GenMatrix<Tb> & B,MatrixView<CT> C)285     inline void MultMM(
286         const T alpha, const GenLowerTriMatrix<Ta>& A,
287         const GenMatrix<Tb>& B, MatrixView<CT> C)
288     { MultMM<add>(CT(alpha),A,B,C); }
289     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenMatrix<Ta> & A,const GenUpperTriMatrix<Tb> & B,MatrixView<CT> C)290     inline void MultMM(
291         const T alpha, const GenMatrix<Ta>& A,
292         const GenUpperTriMatrix<Tb>& B, MatrixView<CT> C)
293     { MultMM<add>(CT(alpha),A,B,C); }
294     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenMatrix<Ta> & A,const GenLowerTriMatrix<Tb> & B,MatrixView<CT> C)295     inline void MultMM(
296         const T alpha, const GenMatrix<Ta>& A,
297         const GenLowerTriMatrix<Tb>& B, MatrixView<CT> C)
298     { MultMM<add>(CT(alpha),A,B,C); }
299 
300     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenUpperTriMatrix<Ta> & A,const GenUpperTriMatrix<Tb> & B,UpperTriMatrixView<CT> C)301     inline void MultMM(
302         const T alpha, const GenUpperTriMatrix<Ta>& A,
303         const GenUpperTriMatrix<Tb>& B, UpperTriMatrixView<CT> C)
304     { MultMM<add>(CT(alpha),A,B,C); }
305     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenUpperTriMatrix<Ta> & A,const GenLowerTriMatrix<Tb> & B,MatrixView<CT> C)306     inline void MultMM(
307         const T alpha, const GenUpperTriMatrix<Ta>& A,
308         const GenLowerTriMatrix<Tb>& B, MatrixView<CT> C)
309     { MultMM<add>(CT(alpha),A,B,C); }
310     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const GenUpperTriMatrix<Tb> & B,MatrixView<CT> C)311     inline void MultMM(
312         const T alpha, const GenLowerTriMatrix<Ta>& A,
313         const GenUpperTriMatrix<Tb>& B, MatrixView<CT> C)
314     { MultMM<add>(CT(alpha),A,B,C); }
315     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const GenLowerTriMatrix<Tb> & B,LowerTriMatrixView<CT> C)316     inline void MultMM(
317         const T alpha, const GenLowerTriMatrix<Ta>& A,
318         const GenLowerTriMatrix<Tb>& B, LowerTriMatrixView<CT> C)
319     { MultMM<add>(CT(alpha),A,B,C); }
320 
321     template <bool add, typename T, typename Ta, typename Tb>
ElemMultMM(const T alpha,const GenUpperTriMatrix<Ta> & A,const GenUpperTriMatrix<Tb> & B,UpperTriMatrixView<CT> C)322     inline void ElemMultMM(
323         const T alpha, const GenUpperTriMatrix<Ta>& A,
324         const GenUpperTriMatrix<Tb>& B, UpperTriMatrixView<CT> C)
325     { ElemMultMM<add>(CT(alpha),A,B,C); }
326     template <bool add, typename T, typename Ta, typename Tb>
ElemMultMM(const T alpha,const GenLowerTriMatrix<Ta> & A,const GenLowerTriMatrix<Tb> & B,LowerTriMatrixView<CT> C)327     inline void ElemMultMM(
328         const T alpha, const GenLowerTriMatrix<Ta>& A,
329         const GenLowerTriMatrix<Tb>& B, LowerTriMatrixView<CT> C)
330     { ElemMultMM<add>(CT(alpha),A,B,C); }
331 
332     // Specialize disallowed complex combinations:
333     template <bool add, typename T, typename Ta, typename Tb>
MultMV(const CT,const GenUpperTriMatrix<Ta> &,const GenVector<Tb> &,VectorView<T>)334     inline void MultMV(
335         const CT , const GenUpperTriMatrix<Ta>& ,
336         const GenVector<Tb>& , VectorView<T> )
337     { TMVAssert(TMV_FALSE); }
338     template <bool add, typename T, typename Ta, typename Tb>
MultMV(const CT,const GenLowerTriMatrix<Ta> &,const GenVector<Tb> &,VectorView<T>)339     inline void MultMV(
340         const CT , const GenLowerTriMatrix<Ta>& ,
341         const GenVector<Tb>& , VectorView<T> )
342     { TMVAssert(TMV_FALSE); }
343 
344     template <typename T>
MultXM(const CT,UpperTriMatrixView<T>)345     inline void MultXM(const CT , UpperTriMatrixView<T> )
346     { TMVAssert(TMV_FALSE); }
347     template <typename T>
MultXM(const CT,LowerTriMatrixView<T>)348     inline void MultXM(const CT , LowerTriMatrixView<T> )
349     { TMVAssert(TMV_FALSE); }
350 
351     template <typename T, typename Ta>
AddMM(const CT,const GenUpperTriMatrix<Ta> &,UpperTriMatrixView<T>)352     inline void AddMM(
353         const CT , const GenUpperTriMatrix<Ta>& , UpperTriMatrixView<T> )
354     { TMVAssert(TMV_FALSE); }
355     template <typename T, typename Ta>
AddMM(const CT,const GenLowerTriMatrix<Ta> &,LowerTriMatrixView<T>)356     inline void AddMM(
357         const CT , const GenLowerTriMatrix<Ta>& , LowerTriMatrixView<T> )
358     { TMVAssert(TMV_FALSE); }
359     template <typename T, typename Ta>
AddMM(const CT,const GenUpperTriMatrix<Ta> &,MatrixView<T>)360     inline void AddMM(
361         const CT , const GenUpperTriMatrix<Ta>& , MatrixView<T> )
362     { TMVAssert(TMV_FALSE); }
363     template <typename T, typename Ta>
AddMM(const CT,const GenLowerTriMatrix<Ta> &,MatrixView<T>)364     inline void AddMM(
365         const CT , const GenLowerTriMatrix<Ta>& , MatrixView<T> )
366     { TMVAssert(TMV_FALSE); }
367     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenUpperTriMatrix<Ta> &,const CT,const GenUpperTriMatrix<Tb> &,UpperTriMatrixView<T>)368     inline void AddMM(
369         const CT , const GenUpperTriMatrix<Ta>& ,
370         const CT , const GenUpperTriMatrix<Tb>& , UpperTriMatrixView<T> )
371     { TMVAssert(TMV_FALSE); }
372     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenLowerTriMatrix<Ta> &,const CT,const GenLowerTriMatrix<Tb> &,LowerTriMatrixView<T>)373     inline void AddMM(
374         const CT , const GenLowerTriMatrix<Ta>& ,
375         const CT , const GenLowerTriMatrix<Tb>& , LowerTriMatrixView<T> )
376     { TMVAssert(TMV_FALSE); }
377     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenMatrix<Ta> &,const CT,const GenUpperTriMatrix<Tb> &,MatrixView<T>)378     inline void AddMM(
379         const CT , const GenMatrix<Ta>& ,
380         const CT , const GenUpperTriMatrix<Tb>& , MatrixView<T> )
381     { TMVAssert(TMV_FALSE); }
382     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenMatrix<Ta> &,const CT,const GenLowerTriMatrix<Tb> &,MatrixView<T>)383     inline void AddMM(
384         const CT , const GenMatrix<Ta>& ,
385         const CT , const GenLowerTriMatrix<Tb>& , MatrixView<T> )
386     { TMVAssert(TMV_FALSE); }
387     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenUpperTriMatrix<Ta> &,const CT,const GenMatrix<Tb> &,MatrixView<T>)388     inline void AddMM(
389         const CT , const GenUpperTriMatrix<Ta>& ,
390         const CT , const GenMatrix<Tb>& , MatrixView<T> )
391     { TMVAssert(TMV_FALSE); }
392     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenLowerTriMatrix<Ta> &,const CT,const GenMatrix<Tb> &,MatrixView<T>)393     inline void AddMM(
394         const CT , const GenLowerTriMatrix<Ta>& ,
395         const CT , const GenMatrix<Tb>& , MatrixView<T> )
396     { TMVAssert(TMV_FALSE); }
397     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenUpperTriMatrix<Ta> &,const CT,const GenLowerTriMatrix<Tb> &,MatrixView<T>)398     inline void AddMM(
399         const CT , const GenUpperTriMatrix<Ta>& ,
400         const CT , const GenLowerTriMatrix<Tb>& , MatrixView<T> )
401     { TMVAssert(TMV_FALSE); }
402     template <typename T, typename Ta, typename Tb>
AddMM(const CT,const GenLowerTriMatrix<Ta> &,const CT,const GenUpperTriMatrix<Tb> &,MatrixView<T>)403     inline void AddMM(
404         const CT , const GenLowerTriMatrix<Ta>& ,
405         const CT , const GenUpperTriMatrix<Tb>& , MatrixView<T> )
406     { TMVAssert(TMV_FALSE); }
407 
408     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenUpperTriMatrix<Ta> &,const GenMatrix<Tb> &,MatrixView<T>)409     inline void MultMM(
410         const CT , const GenUpperTriMatrix<Ta>& ,
411         const GenMatrix<Tb>& , MatrixView<T> )
412     { TMVAssert(TMV_FALSE); }
413     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenMatrix<Ta> &,const GenUpperTriMatrix<Tb> &,MatrixView<T>)414     inline void MultMM(
415         const CT , const GenMatrix<Ta>& ,
416         const GenUpperTriMatrix<Tb>& , MatrixView<T> )
417     { TMVAssert(TMV_FALSE); }
418     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenUpperTriMatrix<Ta> &,const GenUpperTriMatrix<Tb> &,UpperTriMatrixView<T>)419     inline void MultMM(
420         const CT , const GenUpperTriMatrix<Ta>& ,
421         const GenUpperTriMatrix<Tb>& , UpperTriMatrixView<T> )
422     { TMVAssert(TMV_FALSE); }
423     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenLowerTriMatrix<Ta> &,const GenMatrix<Tb> &,MatrixView<T>)424     inline void MultMM(
425         const CT , const GenLowerTriMatrix<Ta>& ,
426         const GenMatrix<Tb>& , MatrixView<T> )
427     { TMVAssert(TMV_FALSE); }
428     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenMatrix<Ta> &,const GenLowerTriMatrix<Tb> &,MatrixView<T>)429     inline void MultMM(
430         const CT , const GenMatrix<Ta>& ,
431         const GenLowerTriMatrix<Tb>& , MatrixView<T> )
432     { TMVAssert(TMV_FALSE); }
433     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenLowerTriMatrix<Ta> &,const GenLowerTriMatrix<Tb> &,LowerTriMatrixView<T>)434     inline void MultMM(
435         const CT , const GenLowerTriMatrix<Ta>& ,
436         const GenLowerTriMatrix<Tb>& , LowerTriMatrixView<T> )
437     { TMVAssert(TMV_FALSE); }
438     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenUpperTriMatrix<Ta> &,const GenLowerTriMatrix<Tb> &,MatrixView<T>)439     inline void MultMM(
440         const CT , const GenUpperTriMatrix<Ta>& ,
441         const GenLowerTriMatrix<Tb>& , MatrixView<T> )
442     { TMVAssert(TMV_FALSE); }
443     template <bool add, typename T, typename Ta, typename Tb>
MultMM(const CT,const GenLowerTriMatrix<Ta> &,const GenUpperTriMatrix<Tb> &,MatrixView<T>)444     inline void MultMM(
445         const CT , const GenLowerTriMatrix<Ta>& ,
446         const GenUpperTriMatrix<Tb>& , MatrixView<T> )
447     { TMVAssert(TMV_FALSE); }
448 
449     template <bool add, typename T, typename Ta, typename Tb>
ElemMultMM(const CT,const GenUpperTriMatrix<Ta> &,const GenUpperTriMatrix<Tb> &,UpperTriMatrixView<T>)450     inline void ElemMultMM(
451         const CT , const GenUpperTriMatrix<Ta>& ,
452         const GenUpperTriMatrix<Tb>& , UpperTriMatrixView<T> )
453     { TMVAssert(TMV_FALSE); }
454     template <bool add, typename T, typename Ta, typename Tb>
ElemMultMM(const CT,const GenLowerTriMatrix<Ta> &,const GenLowerTriMatrix<Tb> &,LowerTriMatrixView<T>)455     inline void ElemMultMM(
456         const CT , const GenLowerTriMatrix<Ta>& ,
457         const GenLowerTriMatrix<Tb>& , LowerTriMatrixView<T> )
458     { TMVAssert(TMV_FALSE); }
459 
460 } // namespace tmv
461 
462 #undef CT
463 
464 #endif
465