C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
scimatrix.hpp
1/*
2** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3**
4** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5** Universitaet Karlsruhe, Germany
6** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7** Universitaet Wuppertal, Germany
8**
9** This library is free software; you can redistribute it and/or
10** modify it under the terms of the GNU Library General Public
11** License as published by the Free Software Foundation; either
12** version 2 of the License, or (at your option) any later version.
13**
14** This library is distributed in the hope that it will be useful,
15** but WITHOUT ANY WARRANTY; without even the implied warranty of
16** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17** Library General Public License for more details.
18**
19** You should have received a copy of the GNU Library General Public
20** License along with this library; if not, write to the Free
21** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22*/
23
24/* CVS $Id: scimatrix.hpp,v 1.20 2014/01/30 17:23:48 cxsc Exp $ */
25
26#ifndef _CXSC_SCIMATRIX_HPP_INCLUDED
27#define _CXSC_SCIMATRIX_HPP_INCLUDED
28
29#include <cinterval.hpp>
30#include <cimatrix.hpp>
31#include <civector.hpp>
32#include <cidot.hpp>
33#include <vector>
34#include <algorithm>
35#include <iostream>
36#include <sparsecidot.hpp>
37#include <sparsematrix.hpp>
38#include <srmatrix.hpp>
39#include <scmatrix.hpp>
40#include <simatrix.hpp>
41#include <srvector.hpp>
42#include <sivector.hpp>
43#include <scvector.hpp>
44#include <scivector.hpp>
45
46namespace cxsc {
47
48//definiert in srmatrix.hpp
49//enum STORAGE_TYPE{triplet,compressed_row,compressed_column};
50
51class scimatrix_slice;
52class scimatrix_subv;
53
54inline bool comp_pair_ci(std::pair<int,cinterval> p1, std::pair<int,cinterval> p2) {
55 return p1.first < p2.first;
56}
57
59
71class scimatrix {
72
73 private:
74 std::vector<int> p;
75 std::vector<int> ind;
76 std::vector<cinterval> x;
77 int m;
78 int n;
79 int lb1,ub1,lb2,ub2;
80
81 public:
82
84 std::vector<int>& column_pointers() {
85 return p;
86 }
87
89 std::vector<int>& row_indices() {
90 return ind;
91 }
92
94 std::vector<cinterval>& values() {
95 return x;
96 }
97
99 const std::vector<int>& column_pointers() const {
100 return p;
101 }
102
104 const std::vector<int>& row_indices() const {
105 return ind;
106 }
107
109 const std::vector<cinterval>& values() const {
110 return x;
111 }
112
115 p.push_back(0);
116 m = n = 0;
117 lb1 = lb2 = ub1 = ub2 = 0;
118 }
119
121 scimatrix(const int r, const int c) : m(r),n(c),lb1(1),ub1(r),lb2(1),ub2(c) {
122 p = std::vector<int>((n>0) ? n+1 : 1, 0);
123 ind.reserve(2*(m+n));
124 x.reserve(2*(m+n));
125
126 p[0] = 0;
127 }
128
130 scimatrix(const int r, const int c, const int e) : m(r),n(c),lb1(1),ub1(r),lb2(1),ub2(c) {
131 p = std::vector<int>((n>0) ? n+1 : 1, 0);
132 ind.reserve(e);
133 x.reserve(e);
134
135 p[0] = 0;
136 }
137
139
145 scimatrix(const int m, const int n, const int nnz, const intvector& rows, const intvector& cols, const civector& values, const enum STORAGE_TYPE t = triplet) {
146 if(t == triplet) {
147 this->m = m;
148 this->n = n;
149 p = std::vector<int>(n+1,0);
150 ind.reserve(nnz);
151 x.reserve(nnz);
152 lb1 = lb2 = 1;
153 ub1 = m; ub2 = n;
154
155 std::vector<triplet_store<cinterval> > work;
156 work.reserve(nnz);
157
158 for(int k=0 ; k<nnz ; k++) {
159 work.push_back(triplet_store<cinterval>(rows[Lb(rows)+k],cols[Lb(cols)+k],values[Lb(values)+k]));
160 }
161
162 sort(work.begin(), work.end());
163
164 int i=0;
165
166 for(int j=0 ; j<n ; j++) {
167
168 while((unsigned int)i < work.size() && work[i].col == j ) {
169 ind.push_back(work[i].row);
170 x.push_back(work[i].val);
171 i++;
172 }
173
174 p[j+1] = i;
175 }
176
177 } else if(t == compressed_row) {
178
179 this->m = m;
180 this->n = n;
181 p = std::vector<int>(n+1,0);
182 ind.reserve(nnz);
183 x.reserve(nnz);
184 lb1 = lb2 = 1;
185 ub1 = m; ub2 = n;
186
187 for(int i=0 ; i<n+1 ; i++)
188 p[i] = rows[Lb(rows)+i];
189
190 std::vector<triplet_store<cinterval> > work;
191 work.reserve(nnz);
192
193 for(int j=0 ; j<n ; j++) {
194 for(int k=p[j] ; k<p[j+1] ; k++) {
195 work.push_back(triplet_store<cinterval>(j,cols[Lb(cols)+k],values[Lb(values)+k]));
196 }
197 }
198
199 sort(work.begin(), work.end());
200
201 int i=0;
202
203 for(int j=0 ; j<n ; j++) {
204
205 while((unsigned int)i < work.size() && work[i].col == j ) {
206 ind.push_back(work[i].row);
207 x.push_back(work[i].val);
208 i++;
209 }
210
211 p[j+1] = i;
212 }
213
214 } else if(t == compressed_column) {
215 this->m = m;
216 this->n = n;
217 p = std::vector<int>(n+1,0);
218 ind.reserve(nnz);
219 x.reserve(nnz);
220 lb1 = lb2 = 1;
221 ub1 = m; ub2 = n;
222
223 for(int i=0 ; i<n+1 ; i++)
224 p[i] = rows[Lb(rows)+i];
225
226 std::vector<std::pair<int,cinterval> > work;
227 work.reserve(n);
228
229 for(int j=0 ; j<n ; j++) {
230 work.clear();
231
232 for(int k=p[j] ; k<p[j+1] ; k++) {
233 work.push_back(std::make_pair(cols[Lb(cols)+k],values[Lb(values)+k]));
234 }
235
236 std::sort(work.begin(),work.end(),comp_pair_ci);
237
238 for(unsigned int i=0 ; i<work.size() ; i++) {
239 ind.push_back(work[i].first);
240 x.push_back(work[i].second);
241 }
242 }
243
244 }
245
246 }
247
249
256 scimatrix(const int m, const int n, const int nnz, const int* rows, const int* cols, const cinterval* values, const enum STORAGE_TYPE t = triplet) {
257 if(t == triplet) {
258 this->m = m;
259 this->n = n;
260 p = std::vector<int>(n+1,0);
261 ind.reserve(nnz);
262 x.reserve(nnz);
263 lb1 = lb2 = 1;
264 ub1 = m; ub2 = n;
265
266 std::vector<triplet_store<cinterval> > work;
267 work.reserve(nnz);
268
269 for(int k=0 ; k<nnz ; k++) {
270 work.push_back(triplet_store<cinterval>(rows[k],cols[k],values[k]));
271 }
272
273 sort(work.begin(), work.end());
274
275 int i=0;
276
277 for(int j=0 ; j<n ; j++) {
278
279 while((unsigned int)i < work.size() && work[i].col == j ) {
280 ind.push_back(work[i].row);
281 x.push_back(work[i].val);
282 i++;
283 }
284
285 p[j+1] = i;
286 }
287
288 } else if(t == compressed_row) {
289
290 this->m = m;
291 this->n = n;
292 p = std::vector<int>(n+1,0);
293 ind.reserve(nnz);
294 x.reserve(nnz);
295 lb1 = lb2 = 1;
296 ub1 = m; ub2 = n;
297
298 for(int i=0 ; i<n+1 ; i++)
299 p[i] = rows[i];
300
301 std::vector<triplet_store<cinterval> > work;
302 work.reserve(nnz);
303
304 for(int j=0 ; j<n ; j++) {
305 for(int k=p[j] ; k<p[j+1] ; k++) {
306 work.push_back(triplet_store<cinterval>(j,cols[k],values[k]));
307 }
308 }
309
310 sort(work.begin(), work.end());
311
312 int i=0;
313
314 for(int j=0 ; j<n ; j++) {
315
316 while((unsigned int)i < work.size() && work[i].col == j ) {
317 ind.push_back(work[i].row);
318 x.push_back(work[i].val);
319 i++;
320 }
321
322 p[j+1] = i;
323 }
324
325 } else if(t == compressed_column) {
326 this->m = m;
327 this->n = n;
328 p = std::vector<int>(n+1,0);
329 ind.reserve(nnz);
330 x.reserve(nnz);
331 lb1 = lb2 = 1;
332 ub1 = m; ub2 = n;
333
334 for(int i=0 ; i<n+1 ; i++)
335 p[i] = rows[i];
336
337 std::vector<std::pair<int,cinterval> > work;
338 work.reserve(n);
339
340 for(int j=0 ; j<n ; j++) {
341 work.clear();
342
343 for(int k=p[j] ; k<p[j+1] ; k++) {
344 work.push_back(std::make_pair(cols[k],values[k]));
345 }
346
347 std::sort(work.begin(),work.end(),comp_pair_ci);
348
349 for(unsigned int i=0 ; i<work.size() ; i++) {
350 ind.push_back(work[i].first);
351 x.push_back(work[i].second);
352 }
353 }
354
355 }
356
357 }
358
360 scimatrix(const srmatrix& A) : p(A.p), ind(A.ind), m(A.m), n(A.n), lb1(A.lb1), ub1(A.ub1), lb2(A.lb2), ub2(A.ub2) {
361 x.reserve(A.get_nnz());
362 for(unsigned int i=0 ; i<A.x.size() ; i++)
363 x.push_back(cinterval(A.x[i]));
364 }
365
367 scimatrix(const scmatrix& A) : p(A.p), ind(A.ind), m(A.m), n(A.n), lb1(A.lb1), ub1(A.ub1), lb2(A.lb2), ub2(A.ub2) {
368 x.reserve(A.get_nnz());
369 for(unsigned int i=0 ; i<A.x.size() ; i++)
370 x.push_back(cinterval(A.x[i]));
371 }
372
374 scimatrix(const simatrix& A) : p(A.p), ind(A.ind), m(A.m), n(A.n), lb1(A.lb1), ub1(A.ub1), lb2(A.lb2), ub2(A.ub2) {
375 x.reserve(A.get_nnz());
376 for(unsigned int i=0 ; i<A.x.size() ; i++)
377 x.push_back(cinterval(A.x[i]));
378 }
379
381 scimatrix(const rmatrix& A) : m(ColLen(A)),n(RowLen(A)),lb1(Lb(A,1)),ub1(Ub(A,1)),lb2(Lb(A,2)),ub2(Ub(A,2)) {
382 p = std::vector<int>((n>0) ? n+1 : 1, 0);
383 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
384 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
385
386 p[0] = 0;
387 int nnz = 0;
388
389 for(int j=0 ; j<n ; j++) {
390 for(int i=0 ; i<m ; i++) {
391 if(A[i+lb1][j+lb2] != 0.0) {
392 ind.push_back(i);
393 x.push_back(cinterval(A[i+lb1][j+lb2]));
394 nnz++;
395 }
396 }
397
398 p[j+1] = nnz;
399 }
400
401 }
402
404 scimatrix(const cmatrix& A) : m(ColLen(A)),n(RowLen(A)),lb1(Lb(A,1)),ub1(Ub(A,1)),lb2(Lb(A,2)),ub2(Ub(A,2)) {
405 p = std::vector<int>((n>0) ? n+1 : 1, 0);
406 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
407 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
408
409 p[0] = 0;
410 int nnz = 0;
411
412 for(int j=0 ; j<n ; j++) {
413 for(int i=0 ; i<m ; i++) {
414 if(A[i+lb1][j+lb2] != 0.0) {
415 ind.push_back(i);
416 x.push_back(cinterval(A[i+lb1][j+lb2]));
417 nnz++;
418 }
419 }
420
421 p[j+1] = nnz;
422 }
423
424 }
425
427 scimatrix(const imatrix& A) : m(ColLen(A)),n(RowLen(A)),lb1(Lb(A,1)),ub1(Ub(A,1)),lb2(Lb(A,2)),ub2(Ub(A,2)) {
428 p = std::vector<int>((n>0) ? n+1 : 1, 0);
429 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
430 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
431
432 p[0] = 0;
433 int nnz = 0;
434
435 for(int j=0 ; j<n ; j++) {
436 for(int i=0 ; i<m ; i++) {
437 if(A[i+lb1][j+lb2] != 0.0) {
438 ind.push_back(i);
439 x.push_back(cinterval(A[i+lb1][j+lb2]));
440 nnz++;
441 }
442 }
443
444 p[j+1] = nnz;
445 }
446
447 }
448
450 scimatrix(const cimatrix& A) : m(ColLen(A)),n(RowLen(A)),lb1(Lb(A,1)),ub1(Ub(A,1)),lb2(Lb(A,2)),ub2(Ub(A,2)) {
451 p = std::vector<int>((n>0) ? n+1 : 1, 0);
452 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
453 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
454
455 p[0] = 0;
456 int nnz = 0;
457
458 for(int j=0 ; j<n ; j++) {
459 for(int i=0 ; i<m ; i++) {
460 if(A[i+lb1][j+lb2] != 0.0) {
461 ind.push_back(i);
462 x.push_back(A[i+lb1][j+lb2]);
463 nnz++;
464 }
465 }
466
467 p[j+1] = nnz;
468 }
469
470 }
471
473
476 scimatrix(const int ms, const int ns, const cimatrix& A) : m(ms), n(ns), lb1(1), ub1(ms), lb2(1), ub2(ns) {
477 //Banded matrix constructor
478 int nnz = RowLen(A)*ColLen(A);
479 p = std::vector<int>((n>0) ? n+1 : 1, 0);
480 ind.reserve(nnz);
481 x.reserve(nnz);
482
483 std::vector<triplet_store<cinterval> > work;
484 work.reserve(nnz);
485
486
487 for(int i=0 ; i<ColLen(A) ; i++) {
488 for(int j=Lb(A,2) ; j<=Ub(A,2) ; j++) {
489 if(i+j >=0 && i+j < n) {
490 work.push_back(triplet_store<cinterval>(i,i+j,A[i+Lb(A,1)][j]));
491 }
492 }
493 }
494
495 sort(work.begin(), work.end());
496
497 int i=0;
498
499 for(int j=0 ; j<n ; j++) {
500
501 while((unsigned int)i < work.size() && work[i].col == j ) {
502 ind.push_back(work[i].row);
503 x.push_back(work[i].val);
504 i++;
505 }
506
507 p[j+1] = i;
508 }
509
510 }
511
520
522 void full(cimatrix& A) const {
523 A = cimatrix(lb1,ub1,lb2,ub2);
524 A = 0.0;
525 for(int j=0 ; j<n ; j++) {
526 for(int k=p[j] ; k<p[j+1] ; k++) {
527 A[ind[k]+lb1][j+lb2] = x[k];
528 }
529 }
530 }
531
533
537 void dropzeros() {
538 std::vector<int> pnew(n+1,0);
539 std::vector<int> indnew;
540 std::vector<cinterval> xnew;
541 int nnznew = 0;
542
543 for(int j=0 ; j<n ; j++) {
544 for(int k=p[j] ; k<p[j+1] ; k++) {
545 if(x[k] != 0.0) {
546 xnew.push_back(x[k]);
547 indnew.push_back(ind[k]);
548 nnznew++;
549 }
550 }
551 pnew[j+1] = nnznew;
552 }
553
554 p = pnew;
555 ind = indnew;
556 x = xnew;
557 }
558
559
562 return sp_ms_assign<scimatrix,real,cinterval>(*this,A);
563 }
564
567 return sp_ms_assign<scimatrix,interval,cinterval>(*this,A);
568 }
569
572 return sp_ms_assign<scimatrix,complex,cinterval>(*this,A);
573 }
574
577 return sp_ms_assign<scimatrix,cinterval,cinterval>(*this,A);
578 }
579
582 return spf_mm_assign<scimatrix,rmatrix,cinterval>(*this,A);
583 }
584
587 return spf_mm_assign<scimatrix,cmatrix,cinterval>(*this,A);
588 }
589
592 return spf_mm_assign<scimatrix,imatrix,cinterval>(*this,A);
593 }
594
597 return spf_mm_assign<scimatrix,cimatrix,cinterval>(*this,A);
598 }
599
602 return spf_mm_assign<scimatrix,rmatrix_slice,cinterval>(*this,A);
603 }
604
607 return spf_mm_assign<scimatrix,cmatrix_slice,cinterval>(*this,A);
608 }
609
612 return spf_mm_assign<scimatrix,imatrix_slice,cinterval>(*this,A);
613 }
614
617 return spf_mm_assign<scimatrix,cimatrix_slice,cinterval>(*this,A);
618 }
619
622 m = A.m;
623 n = A.n;
624 p = A.p;
625 ind = A.ind;
626 x.clear();
627 x.reserve(A.get_nnz());
628 for(unsigned int i=0 ; i<A.x.size() ; i++)
629 x.push_back(cinterval(A.x[i]));
630 return *this;
631 }
632
635 m = A.m;
636 n = A.n;
637 p = A.p;
638 ind = A.ind;
639 x.clear();
640 x.reserve(A.get_nnz());
641 for(unsigned int i=0 ; i<A.x.size() ; i++)
642 x.push_back(cinterval(A.x[i]));
643 return *this;
644 }
645
648 m = A.m;
649 n = A.n;
650 p = A.p;
651 ind = A.ind;
652 x.clear();
653 x.reserve(A.get_nnz());
654 for(unsigned int i=0 ; i<A.x.size() ; i++)
655 x.push_back(cinterval(A.x[i]));
656 return *this;
657 }
658
659 /* scimatrix& operator=(const scimatrix& A) {
660 p = A.p;
661 ind = A.ind;
662 x = A.x;
663 return *this;
664 } */
665
674
676
682 const cinterval operator()(int i, int j) const {
683#if(CXSC_INDEX_CHECK)
684 if(i<lb1 || i>ub1 || j<lb2 || j>ub2)
685 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix::operator()(int, int)"));
686#endif
687 cinterval r(0.0);
688 for(int k=p[j-lb2] ; k<p[j-lb2+1] && ind[k]<=i-lb1 ; k++) {
689 if(ind[k] == i-lb1) r = x[k];
690 }
691 return r;
692 }
693
695
703 cinterval& element(int i, int j) {
704#if(CXSC_INDEX_CHECK)
705 if(i<lb1 || i>ub1 || j<lb2 || j>ub2)
706 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix::element(int, int)"));
707#endif
708 int k;
709 for(k=p[j-lb2] ; k<p[j-lb2+1] && ind[k]<=i-lb1 ; k++) {
710 if(ind[k] == i-lb1) return x[k];
711 }
712
713 //Nicht gefunden, Element muss angelegt werden, da Schreibzugriff moeglich
714 std::vector<int>::iterator ind_it = ind.begin() + k;
715 std::vector<cinterval>::iterator x_it = x.begin() + k;
716 ind.insert(ind_it, i-lb1);
717 x_it = x.insert(x_it, cinterval(0.0));
718 for(k=j-lb2+1 ; k<(int)p.size() ; k++)
719 p[k]++;
720
721 return *x_it;
722 }
723
725 scimatrix_subv operator[](const cxscmatrix_column&);
727 scimatrix_subv operator[](const int);
729 const scimatrix_subv operator[](const cxscmatrix_column&) const;
731 const scimatrix_subv operator[](const int) const;
732
734 scimatrix_slice operator()(const int, const int , const int, const int);
736 const scimatrix_slice operator()(const int, const int , const int, const int) const;
737
739 scimatrix operator()(const intvector& pervec, const intvector& q) {
740 scimatrix A(m,n,get_nnz());
741 intvector per = perminv(pervec);
742
743 int nnz=0;
744 for(int k=0 ; k<n ; k++) {
745 A.p[k] = nnz;
746
747 std::map<int,cinterval> work;
748 for(int j=p[q[Lb(q)+k]] ; j<p[q[Lb(q)+k]+1] ; j++)
749 work.insert(std::make_pair(per[Lb(per)+ind[j]], x[j]));
750
751 for(std::map<int,cinterval>::iterator it = work.begin() ; it != work.end() ; it++) {
752 A.ind.push_back(it->first);
753 A.x.push_back(it->second);
754 }
755
756 nnz += work.size();
757
758 }
759
760 A.p[n] = nnz;
761
762 return A;
763 }
764
767 scimatrix A(m,n,get_nnz());
768 intvector per = perminv(pervec);
769
770 for(int k=0 ; k<n ; k++) {
771 A.p[k] = p[k];
772
773 std::map<int,cinterval> work;
774 for(int j=p[k] ; j<p[k+1] ; j++)
775 work.insert(std::make_pair(per[Lb(per)+ind[j]], x[j]));
776
777 for(std::map<int,cinterval>::iterator it = work.begin() ; it != work.end() ; it++) {
778 A.ind.push_back(it->first);
779 A.x.push_back(it->second);
780 }
781
782 }
783
784 A.p[n] = p[n];
785
786 return A;
787 }
788
791 intvector p = permvec(P);
792 intvector q = perminv(permvec(Q));
793 return (*this)(p,q);
794 }
795
798 intvector p = permvec(P);
799 return (*this)(p);
800 }
801
803 real density() const {
804 return p[n]/((double)m*n);
805 }
806
808 int get_nnz() const {
809 return p[n];
810 }
811
814 return spf_mm_addassign<scimatrix,rmatrix,cimatrix>(*this,B);
815 }
816
819 return spf_mm_addassign<scimatrix,cmatrix,cimatrix>(*this,B);
820 }
821
824 return spf_mm_addassign<scimatrix,imatrix,cimatrix>(*this,B);
825 }
826
829 return spf_mm_addassign<scimatrix,cimatrix,cimatrix>(*this,B);
830 }
831
834 return spf_mm_addassign<scimatrix,rmatrix_slice,cimatrix>(*this,B);
835 }
836
839 return spf_mm_addassign<scimatrix,cmatrix_slice,cimatrix>(*this,B);
840 }
841
844 return spf_mm_addassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
845 }
846
849 return spf_mm_addassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
850 }
851
854 return spsp_mm_addassign<scimatrix,srmatrix,cinterval>(*this,B);
855 }
856
859 return spsp_mm_addassign<scimatrix,scmatrix,cinterval>(*this,B);
860 }
861
864 return spsp_mm_addassign<scimatrix,simatrix,cinterval>(*this,B);
865 }
866
869 return spsp_mm_addassign<scimatrix,scimatrix,cinterval>(*this,B);
870 }
871
874 return spf_mm_subassign<scimatrix,rmatrix,cimatrix>(*this,B);
875 }
876
879 return spf_mm_subassign<scimatrix,cmatrix,cimatrix>(*this,B);
880 }
881
884 return spf_mm_subassign<scimatrix,imatrix,cimatrix>(*this,B);
885 }
886
889 return spf_mm_subassign<scimatrix,cimatrix,cimatrix>(*this,B);
890 }
891
894 return spf_mm_subassign<scimatrix,rmatrix_slice,cimatrix>(*this,B);
895 }
896
899 return spf_mm_subassign<scimatrix,cmatrix_slice,cimatrix>(*this,B);
900 }
901
904 return spf_mm_subassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
905 }
906
909 return spf_mm_subassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
910 }
911
914 return spsp_mm_subassign<scimatrix,srmatrix,cinterval>(*this,B);
915 }
916
919 return spsp_mm_subassign<scimatrix,scmatrix,cinterval>(*this,B);
920 }
921
924 return spsp_mm_subassign<scimatrix,simatrix,cinterval>(*this,B);
925 }
926
929 return spsp_mm_subassign<scimatrix,scimatrix,cinterval>(*this,B);
930 }
931
934 return spf_mm_hullassign<scimatrix,rmatrix,cimatrix>(*this,B);
935 }
936
939 return spf_mm_hullassign<scimatrix,cmatrix,cimatrix>(*this,B);
940 }
941
944 return spf_mm_hullassign<scimatrix,imatrix,cimatrix>(*this,B);
945 }
946
949 return spf_mm_hullassign<scimatrix,cimatrix,cimatrix>(*this,B);
950 }
951
954 return spf_mm_hullassign<scimatrix,rmatrix_slice,cimatrix>(*this,B);
955 }
956
959 return spf_mm_hullassign<scimatrix,cmatrix_slice,cimatrix>(*this,B);
960 }
961
964 return spf_mm_hullassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
965 }
966
969 return spf_mm_hullassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
970 }
971
974 return spsp_mm_hullassign<scimatrix,srmatrix,cinterval>(*this,B);
975 }
976
979 return spsp_mm_hullassign<scimatrix,scmatrix,cinterval>(*this,B);
980 }
981
984 return spsp_mm_hullassign<scimatrix,simatrix,cinterval>(*this,B);
985 }
986
989 return spsp_mm_hullassign<scimatrix,scimatrix,cinterval>(*this,B);
990 }
991
994 return spf_mm_intersectassign<scimatrix,imatrix,cimatrix>(*this,B);
995 }
996
999 return spf_mm_intersectassign<scimatrix,cimatrix,cimatrix>(*this,B);
1000 }
1001
1004 return spf_mm_intersectassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
1005 }
1006
1009 return spf_mm_intersectassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
1010 }
1011
1014 return spsp_mm_intersectassign<scimatrix,simatrix,cinterval>(*this,B);
1015 }
1016
1019 return spsp_mm_intersectassign<scimatrix,scimatrix,cinterval>(*this,B);
1020 }
1021
1024 return spf_mm_multassign<scimatrix,cmatrix,sparse_cidot,cimatrix>(*this,B);
1025 }
1026
1029 return spf_mm_multassign<scimatrix,rmatrix,sparse_cidot,cimatrix>(*this,B);
1030 }
1031
1034 return spf_mm_multassign<scimatrix,imatrix,sparse_cidot,cimatrix>(*this,B);
1035 }
1036
1039 return spf_mm_multassign<scimatrix,cimatrix,sparse_cidot,cimatrix>(*this,B);
1040 }
1041
1044 return spf_mm_multassign<scimatrix,rmatrix_slice,sparse_cidot,cimatrix>(*this,B);
1045 }
1046
1049 return spf_mm_multassign<scimatrix,cmatrix_slice,sparse_cidot,cimatrix>(*this,B);
1050 }
1051
1054 return spf_mm_multassign<scimatrix,imatrix_slice,sparse_cidot,cimatrix>(*this,B);
1055 }
1056
1059 return spf_mm_multassign<scimatrix,cimatrix_slice,sparse_cidot,cimatrix>(*this,B);
1060 }
1061
1064 return spsp_mm_multassign<scimatrix,srmatrix,sparse_cidot,cinterval>(*this,B);
1065 }
1066
1069 return spsp_mm_multassign<scimatrix,scmatrix,sparse_cidot,cinterval>(*this,B);
1070 }
1071
1074 return spsp_mm_multassign<scimatrix,simatrix,sparse_cidot,cinterval>(*this,B);
1075 }
1076
1079 return spsp_mm_multassign<scimatrix,scimatrix,sparse_cidot,cinterval>(*this,B);
1080 }
1081
1084 return sp_ms_multassign(*this,r);
1085 }
1086
1089 return sp_ms_multassign(*this,r);
1090 }
1091
1094 return sp_ms_multassign(*this,r);
1095 }
1096
1099 return sp_ms_multassign(*this,r);
1100 }
1101
1104 return sp_ms_divassign(*this,r);
1105 }
1106
1109 return sp_ms_divassign(*this,r);
1110 }
1111
1114 return sp_ms_divassign(*this,r);
1115 }
1116
1119 return sp_ms_divassign(*this,r);
1120 }
1121
1122 friend void SetLb(scimatrix&, const int, const int);
1123 friend void SetUb(scimatrix&, const int, const int);
1124 friend int Lb(const scimatrix&, int);
1125 friend int Ub(const scimatrix&, int);
1126 friend int RowLen(const scimatrix&);
1127 friend int ColLen(const scimatrix&);
1128 friend simatrix Re(const scimatrix&);
1129 friend simatrix Im(const scimatrix&);
1130 friend scmatrix Sup(const scimatrix&);
1131 friend scmatrix Inf(const scimatrix&);
1132 friend srmatrix InfRe(const scimatrix&);
1133 friend srmatrix InfIm(const scimatrix&);
1134 friend srmatrix SupRe(const scimatrix&);
1135 friend srmatrix SupIm(const scimatrix&);
1136 friend scimatrix conj(const scimatrix&);
1137 friend simatrix abs(const scimatrix&);
1138 friend scmatrix mid(const scimatrix&);
1139 friend scmatrix diam(const scimatrix&);
1140
1141 friend srmatrix CompMat(const scimatrix&);
1142 friend scimatrix transp(const scimatrix&);
1143 friend scimatrix Id(const scimatrix&);
1144
1145 friend std::istream& operator>>(std::istream&, scimatrix_slice&);
1146 friend std::istream& operator>>(std::istream&, scimatrix_subv&);
1147
1148 friend class srmatrix_slice;
1149 friend class srmatrix_subv;
1150 friend class srvector;
1151 friend class scmatrix_slice;
1152 friend class scmatrix_subv;
1153 friend class scvector;
1154 friend class simatrix_slice;
1155 friend class simatrix_subv;
1156 friend class sivector;
1157 friend class scimatrix_slice;
1158 friend class scimatrix_subv;
1159 friend class scivector;
1160 friend class cimatrix;
1161
1162#include "matrix_friend_declarations.inl"
1163};
1164
1166 dat = new cinterval[A.m*A.n];
1167 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1168 xsize = A.n;
1169 ysize = A.m;
1170 *this = 0.0;
1171 for(int j=0 ; j<A.n ; j++) {
1172 for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
1173 dat[A.ind[k]*A.n+j] = A.x[k];
1174 }
1175 }
1176}
1177
1179 dat = new cinterval[A.m*A.n];
1180 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1181 xsize = A.n;
1182 ysize = A.m;
1183 *this = 0.0;
1184 for(int j=0 ; j<A.n ; j++) {
1185 for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
1186 dat[A.ind[k]*A.n+j] = A.x[k];
1187 }
1188 }
1189}
1190
1192 dat = new cinterval[A.m*A.n];
1193 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1194 xsize = A.n;
1195 ysize = A.m;
1196 *this = 0.0;
1197 for(int j=0 ; j<A.n ; j++) {
1198 for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
1199 dat[A.ind[k]*A.n+j] = A.x[k];
1200 }
1201 }
1202}
1203
1205 dat = new cinterval[A.m*A.n];
1206 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1207 xsize = A.n;
1208 ysize = A.m;
1209 *this = 0.0;
1210 for(int j=0 ; j<A.n ; j++) {
1211 for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
1212 dat[A.ind[k]*A.n+j] = A.x[k];
1213 }
1214 }
1215}
1216
1218inline scimatrix Id(const scimatrix& A) {
1219 scimatrix I(A.m, A.n, (A.m>A.n) ? A.m : A.n);
1220 I.lb1 = A.lb1; I.lb2 = A.lb2;
1221 I.ub1 = A.ub1; I.ub2 = A.ub2;
1222
1223 if(A.m < A.n) {
1224 for(int i=0 ; i<A.m ; i++) {
1225 I.p[i+1] = I.p[i] + 1;
1226 I.ind.push_back(i);
1227 I.x.push_back(cinterval(1.0));
1228 }
1229 } else {
1230 for(int i=0 ; i<A.n ; i++) {
1231 I.p[i+1] = I.p[i] + 1;
1232 I.ind.push_back(i);
1233 I.x.push_back(cinterval(1.0));
1234 }
1235 }
1236
1237 return I;
1238}
1239
1241inline srmatrix CompMat(const scimatrix& A) {
1242 srmatrix res(A.m,A.n,A.get_nnz());
1243 res.lb1 = A.lb1;
1244 res.lb2 = A.lb2;
1245 res.ub1 = A.ub1;
1246 res.ub2 = A.ub2;
1247 res.p = A.p;
1248 res.ind = A.ind;
1249 res.p[A.n] = A.p[A.n];
1250
1251 for(int j=0 ; j<res.n ; j++) {
1252 for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
1253 if(A.ind[k] == j)
1254 res.x.push_back(Inf(abs(A.x[k])));
1255 else
1256 res.x.push_back(-Sup(abs(A.x[k])));
1257 }
1258 }
1259
1260 res.dropzeros();
1261
1262 return res;
1263}
1264
1266inline scimatrix transp(const scimatrix& A) {
1267 scimatrix B(A.n, A.m, A.get_nnz());
1268
1269 //NIchtnullen pro Zeile bestimmen
1270 std::vector<int> w(A.m,0);
1271 for(unsigned int i=0 ; i<A.ind.size() ; i++)
1272 w[A.ind[i]]++;
1273
1274 //Spalten"pointer" setzen
1275 B.p.resize(A.m+1);
1276 B.p[0] = 0;
1277 for(unsigned int i=1 ; i<B.p.size() ; i++)
1278 B.p[i] = w[i-1] + B.p[i-1];
1279
1280 //w vorbereiten
1281 w.insert(w.begin(), 0);
1282 for(unsigned int i=1 ; i<w.size() ; i++) {
1283 w[i] += w[i-1];
1284 }
1285
1286 //neuer zeilenindex und wert wird gesetzt
1287 int q;
1288 B.ind.resize(A.get_nnz());
1289 B.x.resize(A.get_nnz());
1290 for(int j=0 ; j<A.n ; j++) {
1291 for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
1292 q = w[A.ind[k]]++;
1293 B.ind[q] = j;
1294 B.x[q] = A.x[k];
1295 }
1296 }
1297
1298 return B;
1299}
1300
1302
1306inline void SetLb(scimatrix& A, const int i, const int j) {
1307 if(i==1) {
1308 A.lb1 = j;
1309 A.ub1 = j + A.m - 1;
1310 } else if(i==2) {
1311 A.lb2 = j;
1312 A.ub2 = j + A.n - 1;
1313 }
1314}
1315
1317
1321inline void SetUb(scimatrix& A, const int i, const int j) {
1322 if(i==1) {
1323 A.ub1 = j;
1324 A.lb1 = j - A.m + 1;
1325 } else if(i==2) {
1326 A.ub2 = j;
1327 A.lb2 = j - A.n + 1;
1328 }
1329}
1330
1332
1335inline int Lb(const scimatrix& A, int i) {
1336 if(i==1)
1337 return A.lb1;
1338 else if(i==2)
1339 return A.lb2;
1340 else
1341 return 1;
1342}
1343
1345
1348inline int Ub(const scimatrix& A, int i) {
1349 if(i==1)
1350 return A.ub1;
1351 else if(i==2)
1352 return A.ub2;
1353 else
1354 return 1;
1355}
1356
1358inline int RowLen(const scimatrix& A) {
1359 return A.n;
1360}
1361
1363inline int ColLen(const scimatrix& A) {
1364 return A.m;
1365}
1366
1368inline void Resize(scimatrix& A) {
1369 sp_m_resize(A);
1370}
1371
1373inline void Resize(scimatrix& A, const int m, const int n) {
1374 sp_m_resize(A,m,n);
1375}
1376
1378inline void Resize(scimatrix& A, const int l1, const int u1, const int l2, const int u2) {
1379 sp_m_resize(A,l1,u1,l2,u2);
1380}
1381
1383inline simatrix Re(const scimatrix& A) {
1384 simatrix res(A.m,A.n,A.get_nnz());
1385 res.lb1 = A.lb1;
1386 res.lb2 = A.lb2;
1387 res.ub1 = A.ub1;
1388 res.ub2 = A.ub2;
1389 res.p = A.p;
1390 res.ind = A.ind;
1391
1392 for(int i=0 ; i<res.get_nnz() ; i++)
1393 res.x.push_back(Re(A.x[i]));
1394
1395 res.dropzeros();
1396
1397 return res;
1398}
1399
1401inline simatrix Im(const scimatrix& A) {
1402 simatrix res(A.m,A.n,A.get_nnz());
1403 res.lb1 = A.lb1;
1404 res.lb2 = A.lb2;
1405 res.ub1 = A.ub1;
1406 res.ub2 = A.ub2;
1407 res.p = A.p;
1408 res.ind = A.ind;
1409
1410 for(int i=0 ; i<res.get_nnz() ; i++)
1411 res.x.push_back(Im(A.x[i]));
1412
1413 res.dropzeros();
1414
1415 return res;
1416}
1417
1419inline scmatrix Inf(const scimatrix& A) {
1420 scmatrix res(A.m,A.n,A.get_nnz());
1421 res.lb1 = A.lb1;
1422 res.lb2 = A.lb2;
1423 res.ub1 = A.ub1;
1424 res.ub2 = A.ub2;
1425 res.p = A.p;
1426 res.ind = A.ind;
1427
1428 for(int i=0 ; i<res.get_nnz() ; i++)
1429 res.x.push_back(Inf(A.x[i]));
1430
1431 res.dropzeros();
1432
1433 return res;
1434}
1435
1437inline scmatrix Sup(const scimatrix& A) {
1438 scmatrix res(A.m,A.n,A.get_nnz());
1439 res.lb1 = A.lb1;
1440 res.lb2 = A.lb2;
1441 res.ub1 = A.ub1;
1442 res.ub2 = A.ub2;
1443 res.p = A.p;
1444 res.ind = A.ind;
1445
1446 for(int i=0 ; i<res.get_nnz() ; i++)
1447 res.x.push_back(Sup(A.x[i]));
1448
1449 res.dropzeros();
1450
1451 return res;
1452}
1453
1455inline scimatrix conj(const scimatrix& A) {
1456 scimatrix res(A.m,A.n,A.get_nnz());
1457 res.lb1 = A.lb1;
1458 res.lb2 = A.lb2;
1459 res.ub1 = A.ub1;
1460 res.ub2 = A.ub2;
1461 res.p = A.p;
1462 res.ind = A.ind;
1463
1464 for(int i=0 ; i<res.get_nnz() ; i++)
1465 res.x.push_back(conj(A.x[i]));
1466
1467 res.dropzeros();
1468
1469 return res;
1470}
1471
1473inline simatrix abs(const scimatrix& A) {
1474 simatrix res(A.m,A.n,A.get_nnz());
1475 res.lb1 = A.lb1;
1476 res.lb2 = A.lb2;
1477 res.ub1 = A.ub1;
1478 res.ub2 = A.ub2;
1479 res.p = A.p;
1480 res.ind = A.ind;
1481
1482 for(int i=0 ; i<res.get_nnz() ; i++)
1483 res.x.push_back(abs(A.x[i]));
1484
1485 res.dropzeros();
1486
1487 return res;
1488}
1489
1491inline scmatrix mid(const scimatrix& A) {
1492 scmatrix res(A.m,A.n,A.get_nnz());
1493 res.lb1 = A.lb1;
1494 res.lb2 = A.lb2;
1495 res.ub1 = A.ub1;
1496 res.ub2 = A.ub2;
1497 res.p = A.p;
1498 res.ind = A.ind;
1499
1500 for(int i=0 ; i<res.get_nnz() ; i++)
1501 res.x.push_back(mid(A.x[i]));
1502
1503 res.dropzeros();
1504
1505 return res;
1506}
1507
1509inline scmatrix diam(const scimatrix& A) {
1510 scmatrix res(A.m,A.n,A.get_nnz());
1511 res.lb1 = A.lb1;
1512 res.lb2 = A.lb2;
1513 res.ub1 = A.ub1;
1514 res.ub2 = A.ub2;
1515 res.p = A.p;
1516 res.ind = A.ind;
1517
1518 for(int i=0 ; i<res.get_nnz() ; i++)
1519 res.x.push_back(diam(A.x[i]));
1520
1521 res.dropzeros();
1522
1523 return res;
1524}
1525
1527inline srmatrix InfRe(const scimatrix& A) {
1528 srmatrix res(A.m,A.n,A.get_nnz());
1529 res.lb1 = A.lb1;
1530 res.lb2 = A.lb2;
1531 res.ub1 = A.ub1;
1532 res.ub2 = A.ub2;
1533 res.p = A.p;
1534 res.ind = A.ind;
1535
1536 for(int i=0 ; i<res.get_nnz() ; i++)
1537 res.x.push_back(InfRe(A.x[i]));
1538
1539 res.dropzeros();
1540
1541 return res;
1542}
1543
1545inline srmatrix InfIm(const scimatrix& A) {
1546 srmatrix res(A.m,A.n,A.get_nnz());
1547 res.lb1 = A.lb1;
1548 res.lb2 = A.lb2;
1549 res.ub1 = A.ub1;
1550 res.ub2 = A.ub2;
1551 res.p = A.p;
1552 res.ind = A.ind;
1553
1554 for(int i=0 ; i<res.get_nnz() ; i++)
1555 res.x.push_back(InfIm(A.x[i]));
1556
1557 res.dropzeros();
1558
1559 return res;
1560}
1561
1563inline srmatrix SupRe(const scimatrix& A) {
1564 srmatrix res(A.m,A.n,A.get_nnz());
1565 res.lb1 = A.lb1;
1566 res.lb2 = A.lb2;
1567 res.ub1 = A.ub1;
1568 res.ub2 = A.ub2;
1569 res.p = A.p;
1570 res.ind = A.ind;
1571
1572 for(int i=0 ; i<res.get_nnz() ; i++)
1573 res.x.push_back(SupRe(A.x[i]));
1574
1575 res.dropzeros();
1576
1577 return res;
1578}
1579
1581inline srmatrix SupIm(const scimatrix& A) {
1582 srmatrix res(A.m,A.n,A.get_nnz());
1583 res.lb1 = A.lb1;
1584 res.lb2 = A.lb2;
1585 res.ub1 = A.ub1;
1586 res.ub2 = A.ub2;
1587 res.p = A.p;
1588 res.ind = A.ind;
1589
1590 for(int i=0 ; i<res.get_nnz() ; i++)
1591 res.x.push_back(SupIm(A.x[i]));
1592
1593 res.dropzeros();
1594
1595 return res;
1596}
1597
1599
1605inline cimatrix operator*(const cimatrix& A, const srmatrix& B) {
1606 return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(A,B);
1607}
1608
1610
1616inline cimatrix operator*(const cimatrix& A, const scmatrix& B) {
1617 return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
1618}
1619
1621
1627inline cimatrix operator*(const cimatrix& A, const simatrix& B) {
1628 return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(A,B);
1629}
1630
1632
1638inline cimatrix operator*(const cimatrix& A, const scimatrix& B) {
1639 return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1640}
1641
1643
1649inline cimatrix operator*(const rmatrix& A, const scimatrix& B) {
1650 return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1651}
1652
1654
1660inline cimatrix operator*(const cmatrix& A, const scimatrix& B) {
1661 return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1662}
1663
1665
1671inline cimatrix operator*(const imatrix& A, const scimatrix& B) {
1672 return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1673}
1674
1676
1682inline cimatrix operator*(const cmatrix& A, const simatrix& B) {
1683 return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(A,B);
1684}
1685
1687
1693inline cimatrix operator*(const imatrix& A, const scmatrix& B) {
1694 return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
1695}
1696
1698
1704inline cimatrix operator*(const scimatrix& A, const rmatrix& B) {
1705 return spf_mm_mult<scimatrix,rmatrix,cimatrix,sparse_cidot>(A,B);
1706}
1707
1709
1715inline cimatrix operator*(const scimatrix& A, const cmatrix& B) {
1716 return spf_mm_mult<scimatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
1717}
1718
1720
1726inline cimatrix operator*(const scimatrix& A, const imatrix& B) {
1727 return spf_mm_mult<scimatrix,imatrix,cimatrix,sparse_cidot>(A,B);
1728}
1729
1731
1737inline cimatrix operator*(const scimatrix& A, const cimatrix& B) {
1738 return spf_mm_mult<scimatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1739}
1740
1742
1748inline cimatrix operator*(const srmatrix& A, const cimatrix& B) {
1749 return spf_mm_mult<srmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1750}
1751
1753
1759inline cimatrix operator*(const scmatrix& A, const cimatrix& B) {
1760 return spf_mm_mult<scmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1761}
1762
1764
1770inline cimatrix operator*(const simatrix& A, const cimatrix& B) {
1771 return spf_mm_mult<simatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1772}
1773
1775
1781inline cimatrix operator*(const scmatrix& A, const imatrix& B) {
1782 return spf_mm_mult<scmatrix,imatrix,cimatrix,sparse_cidot>(A,B);
1783}
1784
1786
1792inline cimatrix operator*(const simatrix& A, const cmatrix& B) {
1793 return spf_mm_mult<simatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
1794}
1795
1797
1803inline cimatrix operator*(const cimatrix_slice& A, const srmatrix& B) {
1804 return fsp_mm_mult<cimatrix_slice,srmatrix,cimatrix,sparse_cidot>(A,B);
1805}
1806
1808
1814inline cimatrix operator*(const cimatrix_slice& A, const scmatrix& B) {
1815 return fsp_mm_mult<cimatrix_slice,scmatrix,cimatrix,sparse_cidot>(A,B);
1816}
1817
1819
1825inline cimatrix operator*(const cimatrix_slice& A, const simatrix& B) {
1826 return fsp_mm_mult<cimatrix_slice,simatrix,cimatrix,sparse_cidot>(A,B);
1827}
1828
1830
1836inline cimatrix operator*(const cimatrix_slice& A, const scimatrix& B) {
1837 return fsp_mm_mult<cimatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1838}
1839
1841
1847inline cimatrix operator*(const rmatrix_slice& A, const scimatrix& B) {
1848 return fsp_mm_mult<rmatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1849}
1850
1852
1858inline cimatrix operator*(const imatrix_slice& A, const scimatrix& B) {
1859 return fsp_mm_mult<imatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1860}
1861
1863
1869inline cimatrix operator*(const cmatrix_slice& A, const scimatrix& B) {
1870 return fsp_mm_mult<cmatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1871}
1872
1874
1880inline cimatrix operator*(const cmatrix_slice& A, const simatrix& B) {
1881 return fsp_mm_mult<cmatrix_slice,simatrix,cimatrix,sparse_cidot>(A,B);
1882}
1883
1885
1891inline cimatrix operator*(const imatrix_slice& A, const scmatrix& B) {
1892 return fsp_mm_mult<imatrix_slice,scmatrix,cimatrix,sparse_cidot>(A,B);
1893}
1894
1896
1902inline cimatrix operator*(const scimatrix& A, const rmatrix_slice& B) {
1903 return spf_mm_mult<scimatrix,rmatrix_slice,cimatrix,sparse_cidot>(A,B);
1904}
1905
1907
1913inline cimatrix operator*(const scimatrix& A, const cmatrix_slice& B) {
1914 return spf_mm_mult<scimatrix,cmatrix_slice,cimatrix,sparse_cidot>(A,B);
1915}
1916
1918
1924inline cimatrix operator*(const scimatrix& A, const imatrix_slice& B) {
1925 return spf_mm_mult<scimatrix,imatrix_slice,cimatrix,sparse_cidot>(A,B);
1926}
1927
1929
1935inline cimatrix operator*(const scimatrix& A, const cimatrix_slice& B) {
1936 return spf_mm_mult<scimatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1937}
1938
1940
1946inline cimatrix operator*(const srmatrix& A, const cimatrix_slice& B) {
1947 return spf_mm_mult<srmatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1948}
1949
1951
1957inline cimatrix operator*(const scmatrix& A, const cimatrix_slice& B) {
1958 return spf_mm_mult<scmatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1959}
1960
1962
1968inline cimatrix operator*(const simatrix& A, const cimatrix_slice& B) {
1969 return spf_mm_mult<simatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1970}
1971
1973
1979inline cimatrix operator*(const scmatrix& A, const imatrix_slice& B) {
1980 return spf_mm_mult<scmatrix,imatrix_slice,cimatrix,sparse_cidot>(A,B);
1981}
1982
1984
1990inline cimatrix operator*(const simatrix& A, const cmatrix_slice& B) {
1991 return spf_mm_mult<simatrix,cmatrix_slice,cimatrix,sparse_cidot>(A,B);
1992}
1993
1995
2001inline scimatrix operator*(const scimatrix& A, const srmatrix& B) {
2002 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2003}
2004
2006
2012inline scimatrix operator*(const scimatrix& A, const scmatrix& B) {
2013 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2014}
2015
2017
2023inline scimatrix operator*(const scimatrix& A, const simatrix& B) {
2024 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2025}
2026
2028
2034inline scimatrix operator*(const scimatrix& A, const scimatrix& B) {
2035 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2036}
2037
2039
2045inline scimatrix operator*(const srmatrix& A, const scimatrix& B) {
2046 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2047}
2048
2050
2056inline scimatrix operator*(const scmatrix& A, const scimatrix& B) {
2057 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2058}
2059
2061
2067inline scimatrix operator*(const simatrix& A, const scimatrix& B) {
2068 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2069}
2070
2072
2078inline scimatrix operator*(const scmatrix& A, const simatrix& B) {
2079 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2080}
2081
2083
2089inline scimatrix operator*(const simatrix& A, const scmatrix& B) {
2090 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2091}
2092
2094inline scimatrix operator/(const scimatrix& A, const real& r) {
2095 return sp_ms_div<scimatrix,real,scimatrix>(A,r);
2096}
2097
2099inline scimatrix operator/(const scimatrix& A, const complex& r) {
2100 return sp_ms_div<scimatrix,complex,scimatrix>(A,r);
2101}
2102
2104inline scimatrix operator/(const scimatrix& A, const interval& r) {
2105 return sp_ms_div<scimatrix,interval,scimatrix>(A,r);
2106}
2107
2109inline scimatrix operator/(const scimatrix& A, const cinterval& r) {
2110 return sp_ms_div<scimatrix,cinterval,scimatrix>(A,r);
2111}
2112
2114inline scimatrix operator/(const srmatrix& A, const cinterval& r) {
2115 return sp_ms_div<srmatrix,cinterval,scimatrix>(A,r);
2116}
2117
2119inline scimatrix operator/(const simatrix& A, const cinterval& r) {
2120 return sp_ms_div<simatrix,cinterval,scimatrix>(A,r);
2121}
2122
2124inline scimatrix operator/(const scmatrix& A, const cinterval& r) {
2125 return sp_ms_div<scmatrix,cinterval,scimatrix>(A,r);
2126}
2127
2129inline scimatrix operator/(const scmatrix& A, const interval& r) {
2130 return sp_ms_div<scmatrix,interval,scimatrix>(A,r);
2131}
2132
2134inline scimatrix operator/(const simatrix& A, const complex& r) {
2135 return sp_ms_div<simatrix,complex,scimatrix>(A,r);
2136}
2137
2139inline scimatrix operator*(const scimatrix& A, const real& r) {
2140 return sp_ms_mult<scimatrix,real,scimatrix>(A,r);
2141}
2142
2144inline scimatrix operator*(const scimatrix& A, const complex& r) {
2145 return sp_ms_mult<scimatrix,complex,scimatrix>(A,r);
2146}
2147
2149inline scimatrix operator*(const scimatrix& A, const interval& r) {
2150 return sp_ms_mult<scimatrix,interval,scimatrix>(A,r);
2151}
2152
2154inline scimatrix operator*(const scimatrix& A, const cinterval& r) {
2155 return sp_ms_mult<scimatrix,cinterval,scimatrix>(A,r);
2156}
2157
2159inline scimatrix operator*(const srmatrix& A, const cinterval& r) {
2160 return sp_ms_mult<srmatrix,cinterval,scimatrix>(A,r);
2161}
2162
2164inline scimatrix operator*(const simatrix& A, const cinterval& r) {
2165 return sp_ms_mult<simatrix,cinterval,scimatrix>(A,r);
2166}
2167
2169inline scimatrix operator*(const scmatrix& A, const cinterval& r) {
2170 return sp_ms_mult<scmatrix,cinterval,scimatrix>(A,r);
2171}
2172
2174inline scimatrix operator*(const scmatrix& A, const interval& r) {
2175 return sp_ms_mult<scmatrix,interval,scimatrix>(A,r);
2176}
2177
2179inline scimatrix operator*(const simatrix& A, const complex& r) {
2180 return sp_ms_mult<simatrix,complex,scimatrix>(A,r);
2181}
2182
2184inline scimatrix operator*(const real& r, const scimatrix& A) {
2185 return sp_sm_mult<real,scimatrix,scimatrix>(r,A);
2186}
2187
2189inline scimatrix operator*(const complex& r, const scimatrix& A) {
2190 return sp_sm_mult<complex,scimatrix,scimatrix>(r,A);
2191}
2192
2194inline scimatrix operator*(const interval& r, const scimatrix& A) {
2195 return sp_sm_mult<interval,scimatrix,scimatrix>(r,A);
2196}
2197
2199inline scimatrix operator*(const cinterval& r, const scimatrix& A) {
2200 return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,A);
2201}
2202
2204inline scimatrix operator*(const cinterval& r, const srmatrix& A) {
2205 return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,A);
2206}
2207
2209inline scimatrix operator*(const cinterval& r, const simatrix& A) {
2210 return sp_sm_mult<cinterval,simatrix,scimatrix>(r,A);
2211}
2212
2214inline scimatrix operator*(const cinterval& r, const scmatrix& A) {
2215 return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,A);
2216}
2217
2219inline scimatrix operator*(const complex& r, const simatrix& A) {
2220 return sp_sm_mult<complex,simatrix,scimatrix>(r,A);
2221}
2222
2224inline scimatrix operator*(const interval& r, const scmatrix& A) {
2225 return sp_sm_mult<interval,scmatrix,scimatrix>(r,A);
2226}
2227
2229
2235inline civector operator*(const scimatrix& A, const rvector& v) {
2236 return spf_mv_mult<scimatrix,rvector,civector,sparse_cidot>(A,v);
2237}
2238
2240
2246inline civector operator*(const scimatrix& A, const cvector& v) {
2247 return spf_mv_mult<scimatrix,cvector,civector,sparse_cidot>(A,v);
2248}
2249
2251
2257inline civector operator*(const scimatrix& A, const ivector& v) {
2258 return spf_mv_mult<scimatrix,ivector,civector,sparse_cidot>(A,v);
2259}
2260
2262
2268inline civector operator*(const scimatrix& A, const civector& v) {
2269 return spf_mv_mult<scimatrix,civector,civector,sparse_cidot>(A,v);
2270}
2271
2273
2279inline civector operator*(const srmatrix& A, const civector& v) {
2280 return spf_mv_mult<srmatrix,civector,civector,sparse_cidot>(A,v);
2281}
2282
2284
2290inline civector operator*(const scmatrix& A, const civector& v) {
2291 return spf_mv_mult<scmatrix,civector,civector,sparse_cidot>(A,v);
2292}
2293
2295
2301inline civector operator*(const simatrix& A, const civector& v) {
2302 return spf_mv_mult<simatrix,civector,civector,sparse_cidot>(A,v);
2303}
2304
2306
2312inline civector operator*(const scmatrix& A, const ivector& v) {
2313 return spf_mv_mult<scmatrix,ivector,civector,sparse_cidot>(A,v);
2314}
2315
2317
2323inline civector operator*(const simatrix& A, const cvector& v) {
2324 return spf_mv_mult<simatrix,cvector,civector,sparse_cidot>(A,v);
2325}
2326
2328
2334inline civector operator*(const scimatrix& A, const rvector_slice& v) {
2335 return spf_mv_mult<scimatrix,rvector_slice,civector,sparse_cidot>(A,v);
2336}
2337
2339
2345inline civector operator*(const scimatrix& A, const ivector_slice& v) {
2346 return spf_mv_mult<scimatrix,ivector_slice,civector,sparse_cidot>(A,v);
2347}
2348
2350
2356inline civector operator*(const scimatrix& A, const cvector_slice& v) {
2357 return spf_mv_mult<scimatrix,cvector_slice,civector,sparse_cidot>(A,v);
2358}
2359
2361
2367inline civector operator*(const scimatrix& A, const civector_slice& v) {
2368 return spf_mv_mult<scimatrix,civector_slice,civector,sparse_cidot>(A,v);
2369}
2370
2372
2378inline civector operator*(const srmatrix& A, const civector_slice& v) {
2379 return spf_mv_mult<srmatrix,civector_slice,civector,sparse_cidot>(A,v);
2380}
2381
2383
2389inline civector operator*(const scmatrix& A, const civector_slice& v) {
2390 return spf_mv_mult<scmatrix,civector_slice,civector,sparse_cidot>(A,v);
2391}
2392
2394
2400inline civector operator*(const simatrix& A, const civector_slice& v) {
2401 return spf_mv_mult<simatrix,civector_slice,civector,sparse_cidot>(A,v);
2402}
2403
2405
2411inline civector operator*(const simatrix& A, const cvector_slice& v) {
2412 return spf_mv_mult<simatrix,cvector_slice,civector,sparse_cidot>(A,v);
2413}
2414
2416
2422inline civector operator*(const scmatrix& A, const ivector_slice& v) {
2423 return spf_mv_mult<scmatrix,ivector_slice,civector,sparse_cidot>(A,v);
2424}
2425
2427
2433inline scivector operator*(const scimatrix& A, const srvector& v) {
2434 return spsp_mv_mult<scimatrix,srvector,scivector,sparse_cidot,cinterval>(A,v);
2435}
2436
2438
2444inline scivector operator*(const scimatrix& A, const sivector& v) {
2445 return spsp_mv_mult<scimatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
2446}
2447
2449
2455inline scivector operator*(const scimatrix& A, const scvector& v) {
2456 return spsp_mv_mult<scimatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
2457}
2458
2460
2466inline scivector operator*(const scimatrix& A, const scivector& v) {
2467 return spsp_mv_mult<scimatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2468}
2469
2471
2477inline scivector operator*(const srmatrix& A, const scivector& v) {
2478 return spsp_mv_mult<srmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2479}
2480
2482
2488inline scivector operator*(const scmatrix& A, const scivector& v) {
2489 return spsp_mv_mult<scmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2490}
2491
2493
2499inline scivector operator*(const simatrix& A, const scivector& v) {
2500 return spsp_mv_mult<simatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2501}
2503
2509inline scivector operator*(const scmatrix& A, const sivector& v) {
2510 return spsp_mv_mult<scmatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
2511}
2512
2514
2520inline scivector operator*(const simatrix& A, const scvector& v) {
2521 return spsp_mv_mult<simatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
2522}
2523
2525
2531inline scivector operator*(const scimatrix& A, const srvector_slice& v) {
2532 return spsl_mv_mult<scimatrix,srvector_slice,scivector,sparse_cidot,cinterval>(A,v);
2533}
2534
2536
2542inline scivector operator*(const scimatrix& A, const scvector_slice& v) {
2543 return spsl_mv_mult<scimatrix,scvector_slice,scivector,sparse_cidot,cinterval>(A,v);
2544}
2545
2547
2553inline scivector operator*(const scimatrix& A, const sivector_slice& v) {
2554 return spsl_mv_mult<scimatrix,sivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2555}
2556
2558
2564inline scivector operator*(const scimatrix& A, const scivector_slice& v) {
2565 return spsl_mv_mult<scimatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2566}
2567
2569
2575inline scivector operator*(const srmatrix& A, const scivector_slice& v) {
2576 return spsl_mv_mult<srmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2577}
2578
2580
2586inline scivector operator*(const scmatrix& A, const scivector_slice& v) {
2587 return spsl_mv_mult<scmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2588}
2589
2591
2597inline scivector operator*(const simatrix& A, const scivector_slice& v) {
2598 return spsl_mv_mult<simatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2599}
2600
2602
2608inline scivector operator*(const simatrix& A, const scvector_slice& v) {
2609 return spsl_mv_mult<simatrix,scvector_slice,scivector,sparse_cidot,cinterval>(A,v);
2610}
2611
2613
2619inline scivector operator*(const scmatrix& A, const sivector_slice& v) {
2620 return spsl_mv_mult<scmatrix,sivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2621}
2622
2624
2630inline civector operator*(const cimatrix& A, const srvector& v) {
2631 return fsp_mv_mult<cimatrix,srvector,civector,sparse_cidot>(A,v);
2632}
2633
2635
2641inline civector operator*(const cimatrix& A, const sivector& v) {
2642 return fsp_mv_mult<cimatrix,sivector,civector,sparse_cidot>(A,v);
2643}
2644
2646
2652inline civector operator*(const cimatrix& A, const scvector& v) {
2653 return fsp_mv_mult<cimatrix,scvector,civector,sparse_cidot>(A,v);
2654}
2655
2657
2663inline civector operator*(const cimatrix& A, const scivector& v) {
2664 return fsp_mv_mult<cimatrix,scivector,civector,sparse_cidot>(A,v);
2665}
2666
2668
2674inline civector operator*(const rmatrix& A, const scivector& v) {
2675 return fsp_mv_mult<rmatrix,scivector,civector,sparse_cidot>(A,v);
2676}
2677
2679
2685inline civector operator*(const cmatrix& A, const scivector& v) {
2686 return fsp_mv_mult<cmatrix,scivector,civector,sparse_cidot>(A,v);
2687}
2688
2690
2696inline civector operator*(const imatrix& A, const scivector& v) {
2697 return fsp_mv_mult<imatrix,scivector,civector,sparse_cidot>(A,v);
2698}
2699
2701
2707inline civector operator*(const cmatrix& A, const sivector& v) {
2708 return fsp_mv_mult<cmatrix,sivector,civector,sparse_cidot>(A,v);
2709}
2710
2712
2718inline civector operator*(const imatrix& A, const scvector& v) {
2719 return fsp_mv_mult<imatrix,scvector,civector,sparse_cidot>(A,v);
2720}
2721
2723
2729inline civector operator*(const cimatrix_slice& A, const srvector& v) {
2730 return fsp_mv_mult<cimatrix_slice,srvector,civector,sparse_cidot>(A,v);
2731}
2732
2734
2740inline civector operator*(const cimatrix_slice& A, const scvector& v) {
2741 return fsp_mv_mult<cimatrix_slice,scvector,civector,sparse_cidot>(A,v);
2742}
2743
2745
2751inline civector operator*(const cimatrix_slice& A, const sivector& v) {
2752 return fsp_mv_mult<cimatrix_slice,sivector,civector,sparse_cidot>(A,v);
2753}
2754
2756
2762inline civector operator*(const cimatrix_slice& A, const scivector& v) {
2763 return fsp_mv_mult<cimatrix_slice,scivector,civector,sparse_cidot>(A,v);
2764}
2765
2767
2773inline civector operator*(const rmatrix_slice& A, const scivector& v) {
2774 return fsp_mv_mult<rmatrix_slice,scivector,civector,sparse_cidot>(A,v);
2775}
2776
2778
2784inline civector operator*(const cmatrix_slice& A, const scivector& v) {
2785 return fsp_mv_mult<cmatrix_slice,scivector,civector,sparse_cidot>(A,v);
2786}
2787
2789
2795inline civector operator*(const imatrix_slice& A, const scivector& v) {
2796 return fsp_mv_mult<imatrix_slice,scivector,civector,sparse_cidot>(A,v);
2797}
2798
2800
2806inline civector operator*(const cmatrix_slice& A, const sivector& v) {
2807 return fsp_mv_mult<cmatrix_slice,sivector,civector,sparse_cidot>(A,v);
2808}
2809
2811
2817inline civector operator*(const imatrix_slice& A, const scvector& v) {
2818 return fsp_mv_mult<imatrix_slice,scvector,civector,sparse_cidot>(A,v);
2819}
2820
2822
2828inline civector operator*(const cimatrix& A, const srvector_slice& v) {
2829 return fsl_mv_mult<cimatrix,srvector_slice,civector,sparse_cidot>(A,v);
2830}
2831
2833
2839inline civector operator*(const cimatrix& A, const scvector_slice& v) {
2840 return fsl_mv_mult<cimatrix,scvector_slice,civector,sparse_cidot>(A,v);
2841}
2842
2844
2850inline civector operator*(const cimatrix& A, const sivector_slice& v) {
2851 return fsl_mv_mult<cimatrix,sivector_slice,civector,sparse_cidot>(A,v);
2852}
2853
2855
2861inline civector operator*(const cimatrix& A, const scivector_slice& v) {
2862 return fsl_mv_mult<cimatrix,scivector_slice,civector,sparse_cidot>(A,v);
2863}
2864
2866
2872inline civector operator*(const rmatrix& A, const scivector_slice& v) {
2873 return fsl_mv_mult<rmatrix,scivector_slice,civector,sparse_cidot>(A,v);
2874}
2875
2877
2883inline civector operator*(const cmatrix& A, const scivector_slice& v) {
2884 return fsl_mv_mult<cmatrix,scivector_slice,civector,sparse_cidot>(A,v);
2885}
2886
2888
2894inline civector operator*(const imatrix& A, const scivector_slice& v) {
2895 return fsl_mv_mult<imatrix,scivector_slice,civector,sparse_cidot>(A,v);
2896}
2897
2899
2905inline civector operator*(const cmatrix& A, const sivector_slice& v) {
2906 return fsl_mv_mult<cmatrix,sivector_slice,civector,sparse_cidot>(A,v);
2907}
2908
2910
2916inline civector operator*(const imatrix& A, const scvector_slice& v) {
2917 return fsl_mv_mult<imatrix,scvector_slice,civector,sparse_cidot>(A,v);
2918}
2919
2921
2928 return fsl_mv_mult<cimatrix_slice,srvector_slice,civector,sparse_cidot>(A,v);
2929}
2930
2932
2939 return fsl_mv_mult<cimatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
2940}
2941
2943
2950 return fsl_mv_mult<cimatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
2951}
2952
2954
2961 return fsl_mv_mult<cimatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2962}
2963
2965
2972 return fsl_mv_mult<rmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2973}
2974
2976
2983 return fsl_mv_mult<imatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2984}
2985
2987
2994 return fsl_mv_mult<cmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2995}
2996
2998
3005 return fsl_mv_mult<cmatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
3006}
3007
3009
3016 return fsl_mv_mult<imatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
3017}
3018
3020inline cimatrix operator+(const cimatrix& A, const srmatrix& B) {
3021 return fsp_mm_add<cimatrix,srmatrix,cimatrix>(A,B);
3022}
3023
3025inline cimatrix operator+(const cimatrix& A, const scmatrix& B) {
3026 return fsp_mm_add<cimatrix,scmatrix,cimatrix>(A,B);
3027}
3028
3030inline cimatrix operator+(const cimatrix& A, const simatrix& B) {
3031 return fsp_mm_add<cimatrix,simatrix,cimatrix>(A,B);
3032}
3033
3035inline cimatrix operator+(const cimatrix& A, const scimatrix& B) {
3036 return fsp_mm_add<cimatrix,scimatrix,cimatrix>(A,B);
3037}
3038
3040inline cimatrix operator+(const rmatrix& A, const scimatrix& B) {
3041 return fsp_mm_add<rmatrix,scimatrix,cimatrix>(A,B);
3042}
3043
3045inline cimatrix operator+(const cmatrix& A, const scimatrix& B) {
3046 return fsp_mm_add<cmatrix,scimatrix,cimatrix>(A,B);
3047}
3048
3050inline cimatrix operator+(const imatrix& A, const scimatrix& B) {
3051 return fsp_mm_add<imatrix,scimatrix,cimatrix>(A,B);
3052}
3053
3055inline cimatrix operator+(const imatrix& A, const scmatrix& B) {
3056 return fsp_mm_add<imatrix,scmatrix,cimatrix>(A,B);
3057}
3058
3060inline cimatrix operator+(const cmatrix& A, const simatrix& B) {
3061 return fsp_mm_add<cmatrix,simatrix,cimatrix>(A,B);
3062}
3063
3065inline cimatrix operator+(const scimatrix& A, const rmatrix& B) {
3066 return spf_mm_add<scimatrix,rmatrix,cimatrix>(A,B);
3067}
3068
3070inline cimatrix operator+(const scimatrix& A, const cmatrix& B) {
3071 return spf_mm_add<scimatrix,cmatrix,cimatrix>(A,B);
3072}
3073
3075inline cimatrix operator+(const scimatrix& A, const imatrix& B) {
3076 return spf_mm_add<scimatrix,imatrix,cimatrix>(A,B);
3077}
3078
3080inline cimatrix operator+(const scimatrix& A, const cimatrix& B) {
3081 return spf_mm_add<scimatrix,cimatrix,cimatrix>(A,B);
3082}
3083
3085inline cimatrix operator+(const srmatrix& A, const cimatrix& B) {
3086 return spf_mm_add<srmatrix,cimatrix,cimatrix>(A,B);
3087}
3088
3090inline cimatrix operator+(const scmatrix& A, const cimatrix& B) {
3091 return spf_mm_add<scmatrix,cimatrix,cimatrix>(A,B);
3092}
3093
3095inline cimatrix operator+(const simatrix& A, const cimatrix& B) {
3096 return spf_mm_add<simatrix,cimatrix,cimatrix>(A,B);
3097}
3098
3100inline cimatrix operator+(const simatrix& A, const cmatrix& B) {
3101 return spf_mm_add<simatrix,cmatrix,cimatrix>(A,B);
3102}
3103
3105inline cimatrix operator+(const scmatrix& A, const imatrix& B) {
3106 return spf_mm_add<scmatrix,imatrix,cimatrix>(A,B);
3107}
3108
3110inline cimatrix operator+(const cimatrix_slice& A, const srmatrix& B) {
3111 return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(A,B);
3112}
3113
3115inline cimatrix operator+(const cimatrix_slice& A, const simatrix& B) {
3116 return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(A,B);
3117}
3118
3120inline cimatrix operator+(const cimatrix_slice& A, const scmatrix& B) {
3121 return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(A,B);
3122}
3123
3125inline cimatrix operator+(const cimatrix_slice& A, const scimatrix& B) {
3126 return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(A,B);
3127}
3128
3130inline cimatrix operator+(const rmatrix_slice& A, const scimatrix& B) {
3131 return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(A,B);
3132}
3133
3135inline cimatrix operator+(const imatrix_slice& A, const scimatrix& B) {
3136 return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(A,B);
3137}
3138
3140inline cimatrix operator+(const cmatrix_slice& A, const scimatrix& B) {
3141 return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(A,B);
3142}
3143
3145inline cimatrix operator+(const cmatrix_slice& A, const simatrix& B) {
3146 return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(A,B);
3147}
3148
3150inline cimatrix operator+(const imatrix_slice& A, const scmatrix& B) {
3151 return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(A,B);
3152}
3153
3155inline cimatrix operator+(const scimatrix& A, const rmatrix_slice& B) {
3156 return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(A,B);
3157}
3158
3160inline cimatrix operator+(const scimatrix& A, const cmatrix_slice& B) {
3161 return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(A,B);
3162}
3163
3165inline cimatrix operator+(const scimatrix& A, const imatrix_slice& B) {
3166 return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(A,B);
3167}
3168
3170inline cimatrix operator+(const scimatrix& A, const cimatrix_slice& B) {
3171 return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(A,B);
3172}
3173
3175inline cimatrix operator+(const srmatrix& A, const cimatrix_slice& B) {
3176 return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(A,B);
3177}
3178
3180inline cimatrix operator+(const scmatrix& A, const cimatrix_slice& B) {
3181 return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(A,B);
3182}
3183
3185inline cimatrix operator+(const simatrix& A, const cimatrix_slice& B) {
3186 return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(A,B);
3187}
3188
3190inline cimatrix operator+(const simatrix& A, const cmatrix_slice& B) {
3191 return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(A,B);
3192}
3193
3195inline cimatrix operator+(const scmatrix& A, const imatrix_slice& B) {
3196 return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(A,B);
3197}
3198
3200inline scimatrix operator+(const scimatrix& A, const srmatrix& B) {
3201 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3202}
3203
3205inline scimatrix operator+(const scimatrix& A, const scmatrix& B) {
3206 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3207}
3208
3210inline scimatrix operator+(const scimatrix& A, const simatrix& B) {
3211 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3212}
3213
3215inline scimatrix operator+(const scimatrix& A, const scimatrix& B) {
3216 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3217}
3218
3220inline scimatrix operator+(const srmatrix& A, const scimatrix& B) {
3221 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3222}
3223
3225inline scimatrix operator+(const scmatrix& A, const scimatrix& B) {
3226 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3227}
3228
3230inline scimatrix operator+(const simatrix& A, const scimatrix& B) {
3231 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3232}
3233
3235inline scimatrix operator+(const simatrix& A, const scmatrix& B) {
3236 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3237}
3238
3240inline scimatrix operator+(const scmatrix& A, const simatrix& B) {
3241 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3242}
3243
3245inline cimatrix operator-(const cimatrix& A, const srmatrix& B) {
3246 return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(A,B);
3247}
3248
3250inline cimatrix operator-(const cimatrix& A, const scmatrix& B) {
3251 return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(A,B);
3252}
3253
3255inline cimatrix operator-(const cimatrix& A, const simatrix& B) {
3256 return fsp_mm_sub<cimatrix,simatrix,cimatrix>(A,B);
3257}
3258
3260inline cimatrix operator-(const cimatrix& A, const scimatrix& B) {
3261 return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(A,B);
3262}
3263
3265inline cimatrix operator-(const rmatrix& A, const scimatrix& B) {
3266 return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(A,B);
3267}
3268
3270inline cimatrix operator-(const cmatrix& A, const scimatrix& B) {
3271 return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(A,B);
3272}
3273
3275inline cimatrix operator-(const imatrix& A, const scimatrix& B) {
3276 return fsp_mm_sub<imatrix,scimatrix,cimatrix>(A,B);
3277}
3278
3280inline cimatrix operator-(const imatrix& A, const scmatrix& B) {
3281 return fsp_mm_sub<imatrix,scmatrix,cimatrix>(A,B);
3282}
3283
3285inline cimatrix operator-(const cmatrix& A, const simatrix& B) {
3286 return fsp_mm_sub<cmatrix,simatrix,cimatrix>(A,B);
3287}
3288
3290inline cimatrix operator-(const scimatrix& A, const rmatrix& B) {
3291 return spf_mm_sub<scimatrix,rmatrix,cimatrix>(A,B);
3292}
3293
3295inline cimatrix operator-(const scimatrix& A, const cmatrix& B) {
3296 return spf_mm_sub<scimatrix,cmatrix,cimatrix>(A,B);
3297}
3298
3300inline cimatrix operator-(const scimatrix& A, const imatrix& B) {
3301 return spf_mm_sub<scimatrix,imatrix,cimatrix>(A,B);
3302}
3303
3305inline cimatrix operator-(const scimatrix& A, const cimatrix& B) {
3306 return spf_mm_sub<scimatrix,cimatrix,cimatrix>(A,B);
3307}
3308
3310inline cimatrix operator-(const srmatrix& A, const cimatrix& B) {
3311 return spf_mm_sub<srmatrix,cimatrix,cimatrix>(A,B);
3312}
3313
3315inline cimatrix operator-(const scmatrix& A, const cimatrix& B) {
3316 return spf_mm_sub<scmatrix,cimatrix,cimatrix>(A,B);
3317}
3318
3320inline cimatrix operator-(const simatrix& A, const cimatrix& B) {
3321 return spf_mm_sub<simatrix,cimatrix,cimatrix>(A,B);
3322}
3323
3325inline cimatrix operator-(const simatrix& A, const cmatrix& B) {
3326 return spf_mm_sub<simatrix,cmatrix,cimatrix>(A,B);
3327}
3328
3330inline cimatrix operator-(const scmatrix& A, const imatrix& B) {
3331 return spf_mm_sub<scmatrix,imatrix,cimatrix>(A,B);
3332}
3333
3335inline cimatrix operator-(const cimatrix_slice& A, const srmatrix& B) {
3336 return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(A,B);
3337}
3338
3340inline cimatrix operator-(const cimatrix_slice& A, const simatrix& B) {
3341 return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(A,B);
3342}
3343
3345inline cimatrix operator-(const cimatrix_slice& A, const scmatrix& B) {
3346 return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(A,B);
3347}
3348
3350inline cimatrix operator-(const cimatrix_slice& A, const scimatrix& B) {
3351 return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(A,B);
3352}
3353
3355inline cimatrix operator-(const rmatrix_slice& A, const scimatrix& B) {
3356 return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(A,B);
3357}
3358
3360inline cimatrix operator-(const imatrix_slice& A, const scimatrix& B) {
3361 return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(A,B);
3362}
3363
3365inline cimatrix operator-(const cmatrix_slice& A, const scimatrix& B) {
3366 return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(A,B);
3367}
3368
3370inline cimatrix operator-(const cmatrix_slice& A, const simatrix& B) {
3371 return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(A,B);
3372}
3373
3375inline cimatrix operator-(const imatrix_slice& A, const scmatrix& B) {
3376 return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(A,B);
3377}
3378
3380inline cimatrix operator-(const scimatrix& A, const rmatrix_slice& B) {
3381 return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(A,B);
3382}
3383
3385inline cimatrix operator-(const scimatrix& A, const cmatrix_slice& B) {
3386 return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(A,B);
3387}
3388
3390inline cimatrix operator-(const scimatrix& A, const imatrix_slice& B) {
3391 return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(A,B);
3392}
3393
3395inline cimatrix operator-(const scimatrix& A, const cimatrix_slice& B) {
3396 return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(A,B);
3397}
3398
3400inline cimatrix operator-(const srmatrix& A, const cimatrix_slice& B) {
3401 return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(A,B);
3402}
3403
3405inline cimatrix operator-(const scmatrix& A, const cimatrix_slice& B) {
3406 return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(A,B);
3407}
3408
3410inline cimatrix operator-(const simatrix& A, const cimatrix_slice& B) {
3411 return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(A,B);
3412}
3413
3415inline cimatrix operator-(const simatrix& A, const cmatrix_slice& B) {
3416 return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(A,B);
3417}
3418
3420inline cimatrix operator-(const scmatrix& A, const imatrix_slice& B) {
3421 return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(A,B);
3422}
3423
3425inline scimatrix operator-(const scimatrix& A, const srmatrix& B) {
3426 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3427}
3428
3430inline scimatrix operator-(const scimatrix& A, const scmatrix& B) {
3431 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3432}
3433
3435inline scimatrix operator-(const scimatrix& A, const simatrix& B) {
3436 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3437}
3438
3440inline scimatrix operator-(const scimatrix& A, const scimatrix& B) {
3441 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3442}
3443
3445inline scimatrix operator-(const srmatrix& A, const scimatrix& B) {
3446 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3447}
3448
3450inline scimatrix operator-(const scmatrix& A, const scimatrix& B) {
3451 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3452}
3453
3455inline scimatrix operator-(const simatrix& A, const scimatrix& B) {
3456 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3457}
3458
3460inline scimatrix operator-(const simatrix& A, const scmatrix& B) {
3461 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3462}
3463
3465inline scimatrix operator-(const scmatrix& A, const simatrix& B) {
3466 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3467}
3468
3470inline cimatrix operator|(const cimatrix& A, const srmatrix& B) {
3471 return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(A,B);
3472}
3473
3475inline cimatrix operator|(const cimatrix& A, const scmatrix& B) {
3476 return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(A,B);
3477}
3478
3480inline cimatrix operator|(const cimatrix& A, const simatrix& B) {
3481 return fsp_mm_hull<cimatrix,simatrix,cimatrix>(A,B);
3482}
3483
3485inline cimatrix operator|(const cimatrix& A, const scimatrix& B) {
3486 return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(A,B);
3487}
3488
3490inline cimatrix operator|(const rmatrix& A, const scimatrix& B) {
3491 return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(A,B);
3492}
3493
3495inline cimatrix operator|(const cmatrix& A, const scimatrix& B) {
3496 return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(A,B);
3497}
3498
3500inline cimatrix operator|(const imatrix& A, const scimatrix& B) {
3501 return fsp_mm_hull<imatrix,scimatrix,cimatrix>(A,B);
3502}
3503
3505inline cimatrix operator|(const imatrix& A, const scmatrix& B) {
3506 return fsp_mm_hull<imatrix,scmatrix,cimatrix>(A,B);
3507}
3508
3510inline cimatrix operator|(const cmatrix& A, const simatrix& B) {
3511 return fsp_mm_hull<cmatrix,simatrix,cimatrix>(A,B);
3512}
3513
3515inline cimatrix operator|(const scimatrix& A, const rmatrix& B) {
3516 return spf_mm_hull<scimatrix,rmatrix,cimatrix>(A,B);
3517}
3518
3520inline cimatrix operator|(const scimatrix& A, const cmatrix& B) {
3521 return spf_mm_hull<scimatrix,cmatrix,cimatrix>(A,B);
3522}
3523
3525inline cimatrix operator|(const scimatrix& A, const imatrix& B) {
3526 return spf_mm_hull<scimatrix,imatrix,cimatrix>(A,B);
3527}
3528
3530inline cimatrix operator|(const scimatrix& A, const cimatrix& B) {
3531 return spf_mm_hull<scimatrix,cimatrix,cimatrix>(A,B);
3532}
3533
3535inline cimatrix operator|(const srmatrix& A, const cimatrix& B) {
3536 return spf_mm_hull<srmatrix,cimatrix,cimatrix>(A,B);
3537}
3538
3540inline cimatrix operator|(const scmatrix& A, const cimatrix& B) {
3541 return spf_mm_hull<scmatrix,cimatrix,cimatrix>(A,B);
3542}
3543
3545inline cimatrix operator|(const simatrix& A, const cimatrix& B) {
3546 return spf_mm_hull<simatrix,cimatrix,cimatrix>(A,B);
3547}
3548
3550inline cimatrix operator|(const simatrix& A, const cmatrix& B) {
3551 return spf_mm_hull<simatrix,cmatrix,cimatrix>(A,B);
3552}
3553
3555inline cimatrix operator|(const scmatrix& A, const imatrix& B) {
3556 return spf_mm_hull<scmatrix,imatrix,cimatrix>(A,B);
3557}
3558
3560inline cimatrix operator|(const cimatrix_slice& A, const srmatrix& B) {
3561 return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(A,B);
3562}
3563
3565inline cimatrix operator|(const cimatrix_slice& A, const simatrix& B) {
3566 return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(A,B);
3567}
3568
3570inline cimatrix operator|(const cimatrix_slice& A, const scmatrix& B) {
3571 return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(A,B);
3572}
3573
3575inline cimatrix operator|(const cimatrix_slice& A, const scimatrix& B) {
3576 return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(A,B);
3577}
3578
3580inline cimatrix operator|(const rmatrix_slice& A, const scimatrix& B) {
3581 return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(A,B);
3582}
3583
3585inline cimatrix operator|(const imatrix_slice& A, const scimatrix& B) {
3586 return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(A,B);
3587}
3588
3590inline cimatrix operator|(const cmatrix_slice& A, const scimatrix& B) {
3591 return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(A,B);
3592}
3593
3595inline cimatrix operator|(const cmatrix_slice& A, const simatrix& B) {
3596 return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(A,B);
3597}
3598
3600inline cimatrix operator|(const imatrix_slice& A, const scmatrix& B) {
3601 return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(A,B);
3602}
3603
3605inline cimatrix operator|(const scimatrix& A, const rmatrix_slice& B) {
3606 return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(A,B);
3607}
3608
3610inline cimatrix operator|(const scimatrix& A, const cmatrix_slice& B) {
3611 return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(A,B);
3612}
3613
3615inline cimatrix operator|(const scimatrix& A, const imatrix_slice& B) {
3616 return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(A,B);
3617}
3618
3620inline cimatrix operator|(const scimatrix& A, const cimatrix_slice& B) {
3621 return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(A,B);
3622}
3623
3625inline cimatrix operator|(const srmatrix& A, const cimatrix_slice& B) {
3626 return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(A,B);
3627}
3628
3630inline cimatrix operator|(const scmatrix& A, const cimatrix_slice& B) {
3631 return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(A,B);
3632}
3633
3635inline cimatrix operator|(const simatrix& A, const cimatrix_slice& B) {
3636 return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(A,B);
3637}
3638
3640inline cimatrix operator|(const simatrix& A, const cmatrix_slice& B) {
3641 return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(A,B);
3642}
3643
3645inline cimatrix operator|(const scmatrix& A, const imatrix_slice& B) {
3646 return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(A,B);
3647}
3648
3650inline scimatrix operator|(const scimatrix& A, const srmatrix& B) {
3651 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3652}
3653
3655inline scimatrix operator|(const scimatrix& A, const scmatrix& B) {
3656 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3657}
3658
3660inline scimatrix operator|(const scimatrix& A, const simatrix& B) {
3661 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3662}
3663
3665inline scimatrix operator|(const scimatrix& A, const scimatrix& B) {
3666 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3667}
3668
3670inline scimatrix operator|(const srmatrix& A, const scimatrix& B) {
3671 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3672}
3673
3675inline scimatrix operator|(const scmatrix& A, const scimatrix& B) {
3676 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3677}
3678
3680inline scimatrix operator|(const simatrix& A, const scimatrix& B) {
3681 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3682}
3683
3685inline scimatrix operator|(const simatrix& A, const scmatrix& B) {
3686 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3687}
3688
3690inline scimatrix operator|(const scmatrix& A, const simatrix& B) {
3691 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3692}
3693
3695inline cimatrix operator|(const cmatrix& A, const srmatrix& B) {
3696 return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(A,B);
3697}
3698
3700inline cimatrix operator|(const rmatrix& A, const scmatrix& B) {
3701 return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(A,B);
3702}
3703
3705inline cimatrix operator|(const cmatrix& A, const scmatrix& B) {
3706 return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(A,B);
3707}
3708
3710inline cimatrix operator|(const scmatrix& A, const rmatrix& B) {
3711 return spf_mm_hull<scmatrix,rmatrix,cimatrix>(A,B);
3712}
3713
3715inline cimatrix operator|(const srmatrix& A, const cmatrix& B) {
3716 return spf_mm_hull<srmatrix,cmatrix,cimatrix>(A,B);
3717}
3718
3720inline cimatrix operator|(const scmatrix& A, const cmatrix& B) {
3721 return spf_mm_hull<scmatrix,cmatrix,cimatrix>(A,B);
3722}
3723
3725inline cimatrix operator|(const cmatrix_slice& A, const srmatrix& B) {
3726 return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(A,B);
3727}
3728
3730inline cimatrix operator|(const rmatrix_slice& A, const scmatrix& B) {
3731 return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(A,B);
3732}
3733
3735inline cimatrix operator|(const cmatrix_slice& A, const scmatrix& B) {
3736 return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(A,B);
3737}
3738
3740inline cimatrix operator|(const scmatrix& A, const rmatrix_slice& B) {
3741 return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(A,B);
3742}
3743
3745inline cimatrix operator|(const srmatrix& A, const cmatrix_slice& B) {
3746 return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(A,B);
3747}
3748
3750inline cimatrix operator|(const scmatrix& A, const cmatrix_slice& B) {
3751 return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(A,B);
3752}
3753
3755inline scimatrix operator|(const scmatrix& A, const srmatrix& B) {
3756 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(A,B);
3757}
3758
3760inline scimatrix operator|(const srmatrix& A, const scmatrix& B) {
3761 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(A,B);
3762}
3763
3765inline scimatrix operator|(const scmatrix& A, const scmatrix& B) {
3766 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(A,B);
3767}
3768
3770inline cimatrix operator&(const cimatrix& A, const simatrix& B) {
3771 return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(A,B);
3772}
3773
3775inline cimatrix operator&(const cimatrix& A, const scimatrix& B) {
3776 return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(A,B);
3777}
3778
3780inline cimatrix operator&(const imatrix& A, const scimatrix& B) {
3781 return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(A,B);
3782}
3783
3785inline cimatrix operator&(const scimatrix& A, const imatrix& B) {
3786 return spf_mm_intersect<scimatrix,imatrix,cimatrix>(A,B);
3787}
3788
3790inline cimatrix operator&(const scimatrix& A, const cimatrix& B) {
3791 return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(A,B);
3792}
3793
3795inline cimatrix operator&(const simatrix& A, const cimatrix& B) {
3796 return spf_mm_intersect<simatrix,cimatrix,cimatrix>(A,B);
3797}
3798
3800inline cimatrix operator&(const cimatrix_slice& A, const simatrix& B) {
3801 return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(A,B);
3802}
3803
3805inline cimatrix operator&(const cimatrix_slice& A, const scimatrix& B) {
3806 return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(A,B);
3807}
3808
3810inline cimatrix operator&(const imatrix_slice& A, const scimatrix& B) {
3811 return fsp_mm_intersect<imatrix_slice,scimatrix,cimatrix>(A,B);
3812}
3813
3815inline cimatrix operator&(const scimatrix& A, const imatrix_slice& B) {
3816 return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(A,B);
3817}
3818
3820inline cimatrix operator&(const scimatrix& A, const cimatrix_slice& B) {
3821 return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(A,B);
3822}
3823
3825inline cimatrix operator&(const simatrix& A, const cimatrix_slice& B) {
3826 return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(A,B);
3827}
3828
3830inline scimatrix operator&(const scimatrix& A, const simatrix& B) {
3831 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3832}
3833
3835inline scimatrix operator&(const scimatrix& A, const scimatrix& B) {
3836 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3837}
3838
3840inline scimatrix operator&(const simatrix& A, const scimatrix& B) {
3841 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3842}
3843
3845inline scimatrix operator-(const scimatrix& M) {
3846 return sp_m_negative<scimatrix,scimatrix>(M);
3847}
3848
3850inline scimatrix& operator+(scimatrix& A) {
3851 return A;
3852}
3853
3855 *this = rmatrix(B);
3856 return *this;
3857}
3858
3860 *this = cmatrix(B);
3861 return *this;
3862}
3863
3865 *this = imatrix(B);
3866 return *this;
3867}
3868
3870 *this = cimatrix(B);
3871 return *this;
3872}
3873
3875 *this = rmatrix(B);
3876 return *this;
3877}
3878
3880 *this = cmatrix(B);
3881 return *this;
3882}
3883
3885 *this = imatrix(B);
3886 return *this;
3887}
3888
3890 *this = cimatrix(B);
3891 return *this;
3892}
3893
3895 return fsp_mm_addassign(*this,B);
3896}
3897
3899 return fsp_mm_addassign(*this,B);
3900}
3901
3903 return fsp_mm_addassign(*this,B);
3904}
3905
3907 return fsp_mm_addassign(*this,B);
3908}
3909
3911 return fsp_mm_addassign(*this,B);
3912}
3913
3915 return fsp_mm_addassign(*this,B);
3916}
3917
3919 return fsp_mm_addassign(*this,B);
3920}
3921
3923 return fsp_mm_addassign(*this,B);
3924}
3925
3927 return fsp_mm_subassign(*this,B);
3928}
3929
3931 return fsp_mm_subassign(*this,B);
3932}
3933
3935 return fsp_mm_subassign(*this,B);
3936}
3937
3939 return fsp_mm_subassign(*this,B);
3940}
3941
3943 return fsp_mm_subassign(*this,B);
3944}
3945
3947 return fsp_mm_subassign(*this,B);
3948}
3949
3951 return fsp_mm_subassign(*this,B);
3952}
3953
3955 return fsp_mm_subassign(*this,B);
3956}
3957
3959 return fsp_mm_hullassign(*this,B);
3960}
3961
3963 return fsp_mm_hullassign(*this,B);
3964}
3965
3967 return fsp_mm_hullassign(*this,B);
3968}
3969
3971 return fsp_mm_hullassign(*this,B);
3972}
3973
3975 return fsp_mm_hullassign(*this,B);
3976}
3977
3979 return fsp_mm_hullassign(*this,B);
3980}
3981
3983 return fsp_mm_hullassign(*this,B);
3984}
3985
3987 return fsp_mm_hullassign(*this,B);
3988}
3989
3991 return fsp_mm_intersectassign(*this,B);
3992}
3993
3995 return fsp_mm_intersectassign(*this,B);
3996}
3997
3999 return fsp_mm_intersectassign(*this,B);
4000}
4001
4003 return fsp_mm_intersectassign(*this,B);
4004}
4005
4007 return fsp_mm_multassign<cimatrix,srmatrix,sparse_cidot,cimatrix>(*this,B);
4008}
4009
4011 return fsp_mm_multassign<cimatrix,scmatrix,sparse_cidot,cimatrix>(*this,B);
4012}
4013
4015 return fsp_mm_multassign<cimatrix,simatrix,sparse_cidot,cimatrix>(*this,B);
4016}
4017
4019 return fsp_mm_multassign<cimatrix,scimatrix,sparse_cidot,cimatrix>(*this,B);
4020}
4021
4023 return fsp_mm_multassign<cimatrix_slice,srmatrix,sparse_cidot,cimatrix>(*this,B);
4024}
4025
4027 return fsp_mm_multassign<cimatrix_slice,scmatrix,sparse_cidot,cimatrix>(*this,B);
4028}
4029
4031 return fsp_mm_multassign<cimatrix_slice,simatrix,sparse_cidot,cimatrix>(*this,B);
4032}
4033
4035 return fsp_mm_multassign<cimatrix_slice,scimatrix,sparse_cidot,cimatrix>(*this,B);
4036}
4037
4039inline bool operator==(const scimatrix& A, const srmatrix& B) {
4040 return spsp_mm_comp(A,B);
4041}
4042
4044inline bool operator==(const scimatrix& A, const scmatrix& B) {
4045 return spsp_mm_comp(A,B);
4046}
4047
4049inline bool operator==(const scimatrix& A, const simatrix& B) {
4050 return spsp_mm_comp(A,B);
4051}
4052
4054inline bool operator==(const scimatrix& A, const scimatrix& B) {
4055 return spsp_mm_comp(A,B);
4056}
4057
4059inline bool operator==(const srmatrix& A, const scimatrix& B) {
4060 return spsp_mm_comp(A,B);
4061}
4062
4064inline bool operator==(const scmatrix& A, const scimatrix& B) {
4065 return spsp_mm_comp(A,B);
4066}
4067
4069inline bool operator==(const simatrix& A, const scimatrix& B) {
4070 return spsp_mm_comp(A,B);
4071}
4072
4074inline bool operator==(const scimatrix& A, const rmatrix& B) {
4075 return spf_mm_comp(A,B);
4076}
4077
4079inline bool operator==(const scimatrix& A, const imatrix& B) {
4080 return spf_mm_comp(A,B);
4081}
4082
4084inline bool operator==(const scimatrix& A, const cmatrix& B) {
4085 return spf_mm_comp(A,B);
4086}
4087
4089inline bool operator==(const scimatrix& A, const cimatrix& B) {
4090 return spf_mm_comp(A,B);
4091}
4092
4094inline bool operator==(const srmatrix& A, const cimatrix& B) {
4095 return spf_mm_comp(A,B);
4096}
4097
4099inline bool operator==(const scmatrix& A, const cimatrix& B) {
4100 return spf_mm_comp(A,B);
4101}
4102
4104inline bool operator==(const simatrix& A, const cimatrix& B) {
4105 return spf_mm_comp(A,B);
4106}
4107
4109inline bool operator==(const cimatrix& A, const srmatrix& B) {
4110 return fsp_mm_comp(A,B);
4111}
4112
4114inline bool operator==(const cimatrix& A, const simatrix& B) {
4115 return fsp_mm_comp(A,B);
4116}
4117
4119inline bool operator==(const cimatrix& A, const scmatrix& B) {
4120 return fsp_mm_comp(A,B);
4121}
4122
4124inline bool operator==(const cimatrix& A, const scimatrix& B) {
4125 return fsp_mm_comp(A,B);
4126}
4127
4129inline bool operator==(const rmatrix& A, const scimatrix& B) {
4130 return fsp_mm_comp(A,B);
4131}
4132
4134inline bool operator==(const cmatrix& A, const scimatrix& B) {
4135 return fsp_mm_comp(A,B);
4136}
4137
4139inline bool operator==(const imatrix& A, const scimatrix& B) {
4140 return fsp_mm_comp(A,B);
4141}
4142
4144inline bool operator==(const cimatrix_slice& A, const srmatrix& B) {
4145 return fsp_mm_comp(A,B);
4146}
4147
4149inline bool operator==(const cimatrix_slice& A, const scmatrix& B) {
4150 return fsp_mm_comp(A,B);
4151}
4152
4154inline bool operator==(const cimatrix_slice& A, const simatrix& B) {
4155 return fsp_mm_comp(A,B);
4156}
4157
4159inline bool operator==(const cimatrix_slice& A, const scimatrix& B) {
4160 return fsp_mm_comp(A,B);
4161}
4162
4164inline bool operator==(const rmatrix_slice& A, const scimatrix& B) {
4165 return fsp_mm_comp(A,B);
4166}
4167
4169inline bool operator==(const cmatrix_slice& A, const scimatrix& B) {
4170 return fsp_mm_comp(A,B);
4171}
4172
4174inline bool operator==(const imatrix_slice& A, const scimatrix& B) {
4175 return fsp_mm_comp(A,B);
4176}
4177
4179inline bool operator==(const scimatrix& A, const rmatrix_slice& B) {
4180 return spf_mm_comp(A,B);
4181}
4182
4184inline bool operator==(const scimatrix& A, const imatrix_slice& B) {
4185 return spf_mm_comp(A,B);
4186}
4187
4189inline bool operator==(const scimatrix& A, const cmatrix_slice& B) {
4190 return spf_mm_comp(A,B);
4191}
4192
4194inline bool operator==(const scimatrix& A, const cimatrix_slice& B) {
4195 return spf_mm_comp(A,B);
4196}
4197
4199inline bool operator==(const srmatrix& A, const cimatrix_slice& B) {
4200 return spf_mm_comp(A,B);
4201}
4202
4204inline bool operator==(const scmatrix& A, const cimatrix_slice& B) {
4205 return spf_mm_comp(A,B);
4206}
4207
4209inline bool operator==(const simatrix& A, const cimatrix_slice& B) {
4210 return spf_mm_comp(A,B);
4211}
4212
4214inline bool operator!=(const scimatrix& A, const srmatrix& B) {
4215 return !spsp_mm_comp(A,B);
4216}
4217
4219inline bool operator!=(const scimatrix& A, const scmatrix& B) {
4220 return !spsp_mm_comp(A,B);
4221}
4222
4224inline bool operator!=(const scimatrix& A, const simatrix& B) {
4225 return !spsp_mm_comp(A,B);
4226}
4227
4229inline bool operator!=(const scimatrix& A, const scimatrix& B) {
4230 return !spsp_mm_comp(A,B);
4231}
4232
4234inline bool operator!=(const srmatrix& A, const scimatrix& B) {
4235 return !spsp_mm_comp(A,B);
4236}
4237
4239inline bool operator!=(const scmatrix& A, const scimatrix& B) {
4240 return !spsp_mm_comp(A,B);
4241}
4242
4244inline bool operator!=(const simatrix& A, const scimatrix& B) {
4245 return !spsp_mm_comp(A,B);
4246}
4247
4249inline bool operator!=(const scimatrix& A, const rmatrix& B) {
4250 return !spf_mm_comp(A,B);
4251}
4252
4254inline bool operator!=(const scimatrix& A, const imatrix& B) {
4255 return !spf_mm_comp(A,B);
4256}
4257
4259inline bool operator!=(const scimatrix& A, const cmatrix& B) {
4260 return !spf_mm_comp(A,B);
4261}
4262
4264inline bool operator!=(const scimatrix& A, const cimatrix& B) {
4265 return !spf_mm_comp(A,B);
4266}
4267
4269inline bool operator!=(const srmatrix& A, const cimatrix& B) {
4270 return !spf_mm_comp(A,B);
4271}
4272
4274inline bool operator!=(const scmatrix& A, const cimatrix& B) {
4275 return !spf_mm_comp(A,B);
4276}
4277
4279inline bool operator!=(const simatrix& A, const cimatrix& B) {
4280 return !spf_mm_comp(A,B);
4281}
4282
4284inline bool operator!=(const cimatrix& A, const srmatrix& B) {
4285 return !fsp_mm_comp(A,B);
4286}
4287
4289inline bool operator!=(const cimatrix& A, const simatrix& B) {
4290 return !fsp_mm_comp(A,B);
4291}
4292
4294inline bool operator!=(const cimatrix& A, const scmatrix& B) {
4295 return !fsp_mm_comp(A,B);
4296}
4297
4299inline bool operator!=(const cimatrix& A, const scimatrix& B) {
4300 return !fsp_mm_comp(A,B);
4301}
4302
4304inline bool operator!=(const rmatrix& A, const scimatrix& B) {
4305 return !fsp_mm_comp(A,B);
4306}
4307
4309inline bool operator!=(const cmatrix& A, const scimatrix& B) {
4310 return !fsp_mm_comp(A,B);
4311}
4312
4314inline bool operator!=(const imatrix& A, const scimatrix& B) {
4315 return !fsp_mm_comp(A,B);
4316}
4317
4319inline bool operator!=(const cimatrix_slice& A, const srmatrix& B) {
4320 return !fsp_mm_comp(A,B);
4321}
4322
4324inline bool operator!=(const cimatrix_slice& A, const scmatrix& B) {
4325 return !fsp_mm_comp(A,B);
4326}
4327
4329inline bool operator!=(const cimatrix_slice& A, const simatrix& B) {
4330 return !fsp_mm_comp(A,B);
4331}
4332
4334inline bool operator!=(const cimatrix_slice& A, const scimatrix& B) {
4335 return !fsp_mm_comp(A,B);
4336}
4337
4339inline bool operator!=(const rmatrix_slice& A, const scimatrix& B) {
4340 return !fsp_mm_comp(A,B);
4341}
4342
4344inline bool operator!=(const cmatrix_slice& A, const scimatrix& B) {
4345 return !fsp_mm_comp(A,B);
4346}
4347
4349inline bool operator!=(const imatrix_slice& A, const scimatrix& B) {
4350 return !fsp_mm_comp(A,B);
4351}
4352
4354inline bool operator!=(const scimatrix& A, const rmatrix_slice& B) {
4355 return !spf_mm_comp(A,B);
4356}
4357
4359inline bool operator!=(const scimatrix& A, const imatrix_slice& B) {
4360 return !spf_mm_comp(A,B);
4361}
4362
4364inline bool operator!=(const scimatrix& A, const cmatrix_slice& B) {
4365 return !spf_mm_comp(A,B);
4366}
4367
4369inline bool operator!=(const scimatrix& A, const cimatrix_slice& B) {
4370 return !spf_mm_comp(A,B);
4371}
4372
4374inline bool operator!=(const srmatrix& A, const cimatrix_slice& B) {
4375 return !spf_mm_comp(A,B);
4376}
4377
4379inline bool operator!=(const scmatrix& A, const cimatrix_slice& B) {
4380 return !spf_mm_comp(A,B);
4381}
4382
4384inline bool operator!=(const simatrix& A, const cimatrix_slice& B) {
4385 return !spf_mm_comp(A,B);
4386}
4387
4389inline bool operator<(const scimatrix& A, const simatrix& B) {
4390 return spsp_mm_less<scimatrix,simatrix,cinterval>(A,B);
4391}
4392
4394inline bool operator<(const scimatrix& A, const scimatrix& B) {
4395 return spsp_mm_less<scimatrix,scimatrix,cinterval>(A,B);
4396}
4397
4399inline bool operator<(const srmatrix& A, const scimatrix& B) {
4400 return spsp_mm_less<srmatrix,scimatrix,cinterval>(A,B);
4401}
4402
4404inline bool operator<(const scmatrix& A, const scimatrix& B) {
4405 return spsp_mm_less<scmatrix,scimatrix,cinterval>(A,B);
4406}
4407
4409inline bool operator<(const simatrix& A, const scimatrix& B) {
4410 return spsp_mm_less<simatrix,scimatrix,cinterval>(A,B);
4411}
4412
4414inline bool operator<(const scimatrix& A, const imatrix& B) {
4415 return spf_mm_less<scimatrix,imatrix,cinterval>(A,B);
4416}
4417
4419inline bool operator<(const scimatrix& A, const cimatrix& B) {
4420 return spf_mm_less<scimatrix,cimatrix,cinterval>(A,B);
4421}
4422
4424inline bool operator<(const srmatrix& A, const cimatrix& B) {
4425 return spf_mm_less<srmatrix,cimatrix,cinterval>(A,B);
4426}
4427
4429inline bool operator<(const scmatrix& A, const cimatrix& B) {
4430 return spf_mm_less<scmatrix,cimatrix,cinterval>(A,B);
4431}
4432
4434inline bool operator<(const simatrix& A, const cimatrix& B) {
4435 return spf_mm_less<simatrix,cimatrix,cinterval>(A,B);
4436}
4437
4439inline bool operator<(const cimatrix& A, const simatrix& B) {
4440 return fsp_mm_less<cimatrix,simatrix,cinterval>(A,B);
4441}
4442
4444inline bool operator<(const cimatrix& A, const scimatrix& B) {
4445 return fsp_mm_less<cimatrix,scimatrix,cinterval>(A,B);
4446}
4447
4449inline bool operator<(const rmatrix& A, const scimatrix& B) {
4450 return fsp_mm_less<rmatrix,scimatrix,cinterval>(A,B);
4451}
4452
4454inline bool operator<(const cmatrix& A, const scimatrix& B) {
4455 return fsp_mm_less<cmatrix,scimatrix,cinterval>(A,B);
4456}
4457
4459inline bool operator<(const imatrix& A, const scimatrix& B) {
4460 return fsp_mm_less<imatrix,scimatrix,cinterval>(A,B);
4461}
4462
4464inline bool operator<(const cimatrix_slice& A, const simatrix& B) {
4465 return fsp_mm_less<cimatrix_slice,simatrix,cinterval>(A,B);
4466}
4467
4469inline bool operator<(const cimatrix_slice& A, const scimatrix& B) {
4470 return fsp_mm_less<cimatrix_slice,scimatrix,cinterval>(A,B);
4471}
4472
4474inline bool operator<(const rmatrix_slice& A, const scimatrix& B) {
4475 return fsp_mm_less<rmatrix_slice,scimatrix,cinterval>(A,B);
4476}
4477
4479inline bool operator<(const cmatrix_slice& A, const scimatrix& B) {
4480 return fsp_mm_less<cmatrix_slice,scimatrix,cinterval>(A,B);
4481}
4482
4484inline bool operator<(const imatrix_slice& A, const scimatrix& B) {
4485 return fsp_mm_less<imatrix_slice,scimatrix,cinterval>(A,B);
4486}
4487
4489inline bool operator<(const scimatrix& A, const imatrix_slice& B) {
4490 return spf_mm_less<scimatrix,imatrix_slice,cinterval>(A,B);
4491}
4492
4494inline bool operator<(const scimatrix& A, const cimatrix_slice& B) {
4495 return spf_mm_less<scimatrix,cimatrix_slice,cinterval>(A,B);
4496}
4497
4499inline bool operator<(const srmatrix& A, const cimatrix_slice& B) {
4500 return spf_mm_less<srmatrix,cimatrix_slice,cinterval>(A,B);
4501}
4502
4504inline bool operator<(const scmatrix& A, const cimatrix_slice& B) {
4505 return spf_mm_less<scmatrix,cimatrix_slice,cinterval>(A,B);
4506}
4507
4509inline bool operator<(const simatrix& A, const cimatrix_slice& B) {
4510 return spf_mm_less<simatrix,cimatrix_slice,cinterval>(A,B);
4511}
4512
4514inline bool operator<=(const scimatrix& A, const simatrix& B) {
4515 return spsp_mm_leq<scimatrix,simatrix,cinterval>(A,B);
4516}
4517
4519inline bool operator<=(const scimatrix& A, const scimatrix& B) {
4520 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(A,B);
4521}
4522
4524inline bool operator<=(const srmatrix& A, const scimatrix& B) {
4525 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(A,B);
4526}
4527
4529inline bool operator<=(const scmatrix& A, const scimatrix& B) {
4530 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(A,B);
4531}
4532
4534inline bool operator<=(const simatrix& A, const scimatrix& B) {
4535 return spsp_mm_leq<simatrix,scimatrix,cinterval>(A,B);
4536}
4537
4539inline bool operator<=(const scimatrix& A, const imatrix& B) {
4540 return spf_mm_leq<scimatrix,imatrix,cinterval>(A,B);
4541}
4542
4544inline bool operator<=(const scimatrix& A, const cimatrix& B) {
4545 return spf_mm_leq<scimatrix,cimatrix,cinterval>(A,B);
4546}
4547
4549inline bool operator<=(const srmatrix& A, const cimatrix& B) {
4550 return spf_mm_leq<srmatrix,cimatrix,cinterval>(A,B);
4551}
4552
4554inline bool operator<=(const scmatrix& A, const cimatrix& B) {
4555 return spf_mm_leq<scmatrix,cimatrix,cinterval>(A,B);
4556}
4557
4559inline bool operator<=(const simatrix& A, const cimatrix& B) {
4560 return spf_mm_leq<simatrix,cimatrix,cinterval>(A,B);
4561}
4562
4564inline bool operator<=(const cimatrix& A, const simatrix& B) {
4565 return fsp_mm_leq<cimatrix,simatrix,cinterval>(A,B);
4566}
4567
4569inline bool operator<=(const cimatrix& A, const scimatrix& B) {
4570 return fsp_mm_leq<cimatrix,scimatrix,cinterval>(A,B);
4571}
4572
4574inline bool operator<=(const rmatrix& A, const scimatrix& B) {
4575 return fsp_mm_leq<rmatrix,scimatrix,cinterval>(A,B);
4576}
4577
4579inline bool operator<=(const cmatrix& A, const scimatrix& B) {
4580 return fsp_mm_leq<cmatrix,scimatrix,cinterval>(A,B);
4581}
4582
4584inline bool operator<=(const imatrix& A, const scimatrix& B) {
4585 return fsp_mm_leq<imatrix,scimatrix,cinterval>(A,B);
4586}
4587
4589inline bool operator<=(const cimatrix_slice& A, const simatrix& B) {
4590 return fsp_mm_leq<cimatrix_slice,simatrix,cinterval>(A,B);
4591}
4592
4594inline bool operator<=(const cimatrix_slice& A, const scimatrix& B) {
4595 return fsp_mm_leq<cimatrix_slice,scimatrix,cinterval>(A,B);
4596}
4597
4599inline bool operator<=(const rmatrix_slice& A, const scimatrix& B) {
4600 return fsp_mm_leq<rmatrix_slice,scimatrix,cinterval>(A,B);
4601}
4602
4604inline bool operator<=(const cmatrix_slice& A, const scimatrix& B) {
4605 return fsp_mm_leq<cmatrix_slice,scimatrix,cinterval>(A,B);
4606}
4607
4609inline bool operator<=(const imatrix_slice& A, const scimatrix& B) {
4610 return fsp_mm_leq<imatrix_slice,scimatrix,cinterval>(A,B);
4611}
4612
4614inline bool operator<=(const scimatrix& A, const imatrix_slice& B) {
4615 return spf_mm_leq<scimatrix,imatrix_slice,cinterval>(A,B);
4616}
4617
4619inline bool operator<=(const scimatrix& A, const cimatrix_slice& B) {
4620 return spf_mm_leq<scimatrix,cimatrix_slice,cinterval>(A,B);
4621}
4622
4624inline bool operator<=(const srmatrix& A, const cimatrix_slice& B) {
4625 return spf_mm_leq<srmatrix,cimatrix_slice,cinterval>(A,B);
4626}
4627
4629inline bool operator<=(const scmatrix& A, const cimatrix_slice& B) {
4630 return spf_mm_leq<scmatrix,cimatrix_slice,cinterval>(A,B);
4631}
4632
4634inline bool operator<=(const simatrix& A, const cimatrix_slice& B) {
4635 return spf_mm_leq<simatrix,cimatrix_slice,cinterval>(A,B);
4636}
4637
4639inline bool operator>(const scimatrix& A, const srmatrix& B) {
4640 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(A,B);
4641}
4642
4644inline bool operator>(const scimatrix& A, const scmatrix& B) {
4645 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(A,B);
4646}
4647
4649inline bool operator>(const scimatrix& A, const simatrix& B) {
4650 return spsp_mm_greater<scimatrix,simatrix,cinterval>(A,B);
4651}
4652
4654inline bool operator>(const scimatrix& A, const scimatrix& B) {
4655 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(A,B);
4656}
4657
4659inline bool operator>(const simatrix& A, const scimatrix& B) {
4660 return spsp_mm_greater<simatrix,scimatrix,cinterval>(A,B);
4661}
4662
4664inline bool operator>(const scimatrix& A, const rmatrix& B) {
4665 return spf_mm_greater<scimatrix,rmatrix,cinterval>(A,B);
4666}
4667
4669inline bool operator>(const scimatrix& A, const imatrix& B) {
4670 return spf_mm_greater<scimatrix,imatrix,cinterval>(A,B);
4671}
4672
4674inline bool operator>(const scimatrix& A, const cmatrix& B) {
4675 return spf_mm_greater<scimatrix,cmatrix,cinterval>(A,B);
4676}
4677
4679inline bool operator>(const scimatrix& A, const cimatrix& B) {
4680 return spf_mm_greater<scimatrix,cimatrix,cinterval>(A,B);
4681}
4682
4684inline bool operator>(const simatrix& A, const cimatrix& B) {
4685 return spf_mm_greater<simatrix,cimatrix,cinterval>(A,B);
4686}
4687
4689inline bool operator>(const cimatrix& A, const srmatrix& B) {
4690 return fsp_mm_greater<cimatrix,srmatrix,cinterval>(A,B);
4691}
4692
4694inline bool operator>(const cimatrix& A, const simatrix& B) {
4695 return fsp_mm_greater<cimatrix,simatrix,cinterval>(A,B);
4696}
4697
4699inline bool operator>(const cimatrix& A, const scmatrix& B) {
4700 return fsp_mm_greater<cimatrix,scmatrix,cinterval>(A,B);
4701}
4702
4704inline bool operator>(const cimatrix& A, const scimatrix& B) {
4705 return fsp_mm_greater<cimatrix,scimatrix,cinterval>(A,B);
4706}
4707
4709inline bool operator>(const imatrix& A, const scimatrix& B) {
4710 return fsp_mm_greater<imatrix,scimatrix,cinterval>(A,B);
4711}
4712
4714inline bool operator>(const cimatrix_slice& A, const srmatrix& B) {
4715 return fsp_mm_greater<cimatrix_slice,srmatrix,cinterval>(A,B);
4716}
4717
4719inline bool operator>(const cimatrix_slice& A, const scmatrix& B) {
4720 return fsp_mm_greater<cimatrix_slice,scmatrix,cinterval>(A,B);
4721}
4722
4724inline bool operator>(const cimatrix_slice& A, const simatrix& B) {
4725 return fsp_mm_greater<cimatrix_slice,simatrix,cinterval>(A,B);
4726}
4727
4729inline bool operator>(const cimatrix_slice& A, const scimatrix& B) {
4730 return fsp_mm_greater<cimatrix_slice,scimatrix,cinterval>(A,B);
4731}
4732
4734inline bool operator>(const imatrix_slice& A, const scimatrix& B) {
4735 return fsp_mm_greater<imatrix_slice,scimatrix,cinterval>(A,B);
4736}
4737
4739inline bool operator>(const scimatrix& A, const rmatrix_slice& B) {
4740 return spf_mm_greater<scimatrix,rmatrix_slice,cinterval>(A,B);
4741}
4742
4744inline bool operator>(const scimatrix& A, const imatrix_slice& B) {
4745 return spf_mm_greater<scimatrix,imatrix_slice,cinterval>(A,B);
4746}
4747
4749inline bool operator>(const scimatrix& A, const cmatrix_slice& B) {
4750 return spf_mm_greater<scimatrix,cmatrix_slice,cinterval>(A,B);
4751}
4752
4754inline bool operator>(const scimatrix& A, const cimatrix_slice& B) {
4755 return spf_mm_greater<scimatrix,cimatrix_slice,cinterval>(A,B);
4756}
4757
4759inline bool operator>(const simatrix& A, const cimatrix_slice& B) {
4760 return spf_mm_greater<simatrix,cimatrix_slice,cinterval>(A,B);
4761}
4762
4764inline bool operator>=(const scimatrix& A, const srmatrix& B) {
4765 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(A,B);
4766}
4767
4769inline bool operator>=(const scimatrix& A, const scmatrix& B) {
4770 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(A,B);
4771}
4772
4774inline bool operator>=(const scimatrix& A, const simatrix& B) {
4775 return spsp_mm_geq<scimatrix,simatrix,cinterval>(A,B);
4776}
4777
4779inline bool operator>=(const scimatrix& A, const scimatrix& B) {
4780 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(A,B);
4781}
4782
4784inline bool operator>=(const simatrix& A, const scimatrix& B) {
4785 return spsp_mm_geq<simatrix,scimatrix,cinterval>(A,B);
4786}
4787
4789inline bool operator>=(const scimatrix& A, const rmatrix& B) {
4790 return spf_mm_geq<scimatrix,rmatrix,cinterval>(A,B);
4791}
4792
4794inline bool operator>=(const scimatrix& A, const imatrix& B) {
4795 return spf_mm_geq<scimatrix,imatrix,cinterval>(A,B);
4796}
4797
4799inline bool operator>=(const scimatrix& A, const cmatrix& B) {
4800 return spf_mm_geq<scimatrix,cmatrix,cinterval>(A,B);
4801}
4802
4804inline bool operator>=(const scimatrix& A, const cimatrix& B) {
4805 return spf_mm_geq<scimatrix,cimatrix,cinterval>(A,B);
4806}
4807
4809inline bool operator>=(const simatrix& A, const cimatrix& B) {
4810 return spf_mm_geq<simatrix,cimatrix,cinterval>(A,B);
4811}
4812
4814inline bool operator>=(const cimatrix& A, const srmatrix& B) {
4815 return fsp_mm_geq<cimatrix,srmatrix,cinterval>(A,B);
4816}
4817
4819inline bool operator>=(const cimatrix& A, const simatrix& B) {
4820 return fsp_mm_geq<cimatrix,simatrix,cinterval>(A,B);
4821}
4822
4824inline bool operator>=(const cimatrix& A, const scmatrix& B) {
4825 return fsp_mm_geq<cimatrix,scmatrix,cinterval>(A,B);
4826}
4827
4829inline bool operator>=(const cimatrix& A, const scimatrix& B) {
4830 return fsp_mm_geq<cimatrix,scimatrix,cinterval>(A,B);
4831}
4832
4834inline bool operator>=(const imatrix& A, const scimatrix& B) {
4835 return fsp_mm_geq<imatrix,scimatrix,cinterval>(A,B);
4836}
4837
4839inline bool operator>=(const cimatrix_slice& A, const srmatrix& B) {
4840 return fsp_mm_geq<cimatrix_slice,srmatrix,cinterval>(A,B);
4841}
4842
4844inline bool operator>=(const cimatrix_slice& A, const scmatrix& B) {
4845 return fsp_mm_geq<cimatrix_slice,scmatrix,cinterval>(A,B);
4846}
4847
4849inline bool operator>=(const cimatrix_slice& A, const simatrix& B) {
4850 return fsp_mm_geq<cimatrix_slice,simatrix,cinterval>(A,B);
4851}
4852
4854inline bool operator>=(const cimatrix_slice& A, const scimatrix& B) {
4855 return fsp_mm_geq<cimatrix_slice,scimatrix,cinterval>(A,B);
4856}
4857
4859inline bool operator>=(const imatrix_slice& A, const scimatrix& B) {
4860 return fsp_mm_geq<imatrix_slice,scimatrix,cinterval>(A,B);
4861}
4862
4864inline bool operator>=(const scimatrix& A, const rmatrix_slice& B) {
4865 return spf_mm_geq<scimatrix,rmatrix_slice,cinterval>(A,B);
4866}
4867
4869inline bool operator>=(const scimatrix& A, const imatrix_slice& B) {
4870 return spf_mm_geq<scimatrix,imatrix_slice,cinterval>(A,B);
4871}
4872
4874inline bool operator>=(const scimatrix& A, const cmatrix_slice& B) {
4875 return spf_mm_geq<scimatrix,cmatrix_slice,cinterval>(A,B);
4876}
4877
4879inline bool operator>=(const scimatrix& A, const cimatrix_slice& B) {
4880 return spf_mm_geq<scimatrix,cimatrix_slice,cinterval>(A,B);
4881}
4882
4884inline bool operator>=(const simatrix& A, const cimatrix_slice& B) {
4885 return spf_mm_geq<simatrix,cimatrix_slice,cinterval>(A,B);
4886}
4887
4889inline bool operator!(const scimatrix& A) {
4890 return sp_m_not(A);
4891}
4892
4894
4899inline std::ostream& operator<<(std::ostream& os, const scimatrix& A) {
4900 return sp_m_output<scimatrix,cinterval>(os,A);
4901}
4902
4904
4909inline std::istream& operator>>(std::istream& is, scimatrix& A) {
4910 return sp_m_input<scimatrix,cinterval>(is,A);
4911}
4912
4914
4919 public:
4920 scimatrix A;
4921 scimatrix* M; //Originalmatrix
4922
4923 private:
4924 scimatrix_slice(scimatrix& Mat, int sl1l, int sl1u, int sl2l, int sl2u) {
4925 A.lb1 = sl1l;
4926 A.lb2 = sl2l;
4927 A.ub1 = sl1u;
4928 A.ub2 = sl2u;
4929 A.m = sl1u-sl1l+1;
4930 A.n = sl2u-sl2l+1;
4931
4932 //Kopieren der Werte aus A
4933 A.p = std::vector<int>(A.n+1, 0);
4934 A.ind.reserve(A.m + A.n);
4935 A.x.reserve(A.m + A.n);
4936
4937 for(int i=0 ; i<A.n ; i++) {
4938 A.p[i+1] = A.p[i];
4939 for(int j=Mat.p[sl2l-Mat.lb2+i] ; j<Mat.p[sl2l-Mat.lb2+i+1] ; j++) {
4940 if(Mat.ind[j] >= sl1l-Mat.lb1 && Mat.ind[j] <= sl1u-Mat.lb1) {
4941 A.ind.push_back(Mat.ind[j]-(sl1l-Mat.lb1));
4942 A.x.push_back(Mat.x[j]);
4943 A.p[i+1]++;
4944 }
4945 }
4946 }
4947
4948 //Zeiger auf A fuer Datenmanipulationen
4949 M = &Mat;
4950 }
4951
4952 scimatrix_slice(const scimatrix& Mat, int sl1l, int sl1u, int sl2l, int sl2u) {
4953 A.lb1 = sl1l;
4954 A.lb2 = sl2l;
4955 A.ub1 = sl1u;
4956 A.ub2 = sl2u;
4957 A.m = sl1u-sl1l+1;
4958 A.n = sl2u-sl2l+1;
4959
4960 //Kopieren der Werte aus A
4961 A.p = std::vector<int>(A.n+1, 0);
4962 A.ind.reserve(A.m + A.n);
4963 A.x.reserve(A.m + A.n);
4964
4965 for(int i=0 ; i<A.n ; i++) {
4966 A.p[i+1] = A.p[i];
4967 for(int j=Mat.p[sl2l-Mat.lb2+i] ; j<Mat.p[sl2l-Mat.lb2+i+1] ; j++) {
4968 if(Mat.ind[j] >= sl1l-Mat.lb1 && Mat.ind[j] <= sl1u-Mat.lb1) {
4969 A.ind.push_back(Mat.ind[j]-(sl1l-Mat.lb1));
4970 A.x.push_back(Mat.x[j]);
4971 A.p[i+1]++;
4972 }
4973 }
4974 }
4975
4976 //Zeiger auf A fuer Datenmanipulationen
4977 M = const_cast<scimatrix*>(&Mat);
4978 }
4979
4980
4981 public:
4982
4985 return sl_ms_assign<scimatrix_slice, real, std::vector<cinterval>::iterator, cinterval>(*this,C);
4986 }
4987
4990 return sl_ms_assign<scimatrix_slice, interval, std::vector<cinterval>::iterator, cinterval>(*this,C);
4991 }
4992
4995 return sl_ms_assign<scimatrix_slice, complex, std::vector<cinterval>::iterator, cinterval>(*this,C);
4996 }
4997
5000 return sl_ms_assign<scimatrix_slice, cinterval, std::vector<cinterval>::iterator, cinterval>(*this,C);
5001 }
5002
5005 return slsp_mm_assign<scimatrix_slice, srmatrix, std::vector<cinterval>::iterator>(*this,C);
5006 }
5007
5010 return slsp_mm_assign<scimatrix_slice, scmatrix, std::vector<cinterval>::iterator>(*this,C);
5011 }
5012
5015 return slsp_mm_assign<scimatrix_slice, simatrix, std::vector<cinterval>::iterator>(*this,C);
5016 }
5017
5020 return slsp_mm_assign<scimatrix_slice, scimatrix, std::vector<cinterval>::iterator>(*this,C);
5021 }
5022
5025 return slf_mm_assign<scimatrix_slice, rmatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
5026 }
5027
5030 return slf_mm_assign<scimatrix_slice, cmatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
5031 }
5032
5035 return slf_mm_assign<scimatrix_slice, imatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
5036 }
5037
5040 return slf_mm_assign<scimatrix_slice, cimatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
5041 }
5042
5045 return slf_mm_assign<scimatrix_slice, rmatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
5046 }
5047
5050 return slf_mm_assign<scimatrix_slice, cmatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
5051 }
5052
5055 return slf_mm_assign<scimatrix_slice, imatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
5056 }
5057
5060 return slf_mm_assign<scimatrix_slice, cimatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
5061 }
5062
5065 *this = C.A;
5066 return *this;
5067 }
5068
5071 *this = C.A;
5072 return *this;
5073 }
5074
5077 *this = C.A;
5078 return *this;
5079 }
5080
5083 *this = C.A;
5084 return *this;
5085 }
5086
5089 *this = A*M.A;
5090 return *this;
5091 }
5092
5095 *this = A*M.A;
5096 return *this;
5097 }
5098
5101 *this = A*M.A;
5102 return *this;
5103 }
5104
5107 *this = A*M.A;
5108 return *this;
5109 }
5110
5113 *this = A*M;
5114 return *this;
5115 }
5116
5119 *this = A*M;
5120 return *this;
5121 }
5122
5125 *this = A*M;
5126 return *this;
5127 }
5128
5131 *this = A*M;
5132 return *this;
5133 }
5134
5137 *this = A*M;
5138 return *this;
5139 }
5140
5143 *this = A*M;
5144 return *this;
5145 }
5146
5149 *this = A*M;
5150 return *this;
5151 }
5152
5155 *this = A*M;
5156 return *this;
5157 }
5158
5161 *this = A*M;
5162 return *this;
5163 }
5164
5167 *this = A*M;
5168 return *this;
5169 }
5170
5173 *this = A*M;
5174 return *this;
5175 }
5176
5179 *this = A*M;
5180 return *this;
5181 }
5182
5185 *this = A*r;
5186 return *this;
5187 }
5188
5191 *this = A*r;
5192 return *this;
5193 }
5194
5197 *this = A*r;
5198 return *this;
5199 }
5200
5203 *this = A*r;
5204 return *this;
5205 }
5206
5209 *this = A/r;
5210 return *this;
5211 }
5212
5215 *this = A/r;
5216 return *this;
5217 }
5218
5221 *this = A/r;
5222 return *this;
5223 }
5224
5227 *this = A/r;
5228 return *this;
5229 }
5230
5233 *this = A+M.A;
5234 return *this;
5235 }
5236
5239 *this = A+M.A;
5240 return *this;
5241 }
5242
5245 *this = A+M.A;
5246 return *this;
5247 }
5248
5251 *this = A+M.A;
5252 return *this;
5253 }
5254
5257 *this = A+M;
5258 return *this;
5259 }
5260
5263 *this = A+M;
5264 return *this;
5265 }
5266
5269 *this = A+M;
5270 return *this;
5271 }
5272
5275 *this = A+M;
5276 return *this;
5277 }
5278
5281 *this = A+M;
5282 return *this;
5283 }
5284
5287 *this = A+M;
5288 return *this;
5289 }
5290
5293 *this = A+M;
5294 return *this;
5295 }
5296
5299 *this = A+M;
5300 return *this;
5301 }
5302
5305 *this = A+M;
5306 return *this;
5307 }
5308
5311 *this = A+M;
5312 return *this;
5313 }
5314
5317 *this = A+M;
5318 return *this;
5319 }
5320
5323 *this = A+M;
5324 return *this;
5325 }
5326
5329 *this = A-M.A;
5330 return *this;
5331 }
5332
5335 *this = A-M.A;
5336 return *this;
5337 }
5338
5341 *this = A-M.A;
5342 return *this;
5343 }
5344
5347 *this = A-M.A;
5348 return *this;
5349 }
5350
5353 *this = A-M;
5354 return *this;
5355 }
5356
5359 *this = A-M;
5360 return *this;
5361 }
5362
5365 *this = A-M;
5366 return *this;
5367 }
5368
5371 *this = A-M;
5372 return *this;
5373 }
5374
5377 *this = A-M;
5378 return *this;
5379 }
5380
5383 *this = A-M;
5384 return *this;
5385 }
5386
5389 *this = A-M;
5390 return *this;
5391 }
5392
5395 *this = A-M;
5396 return *this;
5397 }
5398
5401 *this = A-M;
5402 return *this;
5403 }
5404
5407 *this = A-M;
5408 return *this;
5409 }
5410
5413 *this = A-M;
5414 return *this;
5415 }
5416
5419 *this = A-M;
5420 return *this;
5421 }
5422
5425 *this = A|M.A;
5426 return *this;
5427 }
5428
5431 *this = A|M.A;
5432 return *this;
5433 }
5434
5437 *this = A|M.A;
5438 return *this;
5439 }
5440
5443 *this = A|M.A;
5444 return *this;
5445 }
5446
5449 *this = A|M;
5450 return *this;
5451 }
5452
5455 *this = A|M;
5456 return *this;
5457 }
5458
5461 *this = A|M;
5462 return *this;
5463 }
5464
5467 *this = A|M;
5468 return *this;
5469 }
5470
5473 *this = A|M;
5474 return *this;
5475 }
5476
5479 *this = A|M;
5480 return *this;
5481 }
5482
5485 *this = A|M;
5486 return *this;
5487 }
5488
5491 *this = A|M;
5492 return *this;
5493 }
5494
5497 *this = A|M;
5498 return *this;
5499 }
5500
5503 *this = A|M;
5504 return *this;
5505 }
5506
5509 *this = A|M;
5510 return *this;
5511 }
5512
5515 *this = A|M;
5516 return *this;
5517 }
5518
5520
5524 const cinterval operator()(const int i, const int j) const {
5525#if(CXSC_INDEX_CHECK)
5526 if(i<A.lb1 || i>A.ub1 || j<A.lb2 || j>A.ub2)
5527 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_slice::operator()(int, int)"));
5528#endif
5529 cinterval r = A(i,j);
5530 return r;
5531 }
5532
5534
5538 cinterval& element(const int i, const int j) {
5539#if(CXSC_INDEX_CHECK)
5540 if(i<A.lb1 || i>A.ub1 || j<A.lb2 || j>A.ub2)
5541 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_slice::element(int, int)"));
5542#endif
5543 return M->element(i,j);
5544 }
5545
5547 scimatrix_subv operator[](const int);
5549 scimatrix_subv operator[](const cxscmatrix_column&);
5551 const scimatrix_subv operator[](const int) const;
5553 const scimatrix_subv operator[](const cxscmatrix_column&) const;
5554
5555 friend std::ostream& operator<<(std::ostream&, const scimatrix_slice&);
5556
5557 friend int Lb(const scimatrix_slice&, const int);
5558 friend int Ub(const scimatrix_slice&, const int);
5559 friend simatrix Re(const scimatrix_slice&);
5560 friend simatrix Im(const scimatrix_slice&);
5561 friend scmatrix Inf(const scimatrix_slice&);
5562 friend scmatrix Sup(const scimatrix_slice&);
5563 friend srmatrix InfRe(const scimatrix_slice&);
5564 friend srmatrix InfIm(const scimatrix_slice&);
5565 friend srmatrix SupRe(const scimatrix_slice&);
5566 friend srmatrix SupIm(const scimatrix_slice&);
5567 friend int RowLen(const scimatrix_slice&);
5568 friend int ColLen(const scimatrix_slice&);
5569
5570 friend class srmatrix;
5571 friend class srmatrix_subv;
5572 friend class srvector;
5573 friend class scmatrix;
5574 friend class scmatrix_subv;
5575 friend class scvector;
5576 friend class simatrix;
5577 friend class simatrix_subv;
5578 friend class sivector;
5579 friend class scimatrix;
5580 friend class scimatrix_subv;
5581 friend class scivector;
5582
5583#include "matrix_friend_declarations.inl"
5584};
5585
5587 dat = new cinterval[A.A.m*A.A.n];
5588 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5589 xsize = A.A.n;
5590 ysize = A.A.m;
5591 *this = 0.0;
5592 for(int j=0 ; j<A.A.n ; j++) {
5593 for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5594 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5595 }
5596 }
5597}
5598
5600 dat = new cinterval[A.A.m*A.A.n];
5601 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5602 xsize = A.A.n;
5603 ysize = A.A.m;
5604 *this = 0.0;
5605 for(int j=0 ; j<A.A.n ; j++) {
5606 for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5607 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5608 }
5609 }
5610}
5611
5613 dat = new cinterval[A.A.m*A.A.n];
5614 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5615 xsize = A.A.n;
5616 ysize = A.A.m;
5617 *this = 0.0;
5618 for(int j=0 ; j<A.A.n ; j++) {
5619 for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5620 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5621 }
5622 }
5623}
5624
5626 dat = new cinterval[A.A.m*A.A.n];
5627 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5628 xsize = A.A.n;
5629 ysize = A.A.m;
5630 *this = 0.0;
5631 for(int j=0 ; j<A.A.n ; j++) {
5632 for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5633 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5634 }
5635 }
5636}
5637
5639inline int RowLen(const scimatrix_slice& S) {
5640 return RowLen(S.A);
5641}
5642
5644inline int ColLen(const scimatrix_slice& S) {
5645 return ColLen(S.A);
5646}
5647
5648inline scimatrix_slice scimatrix::operator()(const int i, const int j, const int k, const int l) {
5649#if(CXSC_INDEX_CHECK)
5650 if(i<lb1 || j>ub1 || k<lb2 || l>ub2)
5651 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator()(int, int, int, int)"));
5652#endif
5653 return scimatrix_slice(*this, i, j, k, l);
5654}
5655
5656inline const scimatrix_slice scimatrix::operator()(const int i, const int j, const int k, const int l) const{
5657#if(CXSC_INDEX_CHECK)
5658 if(i<lb1 || j>ub1 || k<lb2 || l>ub2)
5659 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator()(int, int, int, int) const"));
5660#endif
5661 return scimatrix_slice(*this, i, j, k, l);
5662}
5663
5665 *this = S.A;
5666 return *this;
5667}
5668
5670 *this = S.A;
5671 return *this;
5672}
5673
5675 *this = S.A;
5676 return *this;
5677}
5678
5680 *this = S.A;
5681 return *this;
5682}
5683
5685inline int Lb(const scimatrix_slice& S, const int i) {
5686 return Lb(S.A, i);
5687}
5688
5690inline int Ub(const scimatrix_slice& S, const int i) {
5691 return Ub(S.A, i);
5692}
5693
5695inline simatrix Re(const scimatrix_slice& S) {
5696 return Re(S.A);
5697}
5698
5700inline simatrix Im(const scimatrix_slice& S) {
5701 return Im(S.A);
5702}
5703
5705inline scimatrix conj(const scimatrix_slice& S) {
5706 return conj(S.A);
5707}
5708
5710inline simatrix abs(const scimatrix_slice& S) {
5711 return abs(S.A);
5712}
5713
5715inline scmatrix mid(const scimatrix_slice& S) {
5716 return mid(S.A);
5717}
5718
5721 return diam(S.A);
5722}
5723
5725inline scmatrix Inf(const scimatrix_slice& S) {
5726 return Inf(S.A);
5727}
5728
5730inline scmatrix Sup(const scimatrix_slice& S) {
5731 return Sup(S.A);
5732}
5733
5735inline srmatrix InfRe(const scimatrix_slice& S) {
5736 return InfRe(S.A);
5737}
5738
5740inline srmatrix InfIm(const scimatrix_slice& S) {
5741 return InfIm(S.A);
5742}
5743
5745inline srmatrix SupRe(const scimatrix_slice& S) {
5746 return SupRe(S.A);
5747}
5748
5750inline srmatrix SupIm(const scimatrix_slice& S) {
5751 return SupIm(S.A);
5752}
5753
5755 m = S.A.m;
5756 n = S.A.n;
5757 lb1 = S.A.lb1;
5758 ub1 = S.A.ub1;
5759 lb2 = S.A.lb2;
5760 ub2 = S.A.ub2;
5761 *this = S.A;
5762}
5763
5765 m = S.A.m;
5766 n = S.A.n;
5767 lb1 = S.A.lb1;
5768 ub1 = S.A.ub1;
5769 lb2 = S.A.lb2;
5770 ub2 = S.A.ub2;
5771 *this = S.A;
5772}
5773
5775 m = S.A.m;
5776 n = S.A.n;
5777 lb1 = S.A.lb1;
5778 ub1 = S.A.ub1;
5779 lb2 = S.A.lb2;
5780 ub2 = S.A.ub2;
5781 *this = S.A;
5782}
5783
5785 m = S.A.m;
5786 n = S.A.n;
5787 lb1 = S.A.lb1;
5788 ub1 = S.A.ub1;
5789 lb2 = S.A.lb2;
5790 ub2 = S.A.ub2;
5791 *this = S.A;
5792}
5793
5795inline scimatrix operator-(const scimatrix_slice& M) {
5796 return sp_m_negative<scimatrix,scimatrix>(M.A);
5797}
5798
5800inline scimatrix operator+(const scimatrix_slice& M) {
5801 return M.A;
5802}
5803
5805
5812 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5813}
5814
5816
5823 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5824}
5825
5827
5834 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5835}
5836
5838
5845 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5846}
5847
5849
5856 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5857}
5858
5860
5867 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5868}
5869
5871
5878 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5879}
5880
5882
5888inline scimatrix operator*(const simatrix_slice& M1, const scmatrix_slice& M2) {
5889 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5890}
5891
5893
5899inline scimatrix operator*(const scmatrix_slice& M1, const simatrix_slice& M2) {
5900 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5901}
5902
5904
5910inline scimatrix operator*(const scimatrix_slice& M1, const srmatrix& M2) {
5911 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5912}
5913
5915
5921inline scimatrix operator*(const scimatrix_slice& M1, const scmatrix& M2) {
5922 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5923}
5924
5926
5932inline scimatrix operator*(const scimatrix_slice& M1, const simatrix& M2) {
5933 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5934}
5935
5937
5943inline scimatrix operator*(const scimatrix_slice& M1, const scimatrix& M2) {
5944 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5945}
5946
5948
5954inline scimatrix operator*(const srmatrix_slice& M1, const scimatrix& M2) {
5955 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5956}
5957
5959
5965inline scimatrix operator*(const simatrix_slice& M1, const scimatrix& M2) {
5966 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5967}
5968
5970
5976inline scimatrix operator*(const scmatrix_slice& M1, const scimatrix& M2) {
5977 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5978}
5979
5981
5987inline scimatrix operator*(const simatrix_slice& M1, const scmatrix& M2) {
5988 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5989}
5990
5992
5998inline scimatrix operator*(const scmatrix_slice& M1, const simatrix& M2) {
5999 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
6000}
6001
6003
6009inline scimatrix operator*(const scimatrix& M1, const srmatrix_slice& M2) {
6010 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6011}
6012
6014
6020inline scimatrix operator*(const scimatrix& M1, const scmatrix_slice& M2) {
6021 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6022}
6023
6025
6031inline scimatrix operator*(const scimatrix& M1, const simatrix_slice& M2) {
6032 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6033}
6034
6036
6042inline scimatrix operator*(const scimatrix& M1, const scimatrix_slice& M2) {
6043 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6044}
6045
6047
6053inline scimatrix operator*(const srmatrix& M1, const scimatrix_slice& M2) {
6054 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6055}
6056
6058
6064inline scimatrix operator*(const scmatrix& M1, const scimatrix_slice& M2) {
6065 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6066}
6067
6069
6075inline scimatrix operator*(const simatrix& M1, const scimatrix_slice& M2) {
6076 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6077}
6078
6080
6086inline scimatrix operator*(const simatrix& M1, const scmatrix_slice& M2) {
6087 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6088}
6089
6091
6097inline scimatrix operator*(const scmatrix& M1, const simatrix_slice& M2) {
6098 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6099}
6100
6102
6108inline cimatrix operator*(const scimatrix_slice& M1, const rmatrix& M2) {
6109 return spf_mm_mult<scimatrix,rmatrix,cimatrix,sparse_cidot>(M1.A,M2);
6110}
6111
6113
6119inline cimatrix operator*(const scimatrix_slice& M1, const imatrix& M2) {
6120 return spf_mm_mult<scimatrix,imatrix,cimatrix,sparse_cidot>(M1.A,M2);
6121}
6122
6124
6130inline cimatrix operator*(const scimatrix_slice& M1, const cmatrix& M2) {
6131 return spf_mm_mult<scimatrix,cmatrix,cimatrix,sparse_cidot>(M1.A,M2);
6132}
6133
6135
6141inline cimatrix operator*(const scimatrix_slice& M1, const cimatrix& M2) {
6142 return spf_mm_mult<scimatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6143}
6144
6146
6152inline cimatrix operator*(const srmatrix_slice& M1, const cimatrix& M2) {
6153 return spf_mm_mult<srmatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6154}
6155
6157
6163inline cimatrix operator*(const simatrix_slice& M1, const cimatrix& M2) {
6164 return spf_mm_mult<simatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6165}
6166
6168
6174inline cimatrix operator*(const scmatrix_slice& M1, const cimatrix& M2) {
6175 return spf_mm_mult<scmatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6176}
6177
6179
6185inline cimatrix operator*(const simatrix_slice& M1, const cmatrix& M2) {
6186 return spf_mm_mult<simatrix,cmatrix,cimatrix,sparse_cidot>(M1.A,M2);
6187}
6188
6190
6196inline cimatrix operator*(const scmatrix_slice& M1, const imatrix& M2) {
6197 return spf_mm_mult<scmatrix,imatrix,cimatrix,sparse_cidot>(M1.A,M2);
6198}
6199
6201
6207inline cimatrix operator*(const cimatrix& M1, const srmatrix_slice& M2) {
6208 return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6209}
6210
6212
6218inline cimatrix operator*(const cimatrix& M1, const scmatrix_slice& M2) {
6219 return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6220}
6221
6223
6229inline cimatrix operator*(const cimatrix& M1, const simatrix_slice& M2) {
6230 return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6231}
6232
6234
6240inline cimatrix operator*(const cimatrix& M1, const scimatrix_slice& M2) {
6241 return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6242}
6243
6245
6251inline cimatrix operator*(const rmatrix& M1, const scimatrix_slice& M2) {
6252 return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6253}
6254
6256
6262inline cimatrix operator*(const cmatrix& M1, const scimatrix_slice& M2) {
6263 return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6264}
6265
6267
6273inline cimatrix operator*(const imatrix& M1, const scimatrix_slice& M2) {
6274 return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6275}
6276
6278
6284inline cimatrix operator*(const imatrix& M1, const scmatrix_slice& M2) {
6285 return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6286}
6287
6289
6295inline cimatrix operator*(const cmatrix& M1, const simatrix_slice& M2) {
6296 return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6297}
6298
6300
6306inline cimatrix operator*(const scimatrix_slice& M1, const rmatrix_slice& M2) {
6307 return spf_mm_mult<scimatrix,rmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6308}
6309
6311
6317inline cimatrix operator*(const scimatrix_slice& M1, const cmatrix_slice& M2) {
6318 return spf_mm_mult<scimatrix,cmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6319}
6320
6322
6328inline cimatrix operator*(const scimatrix_slice& M1, const imatrix_slice& M2) {
6329 return spf_mm_mult<scimatrix,imatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6330}
6331
6333
6339inline cimatrix operator*(const scimatrix_slice& M1, const cimatrix_slice& M2) {
6340 return spf_mm_mult<scimatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6341}
6342
6344
6350inline cimatrix operator*(const srmatrix_slice& M1, const cimatrix_slice& M2) {
6351 return spf_mm_mult<srmatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6352}
6353
6355
6361inline cimatrix operator*(const simatrix_slice& M1, const cimatrix_slice& M2) {
6362 return spf_mm_mult<simatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6363}
6364
6366
6372inline cimatrix operator*(const scmatrix_slice& M1, const cimatrix_slice& M2) {
6373 return spf_mm_mult<scmatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6374}
6375
6377
6383inline cimatrix operator*(const simatrix_slice& M1, const cmatrix_slice& M2) {
6384 return spf_mm_mult<simatrix,cmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6385}
6386
6388
6394inline cimatrix operator*(const scmatrix_slice& M1, const imatrix_slice& M2) {
6395 return spf_mm_mult<scmatrix,imatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6396}
6397
6399
6405inline cimatrix operator*(const cimatrix_slice& M1, const srmatrix_slice& M2) {
6406 return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6407}
6408
6410
6416inline cimatrix operator*(const cimatrix_slice& M1, const scmatrix_slice& M2) {
6417 return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6418}
6419
6421
6427inline cimatrix operator*(const cimatrix_slice& M1, const simatrix_slice& M2) {
6428 return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6429}
6430
6432
6438inline cimatrix operator*(const cimatrix_slice& M1, const scimatrix_slice& M2) {
6439 return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6440}
6441
6443
6449inline cimatrix operator*(const rmatrix_slice& M1, const scimatrix_slice& M2) {
6450 return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6451}
6452
6454
6460inline cimatrix operator*(const imatrix_slice& M1, const scimatrix_slice& M2) {
6461 return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6462}
6463
6465
6471inline cimatrix operator*(const cmatrix_slice& M1, const scimatrix_slice& M2) {
6472 return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6473}
6474
6476
6482inline cimatrix operator*(const imatrix_slice& M1, const scmatrix_slice& M2) {
6483 return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6484}
6485
6487
6493inline cimatrix operator*(const cmatrix_slice& M1, const simatrix_slice& M2) {
6494 return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6495}
6496
6498
6504inline scivector operator*(const scimatrix_slice& M, const srvector& v) {
6505 return spsp_mv_mult<scimatrix,srvector,scivector,sparse_cidot,cinterval>(M.A,v);
6506}
6507
6509
6515inline scivector operator*(const scimatrix_slice& M, const sivector& v) {
6516 return spsp_mv_mult<scimatrix,sivector,scivector,sparse_cidot,cinterval>(M.A,v);
6517}
6518
6520
6526inline scivector operator*(const scimatrix_slice& M, const scvector& v) {
6527 return spsp_mv_mult<scimatrix,scvector,scivector,sparse_cidot,cinterval>(M.A,v);
6528}
6529
6531
6537inline scivector operator*(const scimatrix_slice& M, const scivector& v) {
6538 return spsp_mv_mult<scimatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6539}
6540
6542
6548inline scivector operator*(const srmatrix_slice& M, const scivector& v) {
6549 return spsp_mv_mult<srmatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6550}
6551
6553
6559inline scivector operator*(const simatrix_slice& M, const scivector& v) {
6560 return spsp_mv_mult<simatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6561}
6562
6564
6570inline scivector operator*(const scmatrix_slice& M, const scivector& v) {
6571 return spsp_mv_mult<scmatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6572}
6573
6575
6581inline scivector operator*(const simatrix_slice& M, const scvector& v) {
6582 return spsp_mv_mult<simatrix,scvector,scivector,sparse_cidot,cinterval>(M.A,v);
6583}
6584
6586
6592inline scivector operator*(const scmatrix_slice& M, const sivector& v) {
6593 return spsp_mv_mult<scmatrix,sivector,scivector,sparse_cidot,cinterval>(M.A,v);
6594}
6595
6597
6604 return spsl_mv_mult<scimatrix,srvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6605}
6606
6608
6615 return spsl_mv_mult<scimatrix,sivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6616}
6617
6619
6626 return spsl_mv_mult<scimatrix,scvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6627}
6628
6630
6637 return spsl_mv_mult<scimatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6638}
6639
6641
6648 return spsl_mv_mult<srmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6649}
6650
6652
6659 return spsl_mv_mult<scmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6660}
6661
6663
6670 return spsl_mv_mult<simatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6671}
6672
6674
6681 return spsl_mv_mult<simatrix,scvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6682}
6683
6685
6692 return spsl_mv_mult<scmatrix,sivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6693}
6694
6696
6702inline civector operator*(const scimatrix_slice& M, const rvector& v) {
6703 return spf_mv_mult<scimatrix,rvector,civector,sparse_cidot>(M.A,v);
6704}
6705
6707
6713inline civector operator*(const scimatrix_slice& M, const ivector& v) {
6714 return spf_mv_mult<scimatrix,ivector,civector,sparse_cidot>(M.A,v);
6715}
6716
6718
6724inline civector operator*(const scimatrix_slice& M, const cvector& v) {
6725 return spf_mv_mult<scimatrix,cvector,civector,sparse_cidot>(M.A,v);
6726}
6727
6729
6735inline civector operator*(const scimatrix_slice& M, const civector& v) {
6736 return spf_mv_mult<scimatrix,civector,civector,sparse_cidot>(M.A,v);
6737}
6738
6740
6746inline civector operator*(const srmatrix_slice& M, const civector& v) {
6747 return spf_mv_mult<srmatrix,civector,civector,sparse_cidot>(M.A,v);
6748}
6749
6751
6757inline civector operator*(const simatrix_slice& M, const civector& v) {
6758 return spf_mv_mult<simatrix,civector,civector,sparse_cidot>(M.A,v);
6759}
6760
6762
6768inline civector operator*(const scmatrix_slice& M, const civector& v) {
6769 return spf_mv_mult<scmatrix,civector,civector,sparse_cidot>(M.A,v);
6770}
6771
6773
6779inline civector operator*(const simatrix_slice& M, const cvector& v) {
6780 return spf_mv_mult<simatrix,cvector,civector,sparse_cidot>(M.A,v);
6781}
6782
6784
6790inline civector operator*(const scmatrix_slice& M, const ivector& v) {
6791 return spf_mv_mult<scmatrix,ivector,civector,sparse_cidot>(M.A,v);
6792}
6793
6795
6802 return spf_mv_mult<scimatrix,rvector_slice,civector,sparse_cidot>(M.A,v);
6803}
6804
6806
6813 return spf_mv_mult<scimatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
6814}
6815
6817
6824 return spf_mv_mult<scimatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
6825}
6826
6828
6835 return spf_mv_mult<scimatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6836}
6837
6839
6846 return spf_mv_mult<srmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6847}
6848
6850
6857 return spf_mv_mult<scmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6858}
6859
6861
6868 return spf_mv_mult<simatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6869}
6870
6872
6879 return spf_mv_mult<simatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
6880}
6881
6883
6890 return spf_mv_mult<scmatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
6891}
6892
6894inline scimatrix operator/(const scimatrix_slice& M, const real& r) {
6895 return sp_ms_div<scimatrix,real,scimatrix>(M.A,r);
6896}
6897
6899inline scimatrix operator/(const scimatrix_slice& M, const complex& r) {
6900 return sp_ms_div<scimatrix,complex,scimatrix>(M.A,r);
6901}
6902
6904inline scimatrix operator/(const scimatrix_slice& M, const interval& r) {
6905 return sp_ms_div<scimatrix,interval,scimatrix>(M.A,r);
6906}
6907
6909inline scimatrix operator/(const scimatrix_slice& M, const cinterval& r) {
6910 return sp_ms_div<scimatrix,cinterval,scimatrix>(M.A,r);
6911}
6912
6914inline scimatrix operator/(const srmatrix_slice& M, const cinterval& r) {
6915 return sp_ms_div<srmatrix,cinterval,scimatrix>(M.A,r);
6916}
6917
6919inline scimatrix operator/(const simatrix_slice& M, const cinterval& r) {
6920 return sp_ms_div<simatrix,cinterval,scimatrix>(M.A,r);
6921}
6922
6924inline scimatrix operator/(const scmatrix_slice& M, const cinterval& r) {
6925 return sp_ms_div<scmatrix,cinterval,scimatrix>(M.A,r);
6926}
6927
6929inline scimatrix operator/(const simatrix_slice& M, const complex& r) {
6930 return sp_ms_div<simatrix,complex,scimatrix>(M.A,r);
6931}
6932
6934inline scimatrix operator/(const scmatrix_slice& M, const interval& r) {
6935 return sp_ms_div<scmatrix,interval,scimatrix>(M.A,r);
6936}
6937
6939inline scimatrix operator*(const scimatrix_slice& M, const real& r) {
6940 return sp_ms_mult<scimatrix,real,scimatrix>(M.A,r);
6941}
6942
6944inline scimatrix operator*(const scimatrix_slice& M, const complex& r) {
6945 return sp_ms_mult<scimatrix,complex,scimatrix>(M.A,r);
6946}
6947
6949inline scimatrix operator*(const scimatrix_slice& M, const interval& r) {
6950 return sp_ms_mult<scimatrix,interval,scimatrix>(M.A,r);
6951}
6952
6954inline scimatrix operator*(const scimatrix_slice& M, const cinterval& r) {
6955 return sp_ms_mult<scimatrix,cinterval,scimatrix>(M.A,r);
6956}
6957
6959inline scimatrix operator*(const srmatrix_slice& M, const cinterval& r) {
6960 return sp_ms_mult<srmatrix,cinterval,scimatrix>(M.A,r);
6961}
6962
6964inline scimatrix operator*(const simatrix_slice& M, const cinterval& r) {
6965 return sp_ms_mult<simatrix,cinterval,scimatrix>(M.A,r);
6966}
6967
6969inline scimatrix operator*(const scmatrix_slice& M, const cinterval& r) {
6970 return sp_ms_mult<scmatrix,cinterval,scimatrix>(M.A,r);
6971}
6972
6974inline scimatrix operator*(const simatrix_slice& M, const complex& r) {
6975 return sp_ms_mult<simatrix,complex,scimatrix>(M.A,r);
6976}
6977
6979inline scimatrix operator*(const scmatrix_slice& M, const interval& r) {
6980 return sp_ms_mult<scmatrix,interval,scimatrix>(M.A,r);
6981}
6982
6984inline scimatrix operator*(const real& r, const scimatrix_slice& M) {
6985 return sp_sm_mult<real,scimatrix,scimatrix>(r,M.A);
6986}
6987
6989inline scimatrix operator*(const complex& r, const scimatrix_slice& M) {
6990 return sp_sm_mult<complex,scimatrix,scimatrix>(r,M.A);
6991}
6992
6994inline scimatrix operator*(const interval& r, const scimatrix_slice& M) {
6995 return sp_sm_mult<interval,scimatrix,scimatrix>(r,M.A);
6996}
6997
6999inline scimatrix operator*(const cinterval& r, const scimatrix_slice& M) {
7000 return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,M.A);
7001}
7002
7004inline scimatrix operator*(const cinterval& r, const srmatrix_slice& M) {
7005 return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,M.A);
7006}
7007
7009inline scimatrix operator*(const cinterval& r, const simatrix_slice& M) {
7010 return sp_sm_mult<cinterval,simatrix,scimatrix>(r,M.A);
7011}
7012
7014inline scimatrix operator*(const cinterval& r, const scmatrix_slice& M) {
7015 return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,M.A);
7016}
7017
7019inline scimatrix operator*(const complex& r, const simatrix_slice& M) {
7020 return sp_sm_mult<complex,simatrix,scimatrix>(r,M.A);
7021}
7022
7024inline scimatrix operator*(const interval& r, const scmatrix_slice& M) {
7025 return sp_sm_mult<interval,scmatrix,scimatrix>(r,M.A);
7026}
7027
7029inline scimatrix operator+(const scimatrix_slice& M1, const srmatrix_slice& M2) {
7030 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7031}
7032
7034inline scimatrix operator+(const scimatrix_slice& M1, const scmatrix_slice& M2) {
7035 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7036}
7037
7039inline scimatrix operator+(const scimatrix_slice& M1, const simatrix_slice& M2) {
7040 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7041}
7042
7044inline scimatrix operator+(const scimatrix_slice& M1, const scimatrix_slice& M2) {
7045 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7046}
7047
7049inline scimatrix operator+(const srmatrix_slice& M1, const scimatrix_slice& M2) {
7050 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7051}
7052
7054inline scimatrix operator+(const scmatrix_slice& M1, const scimatrix_slice& M2) {
7055 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7056}
7057
7059inline scimatrix operator+(const simatrix_slice& M1, const scimatrix_slice& M2) {
7060 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7061}
7062
7064inline scimatrix operator+(const scmatrix_slice& M1, const simatrix_slice& M2) {
7065 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7066}
7067
7069inline scimatrix operator+(const simatrix_slice& M1, const scmatrix_slice& M2) {
7070 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7071}
7072
7074inline scimatrix operator+(const scimatrix_slice& M1, const srmatrix& M2) {
7075 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7076}
7077
7079inline scimatrix operator+(const scimatrix_slice& M1, const scmatrix& M2) {
7080 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7081}
7082
7084inline scimatrix operator+(const scimatrix_slice& M1, const simatrix& M2) {
7085 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7086}
7087
7089inline scimatrix operator+(const scimatrix_slice& M1, const scimatrix& M2) {
7090 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7091}
7092
7094inline scimatrix operator+(const srmatrix_slice& M1, const scimatrix& M2) {
7095 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7096}
7097
7099inline scimatrix operator+(const simatrix_slice& M1, const scimatrix& M2) {
7100 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7101}
7102
7104inline scimatrix operator+(const scmatrix_slice& M1, const scimatrix& M2) {
7105 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7106}
7107
7109inline scimatrix operator+(const simatrix_slice& M1, const scmatrix& M2) {
7110 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7111}
7112
7114inline scimatrix operator+(const scmatrix_slice& M1, const simatrix& M2) {
7115 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7116}
7117
7119inline scimatrix operator+(const scimatrix& M1, const srmatrix_slice& M2) {
7120 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7121}
7122
7124inline scimatrix operator+(const scimatrix& M1, const scmatrix_slice& M2) {
7125 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7126}
7127
7129inline scimatrix operator+(const scimatrix& M1, const simatrix_slice& M2) {
7130 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7131}
7132
7134inline scimatrix operator+(const scimatrix& M1, const scimatrix_slice& M2) {
7135 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7136}
7137
7139inline scimatrix operator+(const srmatrix& M1, const scimatrix_slice& M2) {
7140 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7141}
7142
7144inline scimatrix operator+(const simatrix& M1, const scimatrix_slice& M2) {
7145 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7146}
7147
7149inline scimatrix operator+(const scmatrix& M1, const scimatrix_slice& M2) {
7150 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7151}
7152
7154inline scimatrix operator+(const simatrix& M1, const scmatrix_slice& M2) {
7155 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7156}
7157
7159inline scimatrix operator+(const scmatrix& M1, const simatrix_slice& M2) {
7160 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7161}
7162
7164inline cimatrix operator+(const scimatrix_slice& M1, const rmatrix& M2) {
7165 return spf_mm_add<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7166}
7167
7169inline cimatrix operator+(const scimatrix_slice& M1, const imatrix& M2) {
7170 return spf_mm_add<scimatrix,imatrix,cimatrix>(M1.A,M2);
7171}
7172
7174inline cimatrix operator+(const scimatrix_slice& M1, const cmatrix& M2) {
7175 return spf_mm_add<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7176}
7177
7179inline cimatrix operator+(const scimatrix_slice& M1, const cimatrix& M2) {
7180 return spf_mm_add<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7181}
7182
7184inline cimatrix operator+(const srmatrix_slice& M1, const cimatrix& M2) {
7185 return spf_mm_add<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7186}
7187
7189inline cimatrix operator+(const simatrix_slice& M1, const cimatrix& M2) {
7190 return spf_mm_add<simatrix,cimatrix,cimatrix>(M1.A,M2);
7191}
7192
7194inline cimatrix operator+(const scmatrix_slice& M1, const cimatrix& M2) {
7195 return spf_mm_add<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7196}
7197
7199inline cimatrix operator+(const simatrix_slice& M1, const cmatrix& M2) {
7200 return spf_mm_add<simatrix,cmatrix,cimatrix>(M1.A,M2);
7201}
7202
7204inline cimatrix operator+(const scmatrix_slice& M1, const imatrix& M2) {
7205 return spf_mm_add<scmatrix,imatrix,cimatrix>(M1.A,M2);
7206}
7207
7209inline cimatrix operator+(const cimatrix& M1, const srmatrix_slice& M2) {
7210 return fsp_mm_add<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7211}
7212
7214inline cimatrix operator+(const cimatrix& M1, const simatrix_slice& M2) {
7215 return fsp_mm_add<cimatrix,simatrix,cimatrix>(M1,M2.A);
7216}
7217
7219inline cimatrix operator+(const cimatrix& M1, const scmatrix_slice& M2) {
7220 return fsp_mm_add<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7221}
7222
7224inline cimatrix operator+(const cimatrix& M1, const scimatrix_slice& M2) {
7225 return fsp_mm_add<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7226}
7227
7229inline cimatrix operator+(const rmatrix& M1, const scimatrix_slice& M2) {
7230 return fsp_mm_add<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7231}
7232
7234inline cimatrix operator+(const imatrix& M1, const scimatrix_slice& M2) {
7235 return fsp_mm_add<imatrix,scimatrix,cimatrix>(M1,M2.A);
7236}
7237
7239inline cimatrix operator+(const cmatrix& M1, const scimatrix_slice& M2) {
7240 return fsp_mm_add<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7241}
7242
7244inline cimatrix operator+(const imatrix& M1, const scmatrix_slice& M2) {
7245 return fsp_mm_add<imatrix,scmatrix,cimatrix>(M1,M2.A);
7246}
7247
7249inline cimatrix operator+(const cmatrix& M1, const simatrix_slice& M2) {
7250 return fsp_mm_add<cmatrix,simatrix,cimatrix>(M1,M2.A);
7251}
7252
7254inline cimatrix operator+(const scimatrix_slice& M1, const rmatrix_slice& M2) {
7255 return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7256}
7257
7259inline cimatrix operator+(const scimatrix_slice& M1, const cmatrix_slice& M2) {
7260 return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7261}
7262
7264inline cimatrix operator+(const scimatrix_slice& M1, const imatrix_slice& M2) {
7265 return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7266}
7267
7269inline cimatrix operator+(const scimatrix_slice& M1, const cimatrix_slice& M2) {
7270 return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7271}
7272
7274inline cimatrix operator+(const srmatrix_slice& M1, const cimatrix_slice& M2) {
7275 return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7276}
7277
7279inline cimatrix operator+(const simatrix_slice& M1, const cimatrix_slice& M2) {
7280 return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7281}
7282
7284inline cimatrix operator+(const scmatrix_slice& M1, const cimatrix_slice& M2) {
7285 return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7286}
7287
7289inline cimatrix operator+(const simatrix_slice& M1, const cmatrix_slice& M2) {
7290 return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7291}
7292
7294inline cimatrix operator+(const scmatrix_slice& M1, const imatrix_slice& M2) {
7295 return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7296}
7297
7299inline cimatrix operator+(const cimatrix_slice& M1, const srmatrix_slice& M2) {
7300 return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7301}
7302
7304inline cimatrix operator+(const cimatrix_slice& M1, const simatrix_slice& M2) {
7305 return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7306}
7307
7309inline cimatrix operator+(const cimatrix_slice& M1, const scmatrix_slice& M2) {
7310 return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7311}
7312
7314inline cimatrix operator+(const cimatrix_slice& M1, const scimatrix_slice& M2) {
7315 return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7316}
7317
7319inline cimatrix operator+(const rmatrix_slice& M1, const scimatrix_slice& M2) {
7320 return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7321}
7322
7324inline cimatrix operator+(const imatrix_slice& M1, const scimatrix_slice& M2) {
7325 return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7326}
7327
7329inline cimatrix operator+(const cmatrix_slice& M1, const scimatrix_slice& M2) {
7330 return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7331}
7332
7334inline cimatrix operator+(const imatrix_slice& M1, const scmatrix_slice& M2) {
7335 return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7336}
7337
7339inline cimatrix operator+(const cmatrix_slice& M1, const simatrix_slice& M2) {
7340 return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7341}
7342
7344inline scimatrix operator-(const scimatrix_slice& M1, const srmatrix_slice& M2) {
7345 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7346}
7347
7349inline scimatrix operator-(const scimatrix_slice& M1, const scmatrix_slice& M2) {
7350 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7351}
7352
7354inline scimatrix operator-(const scimatrix_slice& M1, const simatrix_slice& M2) {
7355 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7356}
7357
7359inline scimatrix operator-(const scimatrix_slice& M1, const scimatrix_slice& M2) {
7360 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7361}
7362
7364inline scimatrix operator-(const srmatrix_slice& M1, const scimatrix_slice& M2) {
7365 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7366}
7367
7369inline scimatrix operator-(const scmatrix_slice& M1, const scimatrix_slice& M2) {
7370 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7371}
7372
7374inline scimatrix operator-(const simatrix_slice& M1, const scimatrix_slice& M2) {
7375 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7376}
7377
7379inline scimatrix operator-(const scmatrix_slice& M1, const simatrix_slice& M2) {
7380 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7381}
7382
7384inline scimatrix operator-(const simatrix_slice& M1, const scmatrix_slice& M2) {
7385 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7386}
7387
7389inline scimatrix operator-(const scimatrix_slice& M1, const srmatrix& M2) {
7390 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7391}
7392
7394inline scimatrix operator-(const scimatrix_slice& M1, const scmatrix& M2) {
7395 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7396}
7397
7399inline scimatrix operator-(const scimatrix_slice& M1, const simatrix& M2) {
7400 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7401}
7402
7404inline scimatrix operator-(const scimatrix_slice& M1, const scimatrix& M2) {
7405 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7406}
7407
7409inline scimatrix operator-(const srmatrix_slice& M1, const scimatrix& M2) {
7410 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7411}
7412
7414inline scimatrix operator-(const simatrix_slice& M1, const scimatrix& M2) {
7415 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7416}
7417
7419inline scimatrix operator-(const scmatrix_slice& M1, const scimatrix& M2) {
7420 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7421}
7422
7424inline scimatrix operator-(const simatrix_slice& M1, const scmatrix& M2) {
7425 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7426}
7427
7429inline scimatrix operator-(const scmatrix_slice& M1, const simatrix& M2) {
7430 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7431}
7432
7434inline scimatrix operator-(const scimatrix& M1, const srmatrix_slice& M2) {
7435 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7436}
7437
7439inline scimatrix operator-(const scimatrix& M1, const scmatrix_slice& M2) {
7440 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7441}
7442
7444inline scimatrix operator-(const scimatrix& M1, const simatrix_slice& M2) {
7445 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7446}
7447
7449inline scimatrix operator-(const scimatrix& M1, const scimatrix_slice& M2) {
7450 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7451}
7452
7454inline scimatrix operator-(const srmatrix& M1, const scimatrix_slice& M2) {
7455 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7456}
7457
7459inline scimatrix operator-(const simatrix& M1, const scimatrix_slice& M2) {
7460 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7461}
7462
7464inline scimatrix operator-(const scmatrix& M1, const scimatrix_slice& M2) {
7465 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7466}
7467
7469inline scimatrix operator-(const simatrix& M1, const scmatrix_slice& M2) {
7470 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7471}
7472
7474inline scimatrix operator-(const scmatrix& M1, const simatrix_slice& M2) {
7475 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7476}
7477
7479inline cimatrix operator-(const scimatrix_slice& M1, const rmatrix& M2) {
7480 return spf_mm_sub<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7481}
7482
7484inline cimatrix operator-(const scimatrix_slice& M1, const imatrix& M2) {
7485 return spf_mm_sub<scimatrix,imatrix,cimatrix>(M1.A,M2);
7486}
7487
7489inline cimatrix operator-(const scimatrix_slice& M1, const cmatrix& M2) {
7490 return spf_mm_sub<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7491}
7492
7494inline cimatrix operator-(const scimatrix_slice& M1, const cimatrix& M2) {
7495 return spf_mm_sub<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7496}
7497
7499inline cimatrix operator-(const srmatrix_slice& M1, const cimatrix& M2) {
7500 return spf_mm_sub<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7501}
7502
7504inline cimatrix operator-(const simatrix_slice& M1, const cimatrix& M2) {
7505 return spf_mm_sub<simatrix,cimatrix,cimatrix>(M1.A,M2);
7506}
7507
7509inline cimatrix operator-(const scmatrix_slice& M1, const cimatrix& M2) {
7510 return spf_mm_sub<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7511}
7512
7514inline cimatrix operator-(const simatrix_slice& M1, const cmatrix& M2) {
7515 return spf_mm_sub<simatrix,cmatrix,cimatrix>(M1.A,M2);
7516}
7517
7519inline cimatrix operator-(const scmatrix_slice& M1, const imatrix& M2) {
7520 return spf_mm_sub<scmatrix,imatrix,cimatrix>(M1.A,M2);
7521}
7522
7524inline cimatrix operator-(const cimatrix& M1, const srmatrix_slice& M2) {
7525 return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7526}
7527
7529inline cimatrix operator-(const cimatrix& M1, const simatrix_slice& M2) {
7530 return fsp_mm_sub<cimatrix,simatrix,cimatrix>(M1,M2.A);
7531}
7532
7534inline cimatrix operator-(const cimatrix& M1, const scmatrix_slice& M2) {
7535 return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7536}
7537
7539inline cimatrix operator-(const cimatrix& M1, const scimatrix_slice& M2) {
7540 return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7541}
7542
7544inline cimatrix operator-(const rmatrix& M1, const scimatrix_slice& M2) {
7545 return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7546}
7547
7549inline cimatrix operator-(const imatrix& M1, const scimatrix_slice& M2) {
7550 return fsp_mm_sub<imatrix,scimatrix,cimatrix>(M1,M2.A);
7551}
7552
7554inline cimatrix operator-(const cmatrix& M1, const scimatrix_slice& M2) {
7555 return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7556}
7557
7559inline cimatrix operator-(const imatrix& M1, const scmatrix_slice& M2) {
7560 return fsp_mm_sub<imatrix,scmatrix,cimatrix>(M1,M2.A);
7561}
7562
7564inline cimatrix operator-(const cmatrix& M1, const simatrix_slice& M2) {
7565 return fsp_mm_sub<cmatrix,simatrix,cimatrix>(M1,M2.A);
7566}
7567
7569inline cimatrix operator-(const scimatrix_slice& M1, const rmatrix_slice& M2) {
7570 return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7571}
7572
7574inline cimatrix operator-(const scimatrix_slice& M1, const cmatrix_slice& M2) {
7575 return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7576}
7577
7579inline cimatrix operator-(const scimatrix_slice& M1, const imatrix_slice& M2) {
7580 return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7581}
7582
7584inline cimatrix operator-(const scimatrix_slice& M1, const cimatrix_slice& M2) {
7585 return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7586}
7587
7589inline cimatrix operator-(const srmatrix_slice& M1, const cimatrix_slice& M2) {
7590 return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7591}
7592
7594inline cimatrix operator-(const simatrix_slice& M1, const cimatrix_slice& M2) {
7595 return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7596}
7597
7599inline cimatrix operator-(const scmatrix_slice& M1, const cimatrix_slice& M2) {
7600 return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7601}
7602
7604inline cimatrix operator-(const simatrix_slice& M1, const cmatrix_slice& M2) {
7605 return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7606}
7607
7609inline cimatrix operator-(const scmatrix_slice& M1, const imatrix_slice& M2) {
7610 return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7611}
7612
7614inline cimatrix operator-(const cimatrix_slice& M1, const srmatrix_slice& M2) {
7615 return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7616}
7617
7619inline cimatrix operator-(const cimatrix_slice& M1, const simatrix_slice& M2) {
7620 return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7621}
7622
7624inline cimatrix operator-(const cimatrix_slice& M1, const scmatrix_slice& M2) {
7625 return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7626}
7627
7629inline cimatrix operator-(const cimatrix_slice& M1, const scimatrix_slice& M2) {
7630 return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7631}
7632
7634inline cimatrix operator-(const rmatrix_slice& M1, const scimatrix_slice& M2) {
7635 return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7636}
7637
7639inline cimatrix operator-(const imatrix_slice& M1, const scimatrix_slice& M2) {
7640 return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7641}
7642
7644inline cimatrix operator-(const cmatrix_slice& M1, const scimatrix_slice& M2) {
7645 return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7646}
7647
7649inline cimatrix operator-(const imatrix_slice& M1, const scmatrix_slice& M2) {
7650 return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7651}
7652
7654inline cimatrix operator-(const cmatrix_slice& M1, const simatrix_slice& M2) {
7655 return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7656}
7657
7659inline scimatrix operator|(const scimatrix_slice& M1, const srmatrix_slice& M2) {
7660 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7661}
7662
7664inline scimatrix operator|(const scimatrix_slice& M1, const scmatrix_slice& M2) {
7665 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7666}
7667
7669inline scimatrix operator|(const scimatrix_slice& M1, const simatrix_slice& M2) {
7670 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7671}
7672
7674inline scimatrix operator|(const scimatrix_slice& M1, const scimatrix_slice& M2) {
7675 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7676}
7677
7679inline scimatrix operator|(const srmatrix_slice& M1, const scimatrix_slice& M2) {
7680 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7681}
7682
7684inline scimatrix operator|(const scmatrix_slice& M1, const scimatrix_slice& M2) {
7685 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7686}
7687
7689inline scimatrix operator|(const simatrix_slice& M1, const scimatrix_slice& M2) {
7690 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7691}
7692
7694inline scimatrix operator|(const scmatrix_slice& M1, const simatrix_slice& M2) {
7695 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7696}
7697
7699inline scimatrix operator|(const simatrix_slice& M1, const scmatrix_slice& M2) {
7700 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7701}
7702
7704inline scimatrix operator|(const scimatrix_slice& M1, const srmatrix& M2) {
7705 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7706}
7707
7709inline scimatrix operator|(const scimatrix_slice& M1, const scmatrix& M2) {
7710 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7711}
7712
7714inline scimatrix operator|(const scimatrix_slice& M1, const simatrix& M2) {
7715 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7716}
7717
7719inline scimatrix operator|(const scimatrix_slice& M1, const scimatrix& M2) {
7720 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7721}
7722
7724inline scimatrix operator|(const srmatrix_slice& M1, const scimatrix& M2) {
7725 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7726}
7727
7729inline scimatrix operator|(const simatrix_slice& M1, const scimatrix& M2) {
7730 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7731}
7732
7734inline scimatrix operator|(const scmatrix_slice& M1, const scimatrix& M2) {
7735 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7736}
7737
7739inline scimatrix operator|(const simatrix_slice& M1, const scmatrix& M2) {
7740 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7741}
7742
7744inline scimatrix operator|(const scmatrix_slice& M1, const simatrix& M2) {
7745 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7746}
7747
7749inline scimatrix operator|(const scimatrix& M1, const srmatrix_slice& M2) {
7750 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7751}
7752
7754inline scimatrix operator|(const scimatrix& M1, const scmatrix_slice& M2) {
7755 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7756}
7757
7759inline scimatrix operator|(const scimatrix& M1, const simatrix_slice& M2) {
7760 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7761}
7762
7764inline scimatrix operator|(const scimatrix& M1, const scimatrix_slice& M2) {
7765 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7766}
7767
7769inline scimatrix operator|(const srmatrix& M1, const scimatrix_slice& M2) {
7770 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7771}
7772
7774inline scimatrix operator|(const simatrix& M1, const scimatrix_slice& M2) {
7775 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7776}
7777
7779inline scimatrix operator|(const scmatrix& M1, const scimatrix_slice& M2) {
7780 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7781}
7782
7784inline scimatrix operator|(const simatrix& M1, const scmatrix_slice& M2) {
7785 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7786}
7787
7789inline scimatrix operator|(const scmatrix& M1, const simatrix_slice& M2) {
7790 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7791}
7792
7794inline cimatrix operator|(const scimatrix_slice& M1, const rmatrix& M2) {
7795 return spf_mm_hull<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7796}
7797
7799inline cimatrix operator|(const scimatrix_slice& M1, const imatrix& M2) {
7800 return spf_mm_hull<scimatrix,imatrix,cimatrix>(M1.A,M2);
7801}
7802
7804inline cimatrix operator|(const scimatrix_slice& M1, const cmatrix& M2) {
7805 return spf_mm_hull<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7806}
7807
7809inline cimatrix operator|(const scimatrix_slice& M1, const cimatrix& M2) {
7810 return spf_mm_hull<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7811}
7812
7814inline cimatrix operator|(const srmatrix_slice& M1, const cimatrix& M2) {
7815 return spf_mm_hull<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7816}
7817
7819inline cimatrix operator|(const simatrix_slice& M1, const cimatrix& M2) {
7820 return spf_mm_hull<simatrix,cimatrix,cimatrix>(M1.A,M2);
7821}
7822
7824inline cimatrix operator|(const scmatrix_slice& M1, const cimatrix& M2) {
7825 return spf_mm_hull<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7826}
7827
7829inline cimatrix operator|(const simatrix_slice& M1, const cmatrix& M2) {
7830 return spf_mm_hull<simatrix,cmatrix,cimatrix>(M1.A,M2);
7831}
7832
7834inline cimatrix operator|(const scmatrix_slice& M1, const imatrix& M2) {
7835 return spf_mm_hull<scmatrix,imatrix,cimatrix>(M1.A,M2);
7836}
7837
7839inline cimatrix operator|(const cimatrix& M1, const srmatrix_slice& M2) {
7840 return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7841}
7842
7844inline cimatrix operator|(const cimatrix& M1, const simatrix_slice& M2) {
7845 return fsp_mm_hull<cimatrix,simatrix,cimatrix>(M1,M2.A);
7846}
7847
7849inline cimatrix operator|(const cimatrix& M1, const scmatrix_slice& M2) {
7850 return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7851}
7852
7854inline cimatrix operator|(const cimatrix& M1, const scimatrix_slice& M2) {
7855 return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7856}
7857
7859inline cimatrix operator|(const rmatrix& M1, const scimatrix_slice& M2) {
7860 return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7861}
7862
7864inline cimatrix operator|(const imatrix& M1, const scimatrix_slice& M2) {
7865 return fsp_mm_hull<imatrix,scimatrix,cimatrix>(M1,M2.A);
7866}
7867
7869inline cimatrix operator|(const cmatrix& M1, const scimatrix_slice& M2) {
7870 return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7871}
7872
7874inline cimatrix operator|(const imatrix& M1, const scmatrix_slice& M2) {
7875 return fsp_mm_hull<imatrix,scmatrix,cimatrix>(M1,M2.A);
7876}
7877
7879inline cimatrix operator|(const cmatrix& M1, const simatrix_slice& M2) {
7880 return fsp_mm_hull<cmatrix,simatrix,cimatrix>(M1,M2.A);
7881}
7882
7884inline cimatrix operator|(const scimatrix_slice& M1, const rmatrix_slice& M2) {
7885 return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7886}
7887
7889inline cimatrix operator|(const scimatrix_slice& M1, const cmatrix_slice& M2) {
7890 return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7891}
7892
7894inline cimatrix operator|(const scimatrix_slice& M1, const imatrix_slice& M2) {
7895 return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7896}
7897
7899inline cimatrix operator|(const scimatrix_slice& M1, const cimatrix_slice& M2) {
7900 return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7901}
7902
7904inline cimatrix operator|(const srmatrix_slice& M1, const cimatrix_slice& M2) {
7905 return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7906}
7907
7909inline cimatrix operator|(const simatrix_slice& M1, const cimatrix_slice& M2) {
7910 return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7911}
7912
7914inline cimatrix operator|(const scmatrix_slice& M1, const cimatrix_slice& M2) {
7915 return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7916}
7917
7919inline cimatrix operator|(const simatrix_slice& M1, const cmatrix_slice& M2) {
7920 return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7921}
7922
7924inline cimatrix operator|(const scmatrix_slice& M1, const imatrix_slice& M2) {
7925 return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7926}
7927
7929inline cimatrix operator|(const cimatrix_slice& M1, const srmatrix_slice& M2) {
7930 return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7931}
7932
7934inline cimatrix operator|(const cimatrix_slice& M1, const simatrix_slice& M2) {
7935 return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7936}
7937
7939inline cimatrix operator|(const cimatrix_slice& M1, const scmatrix_slice& M2) {
7940 return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7941}
7942
7944inline cimatrix operator|(const cimatrix_slice& M1, const scimatrix_slice& M2) {
7945 return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7946}
7947
7949inline cimatrix operator|(const rmatrix_slice& M1, const scimatrix_slice& M2) {
7950 return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7951}
7952
7954inline cimatrix operator|(const imatrix_slice& M1, const scimatrix_slice& M2) {
7955 return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7956}
7957
7959inline cimatrix operator|(const cmatrix_slice& M1, const scimatrix_slice& M2) {
7960 return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7961}
7962
7964inline cimatrix operator|(const imatrix_slice& M1, const scmatrix_slice& M2) {
7965 return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7966}
7967
7969inline cimatrix operator|(const cmatrix_slice& M1, const simatrix_slice& M2) {
7970 return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7971}
7972
7974inline scimatrix operator|(const scmatrix_slice& M1, const srmatrix_slice& M2) {
7975 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7976}
7977
7979inline scimatrix operator|(const srmatrix_slice& M1, const scmatrix_slice& M2) {
7980 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7981}
7982
7984inline scimatrix operator|(const scmatrix_slice& M1, const scmatrix_slice& M2) {
7985 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7986}
7987
7989inline scimatrix operator|(const scmatrix_slice& M1, const srmatrix& M2) {
7990 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7991}
7992
7994inline scimatrix operator|(const srmatrix_slice& M1, const scmatrix& M2) {
7995 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7996}
7997
7999inline scimatrix operator|(const scmatrix_slice& M1, const scmatrix& M2) {
8000 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
8001}
8002
8004inline scimatrix operator|(const scmatrix& M1, const srmatrix_slice& M2) {
8005 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
8006}
8007
8009inline scimatrix operator|(const srmatrix& M1, const scmatrix_slice& M2) {
8010 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
8011}
8012
8014inline scimatrix operator|(const scmatrix& M1, const scmatrix_slice& M2) {
8015 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
8016}
8017
8019inline cimatrix operator|(const scmatrix_slice& M1, const rmatrix& M2) {
8020 return spf_mm_hull<scmatrix,rmatrix,cimatrix>(M1.A,M2);
8021}
8022
8024inline cimatrix operator|(const srmatrix_slice& M1, const cmatrix& M2) {
8025 return spf_mm_hull<srmatrix,cmatrix,cimatrix>(M1.A,M2);
8026}
8027
8029inline cimatrix operator|(const scmatrix_slice& M1, const cmatrix& M2) {
8030 return spf_mm_hull<scmatrix,cmatrix,cimatrix>(M1.A,M2);
8031}
8032
8034inline cimatrix operator|(const cmatrix& M1, const srmatrix_slice& M2) {
8035 return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(M1,M2.A);
8036}
8037
8039inline cimatrix operator|(const rmatrix& M1, const scmatrix_slice& M2) {
8040 return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(M1,M2.A);
8041}
8042
8044inline cimatrix operator|(const cmatrix& M1, const scmatrix_slice& M2) {
8045 return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(M1,M2.A);
8046}
8047
8049inline cimatrix operator|(const scmatrix_slice& M1, const rmatrix_slice& M2) {
8050 return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(M1.A,M2);
8051}
8052
8054inline cimatrix operator|(const srmatrix_slice& M1, const cmatrix_slice& M2) {
8055 return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
8056}
8057
8059inline cimatrix operator|(const scmatrix_slice& M1, const cmatrix_slice& M2) {
8060 return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
8061}
8062
8064inline cimatrix operator|(const cmatrix_slice& M1, const srmatrix_slice& M2) {
8065 return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(M1,M2.A);
8066}
8067
8069inline cimatrix operator|(const rmatrix_slice& M1, const scmatrix_slice& M2) {
8070 return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
8071}
8072
8074inline cimatrix operator|(const cmatrix_slice& M1, const scmatrix_slice& M2) {
8075 return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
8076}
8077
8079inline scimatrix operator&(const scimatrix_slice& M1, const simatrix_slice& M2) {
8080 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
8081}
8082
8084inline scimatrix operator&(const scimatrix_slice& M1, const scimatrix_slice& M2) {
8085 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
8086}
8087
8089inline scimatrix operator&(const simatrix_slice& M1, const scimatrix_slice& M2) {
8090 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
8091}
8092
8094inline scimatrix operator&(const scimatrix_slice& M1, const simatrix& M2) {
8095 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
8096}
8097
8099inline scimatrix operator&(const scimatrix_slice& M1, const scimatrix& M2) {
8100 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
8101}
8102
8104inline scimatrix operator&(const simatrix_slice& M1, const scimatrix& M2) {
8105 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
8106}
8107
8109inline scimatrix operator&(const scimatrix& M1, const simatrix_slice& M2) {
8110 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
8111}
8112
8114inline scimatrix operator&(const scimatrix& M1, const scimatrix_slice& M2) {
8115 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
8116}
8117
8119inline scimatrix operator&(const simatrix& M1, const scimatrix_slice& M2) {
8120 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
8121}
8122
8124inline cimatrix operator&(const scimatrix_slice& M1, const imatrix& M2) {
8125 return spf_mm_intersect<scimatrix,imatrix,cimatrix>(M1.A,M2);
8126}
8127
8129inline cimatrix operator&(const scimatrix_slice& M1, const cimatrix& M2) {
8130 return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(M1.A,M2);
8131}
8132
8134inline cimatrix operator&(const simatrix_slice& M1, const cimatrix& M2) {
8135 return spf_mm_intersect<simatrix,cimatrix,cimatrix>(M1.A,M2);
8136}
8137
8139inline cimatrix operator&(const cimatrix& M1, const simatrix_slice& M2) {
8140 return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(M1,M2.A);
8141}
8142
8144inline cimatrix operator&(const cimatrix& M1, const scimatrix_slice& M2) {
8145 return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(M1,M2.A);
8146}
8147
8149inline cimatrix operator&(const imatrix& M1, const scimatrix_slice& M2) {
8150 return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(M1,M2.A);
8151}
8152
8154inline cimatrix operator&(const scimatrix_slice& M1, const imatrix_slice& M2) {
8155 return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
8156}
8157
8159inline cimatrix operator&(const scimatrix_slice& M1, const cimatrix_slice& M2) {
8160 return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
8161}
8162
8164inline cimatrix operator&(const simatrix_slice& M1, const cimatrix_slice& M2) {
8165 return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
8166}
8167
8169inline cimatrix operator&(const cimatrix_slice& M1, const simatrix_slice& M2) {
8170 return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
8171}
8172
8174inline cimatrix operator&(const cimatrix_slice& M1, const scimatrix_slice& M2) {
8175 return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
8176}
8177
8179inline cimatrix operator&(const imatrix_slice& M1, const scimatrix_slice& M2) {
8180 return fsp_mm_intersect<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
8181}
8182
8184 *this = rmatrix(M);
8185 return *this;
8186}
8187
8189 *this = rmatrix(M);
8190 return *this;
8191}
8192
8194 *this = imatrix(M);
8195 return *this;
8196}
8197
8199 *this = imatrix(M);
8200 return *this;
8201}
8202
8204 *this = cmatrix(M);
8205 return *this;
8206}
8207
8209 *this = cmatrix(M);
8210 return *this;
8211}
8212
8214 *this = cimatrix(M);
8215 return *this;
8216}
8217
8219 *this = cimatrix(M);
8220 return *this;
8221}
8222
8224 *this += M.A;
8225 return *this;
8226}
8227
8229 *this += M.A;
8230 return *this;
8231}
8232
8234 *this += M.A;
8235 return *this;
8236}
8237
8239 *this += M.A;
8240 return *this;
8241}
8242
8244 *this += M.A;
8245 return *this;
8246}
8247
8249 *this += M.A;
8250 return *this;
8251}
8252
8254 *this += M.A;
8255 return *this;
8256}
8257
8259 *this += M.A;
8260 return *this;
8261}
8262
8264 *this -= M.A;
8265 return *this;
8266}
8267
8269 *this -= M.A;
8270 return *this;
8271}
8272
8274 *this -= M.A;
8275 return *this;
8276}
8277
8279 *this -= M.A;
8280 return *this;
8281}
8282
8284 *this -= M.A;
8285 return *this;
8286}
8287
8289 *this -= M.A;
8290 return *this;
8291}
8292
8294 *this -= M.A;
8295 return *this;
8296}
8297
8299 *this -= M.A;
8300 return *this;
8301}
8302
8304 *this *= M.A;
8305 return *this;
8306}
8307
8309 *this *= M.A;
8310 return *this;
8311}
8312
8314 *this *= M.A;
8315 return *this;
8316}
8317
8319 *this *= M.A;
8320 return *this;
8321}
8322
8324 *this *= M.A;
8325 return *this;
8326}
8327
8329 *this *= M.A;
8330 return *this;
8331}
8332
8334 *this *= M.A;
8335 return *this;
8336}
8337
8339 *this *= M.A;
8340 return *this;
8341}
8342
8344 *this |= M.A;
8345 return *this;
8346}
8347
8349 *this |= M.A;
8350 return *this;
8351}
8352
8354 *this |= M.A;
8355 return *this;
8356}
8357
8359 *this |= M.A;
8360 return *this;
8361}
8362
8364 *this |= M.A;
8365 return *this;
8366}
8367
8369 *this |= M.A;
8370 return *this;
8371}
8372
8374 *this |= M.A;
8375 return *this;
8376}
8377
8379 *this |= M.A;
8380 return *this;
8381}
8382
8384 *this &= M.A;
8385 return *this;
8386}
8387
8389 *this &= M.A;
8390 return *this;
8391}
8392
8394 *this &= M.A;
8395 return *this;
8396}
8397
8399 *this &= M.A;
8400 return *this;
8401}
8402
8404inline bool operator==(const scimatrix_slice& M1, const srmatrix_slice& M2) {
8405 return spsp_mm_comp(M1.A,M2.A);
8406}
8407
8409inline bool operator==(const scimatrix_slice& M1, const scmatrix_slice& M2) {
8410 return spsp_mm_comp(M1.A,M2.A);
8411}
8412
8414inline bool operator==(const scimatrix_slice& M1, const simatrix_slice& M2) {
8415 return spsp_mm_comp(M1.A,M2.A);
8416}
8417
8419inline bool operator==(const scimatrix_slice& M1, const scimatrix_slice& M2) {
8420 return spsp_mm_comp(M1.A,M2.A);
8421}
8422
8424inline bool operator==(const srmatrix_slice& M1, const scimatrix_slice& M2) {
8425 return spsp_mm_comp(M1.A,M2.A);
8426}
8427
8429inline bool operator==(const scmatrix_slice& M1, const scimatrix_slice& M2) {
8430 return spsp_mm_comp(M1.A,M2.A);
8431}
8432
8434inline bool operator==(const simatrix_slice& M1, const scimatrix_slice& M2) {
8435 return spsp_mm_comp(M1.A,M2.A);
8436}
8437
8439inline bool operator==(const scimatrix_slice& M1, const srmatrix& M2) {
8440 return spsp_mm_comp(M1.A,M2);
8441}
8442
8444inline bool operator==(const scimatrix_slice& M1, const scmatrix& M2) {
8445 return spsp_mm_comp(M1.A,M2);
8446}
8447
8449inline bool operator==(const scimatrix_slice& M1, const simatrix& M2) {
8450 return spsp_mm_comp(M1.A,M2);
8451}
8452
8454inline bool operator==(const scimatrix_slice& M1, const scimatrix& M2) {
8455 return spsp_mm_comp(M1.A,M2);
8456}
8457
8459inline bool operator==(const srmatrix_slice& M1, const scimatrix& M2) {
8460 return spsp_mm_comp(M1.A,M2);
8461}
8462
8464inline bool operator==(const scmatrix_slice& M1, const scimatrix& M2) {
8465 return spsp_mm_comp(M1.A,M2);
8466}
8467
8469inline bool operator==(const simatrix_slice& M1, const scimatrix& M2) {
8470 return spsp_mm_comp(M1.A,M2);
8471}
8472
8474inline bool operator==(const scimatrix& M1, const srmatrix_slice& M2) {
8475 return spsp_mm_comp(M1,M2.A);
8476}
8477
8479inline bool operator==(const scimatrix& M1, const scmatrix_slice& M2) {
8480 return spsp_mm_comp(M1,M2.A);
8481}
8482
8484inline bool operator==(const scimatrix& M1, const simatrix_slice& M2) {
8485 return spsp_mm_comp(M1,M2.A);
8486}
8487
8489inline bool operator==(const scimatrix& M1, const scimatrix_slice& M2) {
8490 return spsp_mm_comp(M1,M2.A);
8491}
8492
8494inline bool operator==(const srmatrix& M1, const scimatrix_slice& M2) {
8495 return spsp_mm_comp(M1,M2.A);
8496}
8497
8499inline bool operator==(const scmatrix& M1, const scimatrix_slice& M2) {
8500 return spsp_mm_comp(M1,M2.A);
8501}
8502
8504inline bool operator==(const simatrix& M1, const scimatrix_slice& M2) {
8505 return spsp_mm_comp(M1,M2.A);
8506}
8507
8509inline bool operator==(const scimatrix_slice& M1, const rmatrix& M2) {
8510 return spf_mm_comp(M1.A,M2);
8511}
8512
8514inline bool operator==(const scimatrix_slice& M1, const cmatrix& M2) {
8515 return spf_mm_comp(M1.A,M2);
8516}
8517
8519inline bool operator==(const scimatrix_slice& M1, const imatrix& M2) {
8520 return spf_mm_comp(M1.A,M2);
8521}
8522
8524inline bool operator==(const scimatrix_slice& M1, const cimatrix& M2) {
8525 return spf_mm_comp(M1.A,M2);
8526}
8527
8529inline bool operator==(const srmatrix_slice& M1, const cimatrix& M2) {
8530 return spf_mm_comp(M1.A,M2);
8531}
8532
8534inline bool operator==(const scmatrix_slice& M1, const cimatrix& M2) {
8535 return spf_mm_comp(M1.A,M2);
8536}
8537
8539inline bool operator==(const simatrix_slice& M1, const cimatrix& M2) {
8540 return spf_mm_comp(M1.A,M2);
8541}
8542
8544inline bool operator==(const cimatrix& M1, const srmatrix_slice& M2) {
8545 return fsp_mm_comp(M1,M2.A);
8546}
8547
8549inline bool operator==(const cimatrix& M1, const simatrix_slice& M2) {
8550 return fsp_mm_comp(M1,M2.A);
8551}
8552
8554inline bool operator==(const cimatrix& M1, const scmatrix_slice& M2) {
8555 return fsp_mm_comp(M1,M2.A);
8556}
8557
8559inline bool operator==(const cimatrix& M1, const scimatrix_slice& M2) {
8560 return fsp_mm_comp(M1,M2.A);
8561}
8562
8564inline bool operator==(const rmatrix& M1, const scimatrix_slice& M2) {
8565 return fsp_mm_comp(M1,M2.A);
8566}
8567
8569inline bool operator==(const imatrix& M1, const scimatrix_slice& M2) {
8570 return fsp_mm_comp(M1,M2.A);
8571}
8572
8574inline bool operator==(const cmatrix& M1, const scimatrix_slice& M2) {
8575 return fsp_mm_comp(M1,M2.A);
8576}
8577
8579inline bool operator==(const cimatrix_slice& M1, const srmatrix_slice& M2) {
8580 return fsp_mm_comp(M1,M2.A);
8581}
8582
8584inline bool operator==(const cimatrix_slice& M1, const simatrix_slice& M2) {
8585 return fsp_mm_comp(M1,M2.A);
8586}
8587
8589inline bool operator==(const cimatrix_slice& M1, const scmatrix_slice& M2) {
8590 return fsp_mm_comp(M1,M2.A);
8591}
8592
8594inline bool operator==(const cimatrix_slice& M1, const scimatrix_slice& M2) {
8595 return fsp_mm_comp(M1,M2.A);
8596}
8597
8599inline bool operator==(const rmatrix_slice& M1, const scimatrix_slice& M2) {
8600 return fsp_mm_comp(M1,M2.A);
8601}
8602
8604inline bool operator==(const imatrix_slice& M1, const scimatrix_slice& M2) {
8605 return fsp_mm_comp(M1,M2.A);
8606}
8607
8609inline bool operator==(const cmatrix_slice& M1, const scimatrix_slice& M2) {
8610 return fsp_mm_comp(M1,M2.A);
8611}
8612
8614inline bool operator==(const scimatrix_slice& M1, const rmatrix_slice& M2) {
8615 return spf_mm_comp(M1.A,M2);
8616}
8617
8619inline bool operator==(const scimatrix_slice& M1, const cmatrix_slice& M2) {
8620 return spf_mm_comp(M1.A,M2);
8621}
8622
8624inline bool operator==(const scimatrix_slice& M1, const imatrix_slice& M2) {
8625 return spf_mm_comp(M1.A,M2);
8626}
8627
8629inline bool operator==(const scimatrix_slice& M1, const cimatrix_slice& M2) {
8630 return spf_mm_comp(M1.A,M2);
8631}
8632
8634inline bool operator==(const srmatrix_slice& M1, const cimatrix_slice& M2) {
8635 return spf_mm_comp(M1.A,M2);
8636}
8637
8639inline bool operator==(const simatrix_slice& M1, const cimatrix_slice& M2) {
8640 return spf_mm_comp(M1.A,M2);
8641}
8642
8644inline bool operator==(const scmatrix_slice& M1, const cimatrix_slice& M2) {
8645 return spf_mm_comp(M1.A,M2);
8646}
8647
8649inline bool operator!=(const scimatrix_slice& M1, const srmatrix_slice& M2) {
8650 return !spsp_mm_comp(M1.A,M2.A);
8651}
8652
8654inline bool operator!=(const scimatrix_slice& M1, const scmatrix_slice& M2) {
8655 return !spsp_mm_comp(M1.A,M2.A);
8656}
8657
8659inline bool operator!=(const scimatrix_slice& M1, const simatrix_slice& M2) {
8660 return !spsp_mm_comp(M1.A,M2.A);
8661}
8662
8664inline bool operator!=(const scimatrix_slice& M1, const scimatrix_slice& M2) {
8665 return !spsp_mm_comp(M1.A,M2.A);
8666}
8667
8669inline bool operator!=(const srmatrix_slice& M1, const scimatrix_slice& M2) {
8670 return !spsp_mm_comp(M1.A,M2.A);
8671}
8672
8674inline bool operator!=(const scmatrix_slice& M1, const scimatrix_slice& M2) {
8675 return !spsp_mm_comp(M1.A,M2.A);
8676}
8677
8679inline bool operator!=(const simatrix_slice& M1, const scimatrix_slice& M2) {
8680 return !spsp_mm_comp(M1.A,M2.A);
8681}
8682
8684inline bool operator!=(const scimatrix_slice& M1, const srmatrix& M2) {
8685 return !spsp_mm_comp(M1.A,M2);
8686}
8687
8689inline bool operator!=(const scimatrix_slice& M1, const scmatrix& M2) {
8690 return !spsp_mm_comp(M1.A,M2);
8691}
8692
8694inline bool operator!=(const scimatrix_slice& M1, const simatrix& M2) {
8695 return !spsp_mm_comp(M1.A,M2);
8696}
8697
8699inline bool operator!=(const scimatrix_slice& M1, const scimatrix& M2) {
8700 return !spsp_mm_comp(M1.A,M2);
8701}
8702
8704inline bool operator!=(const srmatrix_slice& M1, const scimatrix& M2) {
8705 return !spsp_mm_comp(M1.A,M2);
8706}
8707
8709inline bool operator!=(const scmatrix_slice& M1, const scimatrix& M2) {
8710 return !spsp_mm_comp(M1.A,M2);
8711}
8712
8714inline bool operator!=(const simatrix_slice& M1, const scimatrix& M2) {
8715 return !spsp_mm_comp(M1.A,M2);
8716}
8717
8719inline bool operator!=(const scimatrix& M1, const srmatrix_slice& M2) {
8720 return !spsp_mm_comp(M1,M2.A);
8721}
8722
8724inline bool operator!=(const scimatrix& M1, const scmatrix_slice& M2) {
8725 return !spsp_mm_comp(M1,M2.A);
8726}
8727
8729inline bool operator!=(const scimatrix& M1, const simatrix_slice& M2) {
8730 return !spsp_mm_comp(M1,M2.A);
8731}
8732
8734inline bool operator!=(const scimatrix& M1, const scimatrix_slice& M2) {
8735 return !spsp_mm_comp(M1,M2.A);
8736}
8737
8739inline bool operator!=(const srmatrix& M1, const scimatrix_slice& M2) {
8740 return !spsp_mm_comp(M1,M2.A);
8741}
8742
8744inline bool operator!=(const scmatrix& M1, const scimatrix_slice& M2) {
8745 return !spsp_mm_comp(M1,M2.A);
8746}
8747
8749inline bool operator!=(const simatrix& M1, const scimatrix_slice& M2) {
8750 return !spsp_mm_comp(M1,M2.A);
8751}
8752
8754inline bool operator!=(const scimatrix_slice& M1, const rmatrix& M2) {
8755 return !spf_mm_comp(M1.A,M2);
8756}
8757
8759inline bool operator!=(const scimatrix_slice& M1, const cmatrix& M2) {
8760 return !spf_mm_comp(M1.A,M2);
8761}
8762
8764inline bool operator!=(const scimatrix_slice& M1, const imatrix& M2) {
8765 return !spf_mm_comp(M1.A,M2);
8766}
8767
8769inline bool operator!=(const scimatrix_slice& M1, const cimatrix& M2) {
8770 return !spf_mm_comp(M1.A,M2);
8771}
8772
8774inline bool operator!=(const srmatrix_slice& M1, const cimatrix& M2) {
8775 return !spf_mm_comp(M1.A,M2);
8776}
8777
8779inline bool operator!=(const scmatrix_slice& M1, const cimatrix& M2) {
8780 return !spf_mm_comp(M1.A,M2);
8781}
8782
8784inline bool operator!=(const simatrix_slice& M1, const cimatrix& M2) {
8785 return !spf_mm_comp(M1.A,M2);
8786}
8787
8789inline bool operator!=(const cimatrix& M1, const srmatrix_slice& M2) {
8790 return !fsp_mm_comp(M1,M2.A);
8791}
8792
8794inline bool operator!=(const cimatrix& M1, const simatrix_slice& M2) {
8795 return !fsp_mm_comp(M1,M2.A);
8796}
8797
8799inline bool operator!=(const cimatrix& M1, const scmatrix_slice& M2) {
8800 return !fsp_mm_comp(M1,M2.A);
8801}
8802
8804inline bool operator!=(const cimatrix& M1, const scimatrix_slice& M2) {
8805 return !fsp_mm_comp(M1,M2.A);
8806}
8807
8809inline bool operator!=(const rmatrix& M1, const scimatrix_slice& M2) {
8810 return !fsp_mm_comp(M1,M2.A);
8811}
8812
8814inline bool operator!=(const imatrix& M1, const scimatrix_slice& M2) {
8815 return !fsp_mm_comp(M1,M2.A);
8816}
8817
8819inline bool operator!=(const cmatrix& M1, const scimatrix_slice& M2) {
8820 return !fsp_mm_comp(M1,M2.A);
8821}
8822
8824inline bool operator!=(const cimatrix_slice& M1, const srmatrix_slice& M2) {
8825 return !fsp_mm_comp(M1,M2.A);
8826}
8827
8829inline bool operator!=(const cimatrix_slice& M1, const simatrix_slice& M2) {
8830 return !fsp_mm_comp(M1,M2.A);
8831}
8832
8834inline bool operator!=(const cimatrix_slice& M1, const scmatrix_slice& M2) {
8835 return !fsp_mm_comp(M1,M2.A);
8836}
8837
8839inline bool operator!=(const cimatrix_slice& M1, const scimatrix_slice& M2) {
8840 return !fsp_mm_comp(M1,M2.A);
8841}
8842
8844inline bool operator!=(const rmatrix_slice& M1, const scimatrix_slice& M2) {
8845 return !fsp_mm_comp(M1,M2.A);
8846}
8847
8849inline bool operator!=(const imatrix_slice& M1, const scimatrix_slice& M2) {
8850 return !fsp_mm_comp(M1,M2.A);
8851}
8852
8854inline bool operator!=(const cmatrix_slice& M1, const scimatrix_slice& M2) {
8855 return !fsp_mm_comp(M1,M2.A);
8856}
8857
8859inline bool operator!=(const scimatrix_slice& M1, const rmatrix_slice& M2) {
8860 return !spf_mm_comp(M1.A,M2);
8861}
8862
8864inline bool operator!=(const scimatrix_slice& M1, const cmatrix_slice& M2) {
8865 return !spf_mm_comp(M1.A,M2);
8866}
8867
8869inline bool operator!=(const scimatrix_slice& M1, const imatrix_slice& M2) {
8870 return !spf_mm_comp(M1.A,M2);
8871}
8872
8874inline bool operator!=(const scimatrix_slice& M1, const cimatrix_slice& M2) {
8875 return !spf_mm_comp(M1.A,M2);
8876}
8877
8879inline bool operator!=(const srmatrix_slice& M1, const cimatrix_slice& M2) {
8880 return !spf_mm_comp(M1.A,M2);
8881}
8882
8884inline bool operator!=(const simatrix_slice& M1, const cimatrix_slice& M2) {
8885 return !spf_mm_comp(M1.A,M2);
8886}
8887
8889inline bool operator!=(const scmatrix_slice& M1, const cimatrix_slice& M2) {
8890 return !spf_mm_comp(M1.A,M2);
8891}
8892
8894inline bool operator<(const scimatrix_slice& M1, const simatrix_slice& M2) {
8895 return spsp_mm_less<scimatrix,simatrix,cinterval>(M1.A,M2.A);
8896}
8897
8899inline bool operator<(const scimatrix_slice& M1, const scimatrix_slice& M2) {
8900 return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
8901}
8902
8904inline bool operator<(const srmatrix_slice& M1, const scimatrix_slice& M2) {
8905 return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1.A,M2.A);
8906}
8907
8909inline bool operator<(const scmatrix_slice& M1, const scimatrix_slice& M2) {
8910 return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1.A,M2.A);
8911}
8912
8914inline bool operator<(const simatrix_slice& M1, const scimatrix_slice& M2) {
8915 return spsp_mm_less<simatrix,scimatrix,cinterval>(M1.A,M2.A);
8916}
8917
8919inline bool operator<(const scimatrix_slice& M1, const simatrix& M2) {
8920 return spsp_mm_less<scimatrix,simatrix,cinterval>(M1.A,M2);
8921}
8922
8924inline bool operator<(const scimatrix_slice& M1, const scimatrix& M2) {
8925 return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1.A,M2);
8926}
8927
8929inline bool operator<(const srmatrix_slice& M1, const scimatrix& M2) {
8930 return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1.A,M2);
8931}
8932
8934inline bool operator<(const scmatrix_slice& M1, const scimatrix& M2) {
8935 return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1.A,M2);
8936}
8937
8939inline bool operator<(const simatrix_slice& M1, const scimatrix& M2) {
8940 return spsp_mm_less<simatrix,scimatrix,cinterval>(M1.A,M2);
8941}
8942
8944inline bool operator<(const scimatrix& M1, const simatrix_slice& M2) {
8945 return spsp_mm_less<scimatrix,simatrix,cinterval>(M1,M2.A);
8946}
8947
8949inline bool operator<(const scimatrix& M1, const scimatrix_slice& M2) {
8950 return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1,M2.A);
8951}
8952
8954inline bool operator<(const srmatrix& M1, const scimatrix_slice& M2) {
8955 return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1,M2.A);
8956}
8957
8959inline bool operator<(const scmatrix& M1, const scimatrix_slice& M2) {
8960 return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1,M2.A);
8961}
8962
8964inline bool operator<(const simatrix& M1, const scimatrix_slice& M2) {
8965 return spsp_mm_less<simatrix,scimatrix,cinterval>(M1,M2.A);
8966}
8967
8969inline bool operator<(const scimatrix_slice& M1, const imatrix& M2) {
8970 return spf_mm_less<scimatrix,imatrix,cinterval>(M1.A,M2);
8971}
8972
8974inline bool operator<(const scimatrix_slice& M1, const cimatrix& M2) {
8975 return spf_mm_less<scimatrix,cimatrix,cinterval>(M1.A,M2);
8976}
8977
8979inline bool operator<(const srmatrix_slice& M1, const cimatrix& M2) {
8980 return spf_mm_less<srmatrix,cimatrix,cinterval>(M1.A,M2);
8981}
8982
8984inline bool operator<(const scmatrix_slice& M1, const cimatrix& M2) {
8985 return spf_mm_less<scmatrix,cimatrix,cinterval>(M1.A,M2);
8986}
8987
8989inline bool operator<(const simatrix_slice& M1, const cimatrix& M2) {
8990 return spf_mm_less<simatrix,cimatrix,cinterval>(M1.A,M2);
8991}
8992
8994inline bool operator<(const cimatrix& M1, const simatrix_slice& M2) {
8995 return fsp_mm_less<cimatrix,simatrix,cinterval>(M1,M2.A);
8996}
8997
8999inline bool operator<(const cimatrix& M1, const scimatrix_slice& M2) {
9000 return fsp_mm_less<cimatrix,scimatrix,cinterval>(M1,M2.A);
9001}
9002
9004inline bool operator<(const rmatrix& M1, const scimatrix_slice& M2) {
9005 return fsp_mm_less<rmatrix,scimatrix,cinterval>(M1,M2.A);
9006}
9007
9009inline bool operator<(const imatrix& M1, const scimatrix_slice& M2) {
9010 return fsp_mm_less<imatrix,scimatrix,cinterval>(M1,M2.A);
9011}
9012
9014inline bool operator<(const cmatrix& M1, const scimatrix_slice& M2) {
9015 return fsp_mm_less<cmatrix,scimatrix,cinterval>(M1,M2.A);
9016}
9017
9019inline bool operator<(const cimatrix_slice& M1, const simatrix_slice& M2) {
9020 return fsp_mm_less<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9021}
9022
9024inline bool operator<(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9025 return fsp_mm_less<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9026}
9027
9029inline bool operator<(const rmatrix_slice& M1, const scimatrix_slice& M2) {
9030 return fsp_mm_less<rmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9031}
9032
9034inline bool operator<(const imatrix_slice& M1, const scimatrix_slice& M2) {
9035 return fsp_mm_less<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9036}
9037
9039inline bool operator<(const cmatrix_slice& M1, const scimatrix_slice& M2) {
9040 return fsp_mm_less<cmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9041}
9042
9044inline bool operator<(const scimatrix_slice& M1, const imatrix_slice& M2) {
9045 return spf_mm_less<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9046}
9047
9049inline bool operator<(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9050 return spf_mm_less<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9051}
9052
9054inline bool operator<(const srmatrix_slice& M1, const cimatrix_slice& M2) {
9055 return spf_mm_less<srmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9056}
9057
9059inline bool operator<(const simatrix_slice& M1, const cimatrix_slice& M2) {
9060 return spf_mm_less<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9061}
9062
9064inline bool operator<(const scmatrix_slice& M1, const cimatrix_slice& M2) {
9065 return spf_mm_less<scmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9066}
9067
9069inline bool operator<=(const scimatrix_slice& M1, const simatrix_slice& M2) {
9070 return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9071}
9072
9074inline bool operator<=(const scimatrix_slice& M1, const scimatrix_slice& M2) {
9075 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9076}
9077
9079inline bool operator<=(const srmatrix_slice& M1, const scimatrix_slice& M2) {
9080 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1.A,M2.A);
9081}
9082
9084inline bool operator<=(const scmatrix_slice& M1, const scimatrix_slice& M2) {
9085 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1.A,M2.A);
9086}
9087
9089inline bool operator<=(const simatrix_slice& M1, const scimatrix_slice& M2) {
9090 return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9091}
9092
9094inline bool operator<=(const scimatrix_slice& M1, const simatrix& M2) {
9095 return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1.A,M2);
9096}
9097
9099inline bool operator<=(const scimatrix_slice& M1, const scimatrix& M2) {
9100 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1.A,M2);
9101}
9102
9104inline bool operator<=(const srmatrix_slice& M1, const scimatrix& M2) {
9105 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1.A,M2);
9106}
9107
9109inline bool operator<=(const scmatrix_slice& M1, const scimatrix& M2) {
9110 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1.A,M2);
9111}
9112
9114inline bool operator<=(const simatrix_slice& M1, const scimatrix& M2) {
9115 return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1.A,M2);
9116}
9117
9119inline bool operator<=(const scimatrix& M1, const simatrix_slice& M2) {
9120 return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1,M2.A);
9121}
9122
9124inline bool operator<=(const scimatrix& M1, const scimatrix_slice& M2) {
9125 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1,M2.A);
9126}
9127
9129inline bool operator<=(const srmatrix& M1, const scimatrix_slice& M2) {
9130 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1,M2.A);
9131}
9132
9134inline bool operator<=(const scmatrix& M1, const scimatrix_slice& M2) {
9135 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1,M2.A);
9136}
9137
9139inline bool operator<=(const simatrix& M1, const scimatrix_slice& M2) {
9140 return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1,M2.A);
9141}
9142
9144inline bool operator<=(const scimatrix_slice& M1, const imatrix& M2) {
9145 return spf_mm_leq<scimatrix,imatrix,cinterval>(M1.A,M2);
9146}
9147
9149inline bool operator<=(const scimatrix_slice& M1, const cimatrix& M2) {
9150 return spf_mm_leq<scimatrix,cimatrix,cinterval>(M1.A,M2);
9151}
9152
9154inline bool operator<=(const srmatrix_slice& M1, const cimatrix& M2) {
9155 return spf_mm_leq<srmatrix,cimatrix,cinterval>(M1.A,M2);
9156}
9157
9159inline bool operator<=(const scmatrix_slice& M1, const cimatrix& M2) {
9160 return spf_mm_leq<scmatrix,cimatrix,cinterval>(M1.A,M2);
9161}
9162
9164inline bool operator<=(const simatrix_slice& M1, const cimatrix& M2) {
9165 return spf_mm_leq<simatrix,cimatrix,cinterval>(M1.A,M2);
9166}
9167
9169inline bool operator<=(const cimatrix& M1, const simatrix_slice& M2) {
9170 return fsp_mm_leq<cimatrix,simatrix,cinterval>(M1,M2.A);
9171}
9172
9174inline bool operator<=(const cimatrix& M1, const scimatrix_slice& M2) {
9175 return fsp_mm_leq<cimatrix,scimatrix,cinterval>(M1,M2.A);
9176}
9177
9179inline bool operator<=(const rmatrix& M1, const scimatrix_slice& M2) {
9180 return fsp_mm_leq<rmatrix,scimatrix,cinterval>(M1,M2.A);
9181}
9182
9184inline bool operator<=(const imatrix& M1, const scimatrix_slice& M2) {
9185 return fsp_mm_leq<imatrix,scimatrix,cinterval>(M1,M2.A);
9186}
9187
9189inline bool operator<=(const cmatrix& M1, const scimatrix_slice& M2) {
9190 return fsp_mm_leq<cmatrix,scimatrix,cinterval>(M1,M2.A);
9191}
9192
9194inline bool operator<=(const cimatrix_slice& M1, const simatrix_slice& M2) {
9195 return fsp_mm_leq<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9196}
9197
9199inline bool operator<=(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9200 return fsp_mm_leq<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9201}
9202
9204inline bool operator<=(const rmatrix_slice& M1, const scimatrix_slice& M2) {
9205 return fsp_mm_leq<rmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9206}
9207
9209inline bool operator<=(const imatrix_slice& M1, const scimatrix_slice& M2) {
9210 return fsp_mm_leq<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9211}
9212
9214inline bool operator<=(const cmatrix_slice& M1, const scimatrix_slice& M2) {
9215 return fsp_mm_leq<cmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9216}
9217
9219inline bool operator<=(const scimatrix_slice& M1, const imatrix_slice& M2) {
9220 return spf_mm_leq<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9221}
9222
9224inline bool operator<=(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9225 return spf_mm_leq<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9226}
9227
9229inline bool operator<=(const srmatrix_slice& M1, const cimatrix_slice& M2) {
9230 return spf_mm_leq<srmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9231}
9232
9234inline bool operator<=(const simatrix_slice& M1, const cimatrix_slice& M2) {
9235 return spf_mm_leq<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9236}
9237
9239inline bool operator<=(const scmatrix_slice& M1, const cimatrix_slice& M2) {
9240 return spf_mm_leq<scmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9241}
9242
9244inline bool operator>(const scimatrix_slice& M1, const srmatrix_slice& M2) {
9245 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1.A,M2.A);
9246}
9247
9249inline bool operator>(const scimatrix_slice& M1, const scmatrix_slice& M2) {
9250 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1.A,M2.A);
9251}
9252
9254inline bool operator>(const scimatrix_slice& M1, const simatrix_slice& M2) {
9255 return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9256}
9257
9259inline bool operator>(const scimatrix_slice& M1, const scimatrix_slice& M2) {
9260 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9261}
9262
9264inline bool operator>(const simatrix_slice& M1, const scimatrix_slice& M2) {
9265 return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9266}
9267
9269inline bool operator>(const scimatrix_slice& M1, const srmatrix& M2) {
9270 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1.A,M2);
9271}
9272
9274inline bool operator>(const scimatrix_slice& M1, const scmatrix& M2) {
9275 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1.A,M2);
9276}
9277
9279inline bool operator>(const scimatrix_slice& M1, const simatrix& M2) {
9280 return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1.A,M2);
9281}
9282
9284inline bool operator>(const scimatrix_slice& M1, const scimatrix& M2) {
9285 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1.A,M2);
9286}
9287
9289inline bool operator>(const simatrix_slice& M1, const scimatrix& M2) {
9290 return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1.A,M2);
9291}
9292
9294inline bool operator>(const scimatrix& M1, const srmatrix_slice& M2) {
9295 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1,M2.A);
9296}
9297
9299inline bool operator>(const scimatrix& M1, const scmatrix_slice& M2) {
9300 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1,M2.A);
9301}
9302
9304inline bool operator>(const scimatrix& M1, const simatrix_slice& M2) {
9305 return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1,M2.A);
9306}
9307
9309inline bool operator>(const scimatrix& M1, const scimatrix_slice& M2) {
9310 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1,M2.A);
9311}
9312
9314inline bool operator>(const simatrix& M1, const scimatrix_slice& M2) {
9315 return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1,M2.A);
9316}
9317
9319inline bool operator>(const scimatrix_slice& M1, const rmatrix& M2) {
9320 return spf_mm_greater<scimatrix,rmatrix,cinterval>(M1.A,M2);
9321}
9322
9324inline bool operator>(const scimatrix_slice& M1, const cmatrix& M2) {
9325 return spf_mm_greater<scimatrix,cmatrix,cinterval>(M1.A,M2);
9326}
9327
9329inline bool operator>(const scimatrix_slice& M1, const imatrix& M2) {
9330 return spf_mm_greater<scimatrix,imatrix,cinterval>(M1.A,M2);
9331}
9332
9334inline bool operator>(const scimatrix_slice& M1, const cimatrix& M2) {
9335 return spf_mm_greater<scimatrix,cimatrix,cinterval>(M1.A,M2);
9336}
9337
9339inline bool operator>(const simatrix_slice& M1, const cimatrix& M2) {
9340 return spf_mm_greater<simatrix,cimatrix,cinterval>(M1.A,M2);
9341}
9342
9344inline bool operator>(const cimatrix& M1, const srmatrix_slice& M2) {
9345 return fsp_mm_greater<cimatrix,srmatrix,cinterval>(M1,M2.A);
9346}
9347
9349inline bool operator>(const cimatrix& M1, const simatrix_slice& M2) {
9350 return fsp_mm_greater<cimatrix,simatrix,cinterval>(M1,M2.A);
9351}
9352
9354inline bool operator>(const cimatrix& M1, const scmatrix_slice& M2) {
9355 return fsp_mm_greater<cimatrix,scmatrix,cinterval>(M1,M2.A);
9356}
9357
9359inline bool operator>(const cimatrix& M1, const scimatrix_slice& M2) {
9360 return fsp_mm_greater<cimatrix,scimatrix,cinterval>(M1,M2.A);
9361}
9362
9364inline bool operator>(const imatrix& M1, const scimatrix_slice& M2) {
9365 return fsp_mm_greater<imatrix,scimatrix,cinterval>(M1,M2.A);
9366}
9367
9369inline bool operator>(const cimatrix_slice& M1, const srmatrix_slice& M2) {
9370 return fsp_mm_greater<cimatrix_slice,srmatrix,cinterval>(M1,M2.A);
9371}
9372
9374inline bool operator>(const cimatrix_slice& M1, const simatrix_slice& M2) {
9375 return fsp_mm_greater<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9376}
9377
9379inline bool operator>(const cimatrix_slice& M1, const scmatrix_slice& M2) {
9380 return fsp_mm_greater<cimatrix_slice,scmatrix,cinterval>(M1,M2.A);
9381}
9382
9384inline bool operator>(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9385 return fsp_mm_greater<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9386}
9387
9389inline bool operator>(const imatrix_slice& M1, const scimatrix_slice& M2) {
9390 return fsp_mm_greater<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9391}
9392
9394inline bool operator>(const scimatrix_slice& M1, const rmatrix_slice& M2) {
9395 return spf_mm_greater<scimatrix,rmatrix_slice,cinterval>(M1.A,M2);
9396}
9397
9399inline bool operator>(const scimatrix_slice& M1, const cmatrix_slice& M2) {
9400 return spf_mm_greater<scimatrix,cmatrix_slice,cinterval>(M1.A,M2);
9401}
9402
9404inline bool operator>(const scimatrix_slice& M1, const imatrix_slice& M2) {
9405 return spf_mm_greater<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9406}
9407
9409inline bool operator>(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9410 return spf_mm_greater<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9411}
9412
9414inline bool operator>(const simatrix_slice& M1, const cimatrix_slice& M2) {
9415 return spf_mm_greater<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9416}
9417
9419inline bool operator>=(const scimatrix_slice& M1, const srmatrix_slice& M2) {
9420 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1.A,M2.A);
9421}
9422
9424inline bool operator>=(const scimatrix_slice& M1, const scmatrix_slice& M2) {
9425 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1.A,M2.A);
9426}
9427
9429inline bool operator>=(const scimatrix_slice& M1, const simatrix_slice& M2) {
9430 return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9431}
9432
9434inline bool operator>=(const scimatrix_slice& M1, const scimatrix_slice& M2) {
9435 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9436}
9437
9439inline bool operator>=(const simatrix_slice& M1, const scimatrix_slice& M2) {
9440 return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9441}
9442
9444inline bool operator>=(const scimatrix_slice& M1, const srmatrix& M2) {
9445 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1.A,M2);
9446}
9447
9449inline bool operator>=(const scimatrix_slice& M1, const scmatrix& M2) {
9450 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1.A,M2);
9451}
9452
9454inline bool operator>=(const scimatrix_slice& M1, const simatrix& M2) {
9455 return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1.A,M2);
9456}
9457
9459inline bool operator>=(const scimatrix_slice& M1, const scimatrix& M2) {
9460 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1.A,M2);
9461}
9462
9464inline bool operator>=(const simatrix_slice& M1, const scimatrix& M2) {
9465 return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1.A,M2);
9466}
9467
9469inline bool operator>=(const scimatrix& M1, const srmatrix_slice& M2) {
9470 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1,M2.A);
9471}
9472
9474inline bool operator>=(const scimatrix& M1, const scmatrix_slice& M2) {
9475 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1,M2.A);
9476}
9477
9479inline bool operator>=(const scimatrix& M1, const simatrix_slice& M2) {
9480 return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1,M2.A);
9481}
9482
9484inline bool operator>=(const scimatrix& M1, const scimatrix_slice& M2) {
9485 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1,M2.A);
9486}
9487
9489inline bool operator>=(const simatrix& M1, const scimatrix_slice& M2) {
9490 return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1,M2.A);
9491}
9492
9494inline bool operator>=(const scimatrix_slice& M1, const rmatrix& M2) {
9495 return spf_mm_geq<scimatrix,rmatrix,cinterval>(M1.A,M2);
9496}
9497
9499inline bool operator>=(const scimatrix_slice& M1, const cmatrix& M2) {
9500 return spf_mm_geq<scimatrix,cmatrix,cinterval>(M1.A,M2);
9501}
9502
9504inline bool operator>=(const scimatrix_slice& M1, const imatrix& M2) {
9505 return spf_mm_geq<scimatrix,imatrix,cinterval>(M1.A,M2);
9506}
9507
9509inline bool operator>=(const scimatrix_slice& M1, const cimatrix& M2) {
9510 return spf_mm_geq<scimatrix,cimatrix,cinterval>(M1.A,M2);
9511}
9512
9514inline bool operator>=(const simatrix_slice& M1, const cimatrix& M2) {
9515 return spf_mm_geq<simatrix,cimatrix,cinterval>(M1.A,M2);
9516}
9517
9519inline bool operator>=(const cimatrix& M1, const srmatrix_slice& M2) {
9520 return fsp_mm_geq<cimatrix,srmatrix,cinterval>(M1,M2.A);
9521}
9522
9524inline bool operator>=(const cimatrix& M1, const simatrix_slice& M2) {
9525 return fsp_mm_geq<cimatrix,simatrix,cinterval>(M1,M2.A);
9526}
9527
9529inline bool operator>=(const cimatrix& M1, const scmatrix_slice& M2) {
9530 return fsp_mm_geq<cimatrix,scmatrix,cinterval>(M1,M2.A);
9531}
9532
9534inline bool operator>=(const cimatrix& M1, const scimatrix_slice& M2) {
9535 return fsp_mm_geq<cimatrix,scimatrix,cinterval>(M1,M2.A);
9536}
9537
9539inline bool operator>=(const imatrix& M1, const scimatrix_slice& M2) {
9540 return fsp_mm_geq<imatrix,scimatrix,cinterval>(M1,M2.A);
9541}
9542
9544inline bool operator>=(const cimatrix_slice& M1, const srmatrix_slice& M2) {
9545 return fsp_mm_geq<cimatrix_slice,srmatrix,cinterval>(M1,M2.A);
9546}
9547
9549inline bool operator>=(const cimatrix_slice& M1, const simatrix_slice& M2) {
9550 return fsp_mm_geq<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9551}
9552
9554inline bool operator>=(const cimatrix_slice& M1, const scmatrix_slice& M2) {
9555 return fsp_mm_geq<cimatrix_slice,scmatrix,cinterval>(M1,M2.A);
9556}
9557
9559inline bool operator>=(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9560 return fsp_mm_geq<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9561}
9562
9564inline bool operator>=(const imatrix_slice& M1, const scimatrix_slice& M2) {
9565 return fsp_mm_geq<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9566}
9567
9569inline bool operator>=(const scimatrix_slice& M1, const rmatrix_slice& M2) {
9570 return spf_mm_geq<scimatrix,rmatrix_slice,cinterval>(M1.A,M2);
9571}
9572
9574inline bool operator>=(const scimatrix_slice& M1, const cmatrix_slice& M2) {
9575 return spf_mm_geq<scimatrix,cmatrix_slice,cinterval>(M1.A,M2);
9576}
9577
9579inline bool operator>=(const scimatrix_slice& M1, const imatrix_slice& M2) {
9580 return spf_mm_geq<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9581}
9582
9584inline bool operator>=(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9585 return spf_mm_geq<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9586}
9587
9589inline bool operator>=(const simatrix_slice& M1, const cimatrix_slice& M2) {
9590 return spf_mm_geq<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9591}
9592
9594inline bool operator!(const scimatrix_slice& M) {
9595 return sp_m_not(M.A);
9596}
9597
9599
9604inline std::ostream& operator<<(std::ostream& os, const scimatrix_slice& M) {
9605 return sp_m_output<scimatrix,cinterval>(os, M.A);
9606}
9607
9609
9614inline std::istream& operator>>(std::istream& is, scimatrix_slice& M) {
9615 scimatrix tmp(M.A.m,M.A.n);
9616 is >> tmp;
9617 M = tmp;
9618 return is;
9619}
9620
9621
9623
9629 private:
9630 scimatrix_slice dat;
9631 bool row;
9632 int index;
9633
9634 scimatrix_subv(scimatrix& A, bool r, int i, int j, int k, int l) : dat(A,i,j,k,l), row(r) {
9635 if(row) index=i; else index=k;
9636 }
9637
9638 scimatrix_subv(const scimatrix& A, bool r, int i, int j, int k, int l) : dat(A,i,j,k,l), row(r) {
9639 if(row) index=i; else index=k;
9640 }
9641
9642 public:
9644
9648 cinterval& operator[](const int i) {
9649 if(row) {
9650#if(CXSC_INDEX_CHECK)
9651 if(i<dat.A.lb2 || i>dat.A.ub2)
9652 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_subv::operator[](int)"));
9653#endif
9654 return dat.element(index,i);
9655 } else {
9656#if(CXSC_INDEX_CHECK)
9657 if(i<dat.A.lb1 || i>dat.A.ub1)
9658 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_subv::operator[](int)"));
9659#endif
9660 return dat.element(i,index);
9661 }
9662 }
9663
9665
9668 const cinterval operator[](const int i) const {
9669 if(row) {
9670#if(CXSC_INDEX_CHECK)
9671 if(i<dat.A.lb2 || i>dat.A.ub2)
9672 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_subv::operator[](int)"));
9673#endif
9674 return dat(index,i);
9675 } else {
9676#if(CXSC_INDEX_CHECK)
9677 if(i<dat.A.lb1 || i>dat.A.ub1)
9678 cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_subv::operator[](int)"));
9679#endif
9680 return dat(i,index);
9681 }
9682 }
9683
9686 return sv_vs_assign(*this,v);
9687 }
9688
9691 return sv_vs_assign(*this,v);
9692 }
9693
9696 return sv_vs_assign(*this,v);
9697 }
9698
9701 return sv_vs_assign(*this,v);
9702 }
9703
9706 return svsp_vv_assign(*this,v);
9707 }
9708
9711 return svsp_vv_assign(*this,v);
9712 }
9713
9716 return svsp_vv_assign(*this,v);
9717 }
9718
9721 return svsp_vv_assign(*this,v);
9722 }
9723
9726 return svsl_vv_assign(*this,v);
9727 }
9728
9731 return svsl_vv_assign(*this,v);
9732 }
9733
9736 return svsl_vv_assign(*this,v);
9737 }
9738
9741 return svsl_vv_assign(*this,v);
9742 }
9743
9746 return svf_vv_assign(*this,v);
9747 }
9748
9751 return svf_vv_assign(*this,v);
9752 }
9753
9756 return svf_vv_assign(*this,v);
9757 }
9758
9761 return svf_vv_assign(*this,v);
9762 }
9763
9766 return svf_vv_assign(*this,v);
9767 }
9768
9771 return svf_vv_assign(*this,v);
9772 }
9773
9776 return svf_vv_assign(*this,v);
9777 }
9778
9781 return svf_vv_assign(*this,v);
9782 }
9783
9786 return svsp_vv_assign(*this,srvector(v));
9787 }
9788
9791 return svsp_vv_assign(*this,sivector(v));
9792 }
9793
9796 return svsp_vv_assign(*this,scvector(v));
9797 }
9798
9801 return svsp_vv_assign(*this,scivector(v));
9802 }
9803
9916
9917 friend scivector operator-(const scimatrix_subv&);
9918
9919 friend std::istream& operator>>(std::istream&, scimatrix_subv&);
9920
9921 friend int Lb(const scimatrix_subv&);
9922 friend int Ub(const scimatrix_subv&);
9923 friend int VecLen(const scimatrix_subv&);
9924 friend sivector Re(const scimatrix_subv&);
9925 friend sivector Im(const scimatrix_subv&);
9926 friend scvector Inf(const scimatrix_subv&);
9927 friend scvector Sup(const scimatrix_subv&);
9928 friend srvector InfRe(const scimatrix_subv&);
9929 friend srvector InfIm(const scimatrix_subv&);
9930 friend srvector SupRe(const scimatrix_subv&);
9931 friend srvector SupIm(const scimatrix_subv&);
9932
9933 friend class srvector;
9934 friend class srmatrix;
9935 friend class srmatrix_slice;
9936 friend class scvector;
9937 friend class scmatrix;
9938 friend class scmatrix_slice;
9939 friend class sivector;
9940 friend class simatrix;
9941 friend class simatrix_slice;
9942 friend class scivector;
9943 friend class scimatrix;
9944 friend class scimatrix_slice;
9945
9946#include "vector_friend_declarations.inl"
9947};
9948
9950inline int Lb(const scimatrix_subv& S) {
9951 if(S.row)
9952 return Lb(S.dat, 2);
9953 else
9954 return Lb(S.dat, 1);
9955}
9956
9958inline int Ub(const scimatrix_subv& S) {
9959 if(S.row)
9960 return Ub(S.dat, 2);
9961 else
9962 return Ub(S.dat, 1);
9963}
9964
9966inline int VecLen(const scimatrix_subv& S) {
9967 return Ub(S)-Lb(S)+1;
9968}
9969
9971inline sivector Re(const scimatrix_subv& S) {
9972 return Re(scivector(S));
9973}
9974
9976inline sivector Im(const scimatrix_subv& S) {
9977 return Im(scivector(S));
9978}
9979
9981inline scivector conj(const scimatrix_subv& S) {
9982 return conj(scivector(S));
9983}
9984
9986inline sivector abs(const scimatrix_subv& S) {
9987 return abs(scivector(S));
9988}
9989
9991inline scvector mid(const scimatrix_subv& S) {
9992 return mid(scivector(S));
9993}
9994
9996inline scvector diam(const scimatrix_subv& S) {
9997 return diam(scivector(S));
9998}
9999
10001inline scvector Inf(const scimatrix_subv& S) {
10002 return Inf(scivector(S));
10003}
10004
10006inline scvector Sup(const scimatrix_subv& S) {
10007 return Sup(scivector(S));
10008}
10009
10011inline srvector InfRe(const scimatrix_subv& S) {
10012 return InfRe(scivector(S));
10013}
10014
10016inline srvector InfIm(const scimatrix_subv& S) {
10017 return InfIm(scivector(S));
10018}
10019
10021inline srvector SupRe(const scimatrix_subv& S) {
10022 return SupRe(scivector(S));
10023}
10024
10026inline srvector SupIm(const scimatrix_subv& S) {
10027 return SupIm(scivector(S));
10028}
10029
10031inline std::ostream& operator<<(std::ostream& os, const scimatrix_subv& v) {
10032 os << scivector(v);
10033 return os;
10034}
10035
10037inline std::istream& operator>>(std::istream& is, scimatrix_subv& v) {
10038 int n=0;
10039 if(v.row) n=v.dat.A.n; else n=v.dat.A.m;
10040 scivector tmp(n);
10041 is >> tmp;
10042 v = tmp;
10043 return is;
10044}
10045
10046inline scimatrix_subv scimatrix::operator[](const cxscmatrix_column& c) {
10047#if(CXSC_INDEX_CHECK)
10048 if(c.col()<lb2 || c.col()>ub2)
10049 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator[](const cxscmatrix_column&)"));
10050#endif
10051 return scimatrix_subv(*this, false, lb1, ub1, c.col(), c.col());
10052}
10053
10055#if(CXSC_INDEX_CHECK)
10056 if(i<lb1 || i>ub1)
10057 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator[](const int)"));
10058#endif
10059 return scimatrix_subv(*this, true, i, i, lb2, ub2);
10060}
10061
10062inline const scimatrix_subv scimatrix::operator[](const cxscmatrix_column& c) const{
10063#if(CXSC_INDEX_CHECK)
10064 if(c.col()<lb2 || c.col()>ub2)
10065 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator[](const cxscmatrix_column&)"));
10066#endif
10067 return scimatrix_subv(*this, false, lb1, ub1, c.col(), c.col());
10068}
10069
10070inline const scimatrix_subv scimatrix::operator[](const int i) const{
10071#if(CXSC_INDEX_CHECK)
10072 if(i<lb1 || i>ub1)
10073 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator[](const int)"));
10074#endif
10075 return scimatrix_subv(*this, true, i, i, lb2, ub2);
10076}
10077
10079#if(CXSC_INDEX_CHECK)
10080 if(i<A.lb1 || i>A.ub1)
10081 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix_slice::operator[](const int)"));
10082#endif
10083 return scimatrix_subv(*M, true, i, i, A.lb2, A.ub2);
10084}
10085
10086inline scimatrix_subv scimatrix_slice::operator[](const cxscmatrix_column& c) {
10087#if(CXSC_INDEX_CHECK)
10088 if(c.col()<A.lb2 || c.col()>A.ub2)
10089 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix_slice::operator[](const cxscmatrix_column&)"));
10090#endif
10091 return scimatrix_subv(*M, false, A.lb1, A.ub1, c.col(), c.col());
10092}
10093
10094inline const scimatrix_subv scimatrix_slice::operator[](const int i) const {
10095#if(CXSC_INDEX_CHECK)
10096 if(i<A.lb1 || i>A.ub1)
10097 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix_slice::operator[](const int)"));
10098#endif
10099 return scimatrix_subv(*M, true, i, i, A.lb2, A.ub2);
10100}
10101
10102inline const scimatrix_subv scimatrix_slice::operator[](const cxscmatrix_column& c) const {
10103#if(CXSC_INDEX_CHECK)
10104 if(c.col()<A.lb2 || c.col()>A.ub2)
10105 cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix_slice::operator[](const cxscmatrix_column&)"));
10106#endif
10107 return scimatrix_subv(*M, false, A.lb1, A.ub1, c.col(), c.col());
10108}
10109
10111 int nnz = A.dat.A.get_nnz();
10112 p.reserve(nnz);
10113 x.reserve(nnz);
10114
10115 if(A.row) {
10116 lb = A.dat.A.lb2;
10117 ub = A.dat.A.ub2;
10118 n = ub-lb+1;
10119
10120 for(int j=0 ; j<n ; j++) {
10121 for(int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10122 p.push_back(j);
10123 x.push_back(A.dat.A.x[k]);
10124 }
10125 }
10126
10127 } else {
10128 lb = A.dat.A.lb1;
10129 ub = A.dat.A.ub1;
10130 n = ub-lb+1;
10131
10132 for(unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10133 p.push_back(A.dat.A.ind[k]);
10134 x.push_back(A.dat.A.x[k]);
10135 }
10136 }
10137}
10138
10140 int nnz = A.dat.A.get_nnz();
10141 p.reserve(nnz);
10142 x.reserve(nnz);
10143
10144 if(A.row) {
10145 lb = A.dat.A.lb2;
10146 ub = A.dat.A.ub2;
10147 n = ub-lb+1;
10148
10149 for(int j=0 ; j<n ; j++) {
10150 for(int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10151 p.push_back(j);
10152 x.push_back(cinterval(A.dat.A.x[k]));
10153 }
10154 }
10155
10156 } else {
10157 lb = A.dat.A.lb1;
10158 ub = A.dat.A.ub1;
10159 n = ub-lb+1;
10160
10161 for(unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10162 p.push_back(A.dat.A.ind[k]);
10163 x.push_back(cinterval(A.dat.A.x[k]));
10164 }
10165 }
10166}
10167
10169 int nnz = A.dat.A.get_nnz();
10170 p.reserve(nnz);
10171 x.reserve(nnz);
10172
10173 if(A.row) {
10174 lb = A.dat.A.lb2;
10175 ub = A.dat.A.ub2;
10176 n = ub-lb+1;
10177
10178 for(int j=0 ; j<n ; j++) {
10179 for(int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10180 p.push_back(j);
10181 x.push_back(cinterval(A.dat.A.x[k]));
10182 }
10183 }
10184
10185 } else {
10186 lb = A.dat.A.lb1;
10187 ub = A.dat.A.ub1;
10188 n = ub-lb+1;
10189
10190 for(unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10191 p.push_back(A.dat.A.ind[k]);
10192 x.push_back(cinterval(A.dat.A.x[k]));
10193 }
10194 }
10195}
10196
10198 int nnz = A.dat.A.get_nnz();
10199 p.reserve(nnz);
10200 x.reserve(nnz);
10201
10202 if(A.row) {
10203 lb = A.dat.A.lb2;
10204 ub = A.dat.A.ub2;
10205 n = ub-lb+1;
10206
10207 for(int j=0 ; j<n ; j++) {
10208 for(int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10209 p.push_back(j);
10210 x.push_back(cinterval(A.dat.A.x[k]));
10211 }
10212 }
10213
10214 } else {
10215 lb = A.dat.A.lb1;
10216 ub = A.dat.A.ub1;
10217 n = ub-lb+1;
10218
10219 for(unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10220 p.push_back(A.dat.A.ind[k]);
10221 x.push_back(cinterval(A.dat.A.x[k]));
10222 }
10223 }
10224}
10225
10227inline scivector operator-(const scimatrix_subv& v) {
10228 scivector s(v);
10229 return -s;
10230}
10231
10233inline scivector operator/(const scimatrix_subv& v1, const real& v2) {
10234 return scivector(v1) / v2;
10235}
10236
10238inline scivector operator/(const scimatrix_subv& v1, const complex& v2) {
10239 return scivector(v1) / v2;
10240}
10241
10243inline scivector operator/(const scimatrix_subv& v1, const interval& v2) {
10244 return scivector(v1) / v2;
10245}
10246
10248inline scivector operator/(const scimatrix_subv& v1, const cinterval& v2) {
10249 return scivector(v1) / v2;
10250}
10251
10253inline scivector operator/(const srmatrix_subv& v1, const cinterval& v2) {
10254 return srvector(v1) / v2;
10255}
10256
10258inline scivector operator/(const scmatrix_subv& v1, const cinterval& v2) {
10259 return scvector(v1) / v2;
10260}
10261
10263inline scivector operator/(const simatrix_subv& v1, const cinterval& v2) {
10264 return sivector(v1) / v2;
10265}
10266
10268inline scivector operator/(const simatrix_subv& v1, const complex& v2) {
10269 return sivector(v1) / v2;
10270}
10271
10273inline scivector operator/(const scmatrix_subv& v1, const interval& v2) {
10274 return scvector(v1) / v2;
10275}
10276
10278inline scivector operator*(const scimatrix_subv& v1, const real& v2) {
10279 return scivector(v1) * v2;
10280}
10281
10283inline scivector operator*(const scimatrix_subv& v1, const complex& v2) {
10284 return scivector(v1) * v2;
10285}
10286
10288inline scivector operator*(const scimatrix_subv& v1, const interval& v2) {
10289 return scivector(v1) * v2;
10290}
10291
10293inline scivector operator*(const scimatrix_subv& v1, const cinterval& v2) {
10294 return scivector(v1) * v2;
10295}
10296
10298inline scivector operator*(const srmatrix_subv& v1, const cinterval& v2) {
10299 return srvector(v1) * v2;
10300}
10301
10303inline scivector operator*(const scmatrix_subv& v1, const cinterval& v2) {
10304 return scvector(v1) * v2;
10305}
10306
10308inline scivector operator*(const simatrix_subv& v1, const cinterval& v2) {
10309 return sivector(v1) * v2;
10310}
10311
10313inline scivector operator*(const simatrix_subv& v1, const complex& v2) {
10314 return sivector(v1) * v2;
10315}
10316
10318inline scivector operator*(const scmatrix_subv& v1, const interval& v2) {
10319 return scvector(v1) * v2;
10320}
10321
10323inline scivector operator*(const real& v1, const scimatrix_subv& v2) {
10324 return v1 * scivector(v2);
10325}
10326
10328inline scivector operator*(const complex& v1, const scimatrix_subv& v2) {
10329 return v1 * scivector(v2);
10330}
10331
10333inline scivector operator*(const interval& v1, const scimatrix_subv& v2) {
10334 return v1 * scivector(v2);
10335}
10336
10338inline scivector operator*(const cinterval& v1, const scimatrix_subv& v2) {
10339 return v1 * scivector(v2);
10340}
10341
10343inline scivector operator*(const cinterval& v1, const srmatrix_subv& v2) {
10344 return v1 * srvector(v2);
10345}
10346
10348inline scivector operator*(const cinterval& v1, const scmatrix_subv& v2) {
10349 return v1 * scvector(v2);
10350}
10351
10353inline scivector operator*(const cinterval& v1, const simatrix_subv& v2) {
10354 return v1 * sivector(v2);
10355}
10356
10358inline scivector operator*(const complex& v1, const simatrix_subv& v2) {
10359 return v1 * sivector(v2);
10360}
10361
10363inline scivector operator*(const interval& v1, const scmatrix_subv& v2) {
10364 return v1 * scvector(v2);
10365}
10366
10368
10374inline cinterval operator*(const scimatrix_subv& v1, const srvector& v2) {
10375 return scivector(v1) * v2;
10376}
10377
10379
10385inline cinterval operator*(const scimatrix_subv& v1, const scvector& v2) {
10386 return scivector(v1) * v2;
10387}
10388
10390
10396inline cinterval operator*(const scimatrix_subv& v1, const sivector& v2) {
10397 return scivector(v1) * v2;
10398}
10399
10401
10407inline cinterval operator*(const scimatrix_subv& v1, const scivector& v2) {
10408 return scivector(v1) * v2;
10409}
10410
10412
10418inline cinterval operator*(const srmatrix_subv& v1, const scivector& v2) {
10419 return srvector(v1) * v2;
10420}
10421
10423
10429inline cinterval operator*(const scmatrix_subv& v1, const scivector& v2) {
10430 return scvector(v1) * v2;
10431}
10432
10434
10440inline cinterval operator*(const simatrix_subv& v1, const scivector& v2) {
10441 return sivector(v1) * v2;
10442}
10443
10445
10451inline cinterval operator*(const scmatrix_subv& v1, const sivector& v2) {
10452 return scvector(v1) * v2;
10453}
10454
10456
10462inline cinterval operator*(const simatrix_subv& v1, const scvector& v2) {
10463 return sivector(v1) * v2;
10464}
10465
10467
10473inline cinterval operator*(const scimatrix_subv& v1, const srvector_slice& v2) {
10474 return scivector(v1) * v2;
10475}
10476
10478
10484inline cinterval operator*(const scimatrix_subv& v1, const scvector_slice& v2) {
10485 return scivector(v1) * v2;
10486}
10487
10489
10495inline cinterval operator*(const scimatrix_subv& v1, const sivector_slice& v2) {
10496 return scivector(v1) * v2;
10497}
10498
10500
10507 return scivector(v1) * v2;
10508}
10509
10511
10517inline cinterval operator*(const srmatrix_subv& v1, const scivector_slice& v2) {
10518 return srvector(v1) * v2;
10519}
10520
10522
10528inline cinterval operator*(const scmatrix_subv& v1, const scivector_slice& v2) {
10529 return scvector(v1) * v2;
10530}
10531
10533
10539inline cinterval operator*(const simatrix_subv& v1, const scivector_slice& v2) {
10540 return sivector(v1) * v2;
10541}
10542
10544
10550inline cinterval operator*(const scmatrix_subv& v1, const sivector_slice& v2) {
10551 return scvector(v1) * v2;
10552}
10553
10555
10561inline cinterval operator*(const simatrix_subv& v1, const scvector_slice& v2) {
10562 return sivector(v1) * v2;
10563}
10564
10566
10572inline cinterval operator*(const scimatrix_subv& v1, const rvector& v2) {
10573 return scivector(v1) * v2;
10574}
10575
10577
10583inline cinterval operator*(const scimatrix_subv& v1, const ivector& v2) {
10584 return scivector(v1) * v2;
10585}
10586
10588
10594inline cinterval operator*(const scimatrix_subv& v1, const cvector& v2) {
10595 return scivector(v1) * v2;
10596}
10597
10599
10605inline cinterval operator*(const scimatrix_subv& v1, const civector& v2) {
10606 return scivector(v1) * v2;
10607}
10608
10610
10616inline cinterval operator*(const srmatrix_subv& v1, const civector& v2) {
10617 return srvector(v1) * v2;
10618}
10619
10621
10627inline cinterval operator*(const simatrix_subv& v1, const civector& v2) {
10628 return sivector(v1) * v2;
10629}
10630
10632
10638inline cinterval operator*(const scmatrix_subv& v1, const civector& v2) {
10639 return scvector(v1) * v2;
10640}
10641
10643
10649inline cinterval operator*(const scmatrix_subv& v1, const ivector& v2) {
10650 return scvector(v1) * v2;
10651}
10652
10654
10660inline cinterval operator*(const simatrix_subv& v1, const cvector& v2) {
10661 return sivector(v1) * v2;
10662}
10663
10665
10671inline cinterval operator*(const scimatrix_subv& v1, const rvector_slice& v2) {
10672 return scivector(v1) * v2;
10673}
10674
10676
10682inline cinterval operator*(const scimatrix_subv& v1, const ivector_slice& v2) {
10683 return scivector(v1) * v2;
10684}
10685
10687
10693inline cinterval operator*(const scimatrix_subv& v1, const cvector_slice& v2) {
10694 return scivector(v1) * v2;
10695}
10696
10698
10704inline cinterval operator*(const scimatrix_subv& v1, const civector_slice& v2) {
10705 return scivector(v1) * v2;
10706}
10707
10709
10715inline cinterval operator*(const srmatrix_subv& v1, const civector_slice& v2) {
10716 return srvector(v1) * v2;
10717}
10718
10720
10726inline cinterval operator*(const scmatrix_subv& v1, const civector_slice& v2) {
10727 return scvector(v1) * v2;
10728}
10729
10731
10737inline cinterval operator*(const simatrix_subv& v1, const civector_slice& v2) {
10738 return sivector(v1) * v2;
10739}
10740
10742
10748inline cinterval operator*(const scmatrix_subv& v1, const ivector_slice& v2) {
10749 return scvector(v1) * v2;
10750}
10751
10753
10759inline cinterval operator*(const simatrix_subv& v1, const cvector_slice& v2) {
10760 return sivector(v1) * v2;
10761}
10762
10764
10770inline cinterval operator*(const scivector& v1, const srmatrix_subv& v2) {
10771 return v1 * srvector(v2);
10772}
10773
10775
10781inline cinterval operator*(const scivector& v1, const scmatrix_subv& v2) {
10782 return v1 * scvector(v2);
10783}
10784
10786
10792inline cinterval operator*(const scivector& v1, const simatrix_subv& v2) {
10793 return v1 * sivector(v2);
10794}
10795
10797
10803inline cinterval operator*(const scivector& v1, const scimatrix_subv& v2) {
10804 return v1 * scivector(v2);
10805}
10806
10808
10814inline cinterval operator*(const srvector& v1, const scimatrix_subv& v2) {
10815 return v1 * scivector(v2);
10816}
10817
10819
10825inline cinterval operator*(const scvector& v1, const scimatrix_subv& v2) {
10826 return v1 * scivector(v2);
10827}
10828
10830
10836inline cinterval operator*(const sivector& v1, const scimatrix_subv& v2) {
10837 return v1 * scivector(v2);
10838}
10839
10841
10847inline cinterval operator*(const scvector& v1, const simatrix_subv& v2) {
10848 return v1 * sivector(v2);
10849}
10850
10852
10858inline cinterval operator*(const sivector& v1, const scmatrix_subv& v2) {
10859 return v1 * scvector(v2);
10860}
10861
10863
10869inline cinterval operator*(const scivector_slice& v1, const srmatrix_subv& v2) {
10870 return v1 * srvector(v2);
10871}
10872
10874
10880inline cinterval operator*(const scivector_slice& v1, const scmatrix_subv& v2) {
10881 return v1 * scvector(v2);
10882}
10883
10885
10891inline cinterval operator*(const scivector_slice& v1, const simatrix_subv& v2) {
10892 return v1 * sivector(v2);
10893}
10894
10896
10903 return v1 * scivector(v2);
10904}
10905
10907
10913inline cinterval operator*(const srvector_slice& v1, const scimatrix_subv& v2) {
10914 return v1 * scivector(v2);
10915}
10916
10918
10924inline cinterval operator*(const sivector_slice& v1, const scimatrix_subv& v2) {
10925 return v1 * scivector(v2);
10926}
10927
10929
10935inline cinterval operator*(const scvector_slice& v1, const scimatrix_subv& v2) {
10936 return v1 * scivector(v2);
10937}
10938
10940
10946inline cinterval operator*(const scvector_slice& v1, const simatrix_subv& v2) {
10947 return v1 * sivector(v2);
10948}
10949
10951
10957inline cinterval operator*(const sivector_slice& v1, const scmatrix_subv& v2) {
10958 return v1 * scvector(v2);
10959}
10960
10962
10968inline cinterval operator*(const civector& v1, const srmatrix_subv& v2) {
10969 return v1 * srvector(v2);
10970}
10971
10973
10979inline cinterval operator*(const civector& v1, const scmatrix_subv& v2) {
10980 return v1 * scvector(v2);
10981}
10982
10984
10990inline cinterval operator*(const civector& v1, const simatrix_subv& v2) {
10991 return v1 * sivector(v2);
10992}
10993
10995
11001inline cinterval operator*(const civector& v1, const scimatrix_subv& v2) {
11002 return v1 * scivector(v2);
11003}
11004
11006
11012inline cinterval operator*(const rvector& v1, const scimatrix_subv& v2) {
11013 return v1 * scivector(v2);
11014}
11015
11017
11023inline cinterval operator*(const cvector& v1, const scimatrix_subv& v2) {
11024 return v1 * scivector(v2);
11025}
11026
11028
11034inline cinterval operator*(const ivector& v1, const scimatrix_subv& v2) {
11035 return v1 * scivector(v2);
11036}
11037
11039
11045inline cinterval operator*(const ivector& v1, const scmatrix_subv& v2) {
11046 return v1 * scvector(v2);
11047}
11048
11050
11056inline cinterval operator*(const cvector& v1, const simatrix_subv& v2) {
11057 return v1 * sivector(v2);
11058}
11059
11061
11067inline cinterval operator*(const civector_slice& v1, const srmatrix_subv& v2) {
11068 return v1 * srvector(v2);
11069}
11070
11072
11078inline cinterval operator*(const civector_slice& v1, const scmatrix_subv& v2) {
11079 return v1 * scvector(v2);
11080}
11081
11083
11089inline cinterval operator*(const civector_slice& v1, const simatrix_subv& v2) {
11090 return v1 * sivector(v2);
11091}
11092
11094
11100inline cinterval operator*(const civector_slice& v1, const scimatrix_subv& v2) {
11101 return v1 * scivector(v2);
11102}
11103
11105
11111inline cinterval operator*(const rvector_slice& v1, const scimatrix_subv& v2) {
11112 return v1 * scivector(v2);
11113}
11114
11116
11122inline cinterval operator*(const cvector_slice& v1, const scimatrix_subv& v2) {
11123 return v1 * scivector(v2);
11124}
11125
11127
11133inline cinterval operator*(const ivector_slice& v1, const scimatrix_subv& v2) {
11134 return v1 * scivector(v2);
11135}
11136
11138
11144inline cinterval operator*(const ivector_slice& v1, const scmatrix_subv& v2) {
11145 return v1 * scvector(v2);
11146}
11147
11149
11155inline cinterval operator*(const cvector_slice& v1, const simatrix_subv& v2) {
11156 return v1 * sivector(v2);
11157}
11158
11160inline scivector operator+(const scimatrix_subv& v1, const srvector& v2) {
11161 return scivector(v1) + v2;
11162}
11163
11165inline scivector operator+(const scimatrix_subv& v1, const scvector& v2) {
11166 return scivector(v1) + v2;
11167}
11168
11170inline scivector operator+(const scimatrix_subv& v1, const sivector& v2) {
11171 return scivector(v1) + v2;
11172}
11173
11175inline scivector operator+(const scimatrix_subv& v1, const scivector& v2) {
11176 return scivector(v1) + v2;
11177}
11178
11180inline scivector operator+(const srmatrix_subv& v1, const scivector& v2) {
11181 return srvector(v1) + v2;
11182}
11183
11185inline scivector operator+(const scmatrix_subv& v1, const scivector& v2) {
11186 return scvector(v1) + v2;
11187}
11188
11190inline scivector operator+(const simatrix_subv& v1, const scivector& v2) {
11191 return sivector(v1) + v2;
11192}
11193
11195inline scivector operator+(const scmatrix_subv& v1, const sivector& v2) {
11196 return scvector(v1) + v2;
11197}
11198
11200inline scivector operator+(const simatrix_subv& v1, const scvector& v2) {
11201 return sivector(v1) + v2;
11202}
11203
11205inline scivector operator+(const scimatrix_subv& v1, const srvector_slice& v2) {
11206 return scivector(v1) + v2;
11207}
11208
11210inline scivector operator+(const scimatrix_subv& v1, const scvector_slice& v2) {
11211 return scivector(v1) + v2;
11212}
11213
11215inline scivector operator+(const scimatrix_subv& v1, const sivector_slice& v2) {
11216 return scivector(v1) + v2;
11217}
11218
11220inline scivector operator+(const scimatrix_subv& v1, const scivector_slice& v2) {
11221 return scivector(v1) + v2;
11222}
11223
11225inline scivector operator+(const srmatrix_subv& v1, const scivector_slice& v2) {
11226 return srvector(v1) + v2;
11227}
11228
11230inline scivector operator+(const scmatrix_subv& v1, const scivector_slice& v2) {
11231 return scvector(v1) + v2;
11232}
11233
11235inline scivector operator+(const simatrix_subv& v1, const scivector_slice& v2) {
11236 return sivector(v1) + v2;
11237}
11238
11240inline scivector operator+(const simatrix_subv& v1, const scvector_slice& v2) {
11241 return sivector(v1) + v2;
11242}
11243
11245inline scivector operator+(const scmatrix_subv& v1, const sivector_slice& v2) {
11246 return scvector(v1) + v2;
11247}
11248
11250inline civector operator+(const scimatrix_subv& v1, const rvector& v2) {
11251 return scivector(v1) + v2;
11252}
11253
11255inline civector operator+(const scimatrix_subv& v1, const cvector& v2) {
11256 return scivector(v1) + v2;
11257}
11258
11260inline civector operator+(const scimatrix_subv& v1, const ivector& v2) {
11261 return scivector(v1) + v2;
11262}
11263
11265inline civector operator+(const scimatrix_subv& v1, const civector& v2) {
11266 return scivector(v1) + v2;
11267}
11268
11270inline civector operator+(const srmatrix_subv& v1, const civector& v2) {
11271 return srvector(v1) + v2;
11272}
11273
11275inline civector operator+(const simatrix_subv& v1, const civector& v2) {
11276 return sivector(v1) + v2;
11277}
11278
11280inline civector operator+(const scmatrix_subv& v1, const civector& v2) {
11281 return scvector(v1) + v2;
11282}
11283
11285inline civector operator+(const scmatrix_subv& v1, const ivector& v2) {
11286 return scvector(v1) + v2;
11287}
11288
11290inline civector operator+(const simatrix_subv& v1, const cvector& v2) {
11291 return sivector(v1) + v2;
11292}
11293
11295inline civector operator+(const scimatrix_subv& v1, const rvector_slice& v2) {
11296 return scivector(v1) + v2;
11297}
11298
11300inline civector operator+(const scimatrix_subv& v1, const cvector_slice& v2) {
11301 return scivector(v1) + v2;
11302}
11303
11305inline civector operator+(const scimatrix_subv& v1, const ivector_slice& v2) {
11306 return scivector(v1) + v2;
11307}
11308
11310inline civector operator+(const scimatrix_subv& v1, const civector_slice& v2) {
11311 return scivector(v1) + v2;
11312}
11313
11315inline civector operator+(const srmatrix_subv& v1, const civector_slice& v2) {
11316 return srvector(v1) + v2;
11317}
11318
11320inline civector operator+(const scmatrix_subv& v1, const civector_slice& v2) {
11321 return scvector(v1) + v2;
11322}
11323
11325inline civector operator+(const simatrix_subv& v1, const civector_slice& v2) {
11326 return sivector(v1) + v2;
11327}
11328
11330inline civector operator+(const simatrix_subv& v1, const cvector_slice& v2) {
11331 return sivector(v1) + v2;
11332}
11333
11335inline civector operator+(const scmatrix_subv& v1, const ivector_slice& v2) {
11336 return scvector(v1) + v2;
11337}
11338
11340inline scivector operator+(const scivector& v1, const srmatrix_subv& v2) {
11341 return v1 + srvector(v2);
11342}
11343
11345inline scivector operator+(const scivector& v1, const scmatrix_subv& v2) {
11346 return v1 + scvector(v2);
11347}
11348
11350inline scivector operator+(const scivector& v1, const simatrix_subv& v2) {
11351 return v1 + sivector(v2);
11352}
11353
11355inline scivector operator+(const scivector& v1, const scimatrix_subv& v2) {
11356 return v1 + scivector(v2);
11357}
11358
11360inline scivector operator+(const srvector& v1, const scimatrix_subv& v2) {
11361 return v1 + scivector(v2);
11362}
11363
11365inline scivector operator+(const scvector& v1, const scimatrix_subv& v2) {
11366 return v1 + scivector(v2);
11367}
11368
11370inline scivector operator+(const sivector& v1, const scimatrix_subv& v2) {
11371 return v1 + scivector(v2);
11372}
11373
11375inline scivector operator+(const sivector& v1, const scmatrix_subv& v2) {
11376 return v1 + scvector(v2);
11377}
11378
11380inline scivector operator+(const scvector& v1, const simatrix_subv& v2) {
11381 return v1 + sivector(v2);
11382}
11383
11385inline scivector operator+(const scivector_slice& v1, const srmatrix_subv& v2) {
11386 return v1 + srvector(v2);
11387}
11388
11390inline scivector operator+(const scivector_slice& v1, const scmatrix_subv& v2) {
11391 return v1 + scvector(v2);
11392}
11393
11395inline scivector operator+(const scivector_slice& v1, const simatrix_subv& v2) {
11396 return v1 + sivector(v2);
11397}
11398
11400inline scivector operator+(const scivector_slice& v1, const scimatrix_subv& v2) {
11401 return v1 + scivector(v2);
11402}
11403
11405inline scivector operator+(const srvector_slice& v1, const scimatrix_subv& v2) {
11406 return v1 + scivector(v2);
11407}
11408
11410inline scivector operator+(const scvector_slice& v1, const scimatrix_subv& v2) {
11411 return v1 + scivector(v2);
11412}
11413
11415inline scivector operator+(const sivector_slice& v1, const scimatrix_subv& v2) {
11416 return v1 + scivector(v2);
11417}
11418
11420inline scivector operator+(const sivector_slice& v1, const scmatrix_subv& v2) {
11421 return v1 + scvector(v2);
11422}
11423
11425inline scivector operator+(const scvector_slice& v1, const simatrix_subv& v2) {
11426 return v1 + sivector(v2);
11427}
11428
11430inline civector operator+(const civector& v1, const srmatrix_subv& v2) {
11431 return v1 + srvector(v2);
11432}
11433
11435inline civector operator+(const civector& v1, const scmatrix_subv& v2) {
11436 return v1 + scvector(v2);
11437}
11438
11440inline civector operator+(const civector& v1, const simatrix_subv& v2) {
11441 return v1 + sivector(v2);
11442}
11443
11445inline civector operator+(const civector& v1, const scimatrix_subv& v2) {
11446 return v1 + scivector(v2);
11447}
11448
11450inline civector operator+(const rvector& v1, const scimatrix_subv& v2) {
11451 return v1 + scivector(v2);
11452}
11453
11455inline civector operator+(const cvector& v1, const scimatrix_subv& v2) {
11456 return v1 + scivector(v2);
11457}
11458
11460inline civector operator+(const ivector& v1, const scimatrix_subv& v2) {
11461 return v1 + scivector(v2);
11462}
11463
11465inline civector operator+(const ivector& v1, const scmatrix_subv& v2) {
11466 return v1 + scvector(v2);
11467}
11468
11470inline civector operator+(const cvector& v1, const simatrix_subv& v2) {
11471 return v1 + sivector(v2);
11472}
11473
11475inline civector operator+(const civector_slice& v1, const srmatrix_subv& v2) {
11476 return v1 + srvector(v2);
11477}
11478
11480inline civector operator+(const civector_slice& v1, const scmatrix_subv& v2) {
11481 return v1 + scvector(v2);
11482}
11483
11485inline civector operator+(const civector_slice& v1, const simatrix_subv& v2) {
11486 return v1 + sivector(v2);
11487}
11488
11490inline civector operator+(const civector_slice& v1, const scimatrix_subv& v2) {
11491 return v1 + scivector(v2);
11492}
11493
11495inline civector operator+(const rvector_slice& v1, const scimatrix_subv& v2) {
11496 return v1 + scivector(v2);
11497}
11498
11500inline civector operator+(const cvector_slice& v1, const scimatrix_subv& v2) {
11501 return v1 + scivector(v2);
11502}
11503
11505inline civector operator+(const ivector_slice& v1, const scimatrix_subv& v2) {
11506 return v1 + scivector(v2);
11507}
11508
11510inline civector operator+(const ivector_slice& v1, const scmatrix_subv& v2) {
11511 return v1 + scvector(v2);
11512}
11513
11515inline civector operator+(const cvector_slice& v1, const simatrix_subv& v2) {
11516 return v1 + sivector(v2);
11517}
11518
11520inline scivector operator-(const scimatrix_subv& v1, const srvector& v2) {
11521 return scivector(v1) - v2;
11522}
11523
11525inline scivector operator-(const scimatrix_subv& v1, const scvector& v2) {
11526 return scivector(v1) - v2;
11527}
11528
11530inline scivector operator-(const scimatrix_subv& v1, const sivector& v2) {
11531 return scivector(v1) - v2;
11532}
11533
11535inline scivector operator-(const scimatrix_subv& v1, const scivector& v2) {
11536 return scivector(v1) - v2;
11537}
11538
11540inline scivector operator-(const srmatrix_subv& v1, const scivector& v2) {
11541 return srvector(v1) - v2;
11542}
11543
11545inline scivector operator-(const scmatrix_subv& v1, const scivector& v2) {
11546 return scvector(v1) - v2;
11547}
11548
11550inline scivector operator-(const simatrix_subv& v1, const scivector& v2) {
11551 return sivector(v1) - v2;
11552}
11553
11555inline scivector operator-(const scmatrix_subv& v1, const sivector& v2) {
11556 return scvector(v1) - v2;
11557}
11558
11560inline scivector operator-(const simatrix_subv& v1, const scvector& v2) {
11561 return sivector(v1) - v2;
11562}
11563
11565inline scivector operator-(const scimatrix_subv& v1, const srvector_slice& v2) {
11566 return scivector(v1) - v2;
11567}
11568
11570inline scivector operator-(const scimatrix_subv& v1, const scvector_slice& v2) {
11571 return scivector(v1) - v2;
11572}
11573
11575inline scivector operator-(const scimatrix_subv& v1, const sivector_slice& v2) {
11576 return scivector(v1) - v2;
11577}
11578
11580inline scivector operator-(const scimatrix_subv& v1, const scivector_slice& v2) {
11581 return scivector(v1) - v2;
11582}
11583
11585inline scivector operator-(const srmatrix_subv& v1, const scivector_slice& v2) {
11586 return srvector(v1) - v2;
11587}
11588
11590inline scivector operator-(const scmatrix_subv& v1, const scivector_slice& v2) {
11591 return scvector(v1) - v2;
11592}
11593
11595inline scivector operator-(const simatrix_subv& v1, const scivector_slice& v2) {
11596 return sivector(v1) - v2;
11597}
11598
11600inline scivector operator-(const simatrix_subv& v1, const scvector_slice& v2) {
11601 return sivector(v1) - v2;
11602}
11603
11605inline scivector operator-(const scmatrix_subv& v1, const sivector_slice& v2) {
11606 return scvector(v1) - v2;
11607}
11608
11610inline civector operator-(const scimatrix_subv& v1, const rvector& v2) {
11611 return scivector(v1) - v2;
11612}
11613
11615inline civector operator-(const scimatrix_subv& v1, const cvector& v2) {
11616 return scivector(v1) - v2;
11617}
11618
11620inline civector operator-(const scimatrix_subv& v1, const ivector& v2) {
11621 return scivector(v1) - v2;
11622}
11623
11625inline civector operator-(const scimatrix_subv& v1, const civector& v2) {
11626 return scivector(v1) - v2;
11627}
11628
11630inline civector operator-(const srmatrix_subv& v1, const civector& v2) {
11631 return srvector(v1) - v2;
11632}
11633
11635inline civector operator-(const simatrix_subv& v1, const civector& v2) {
11636 return sivector(v1) - v2;
11637}
11638
11640inline civector operator-(const scmatrix_subv& v1, const civector& v2) {
11641 return scvector(v1) - v2;
11642}
11643
11645inline civector operator-(const scmatrix_subv& v1, const ivector& v2) {
11646 return scvector(v1) - v2;
11647}
11648
11650inline civector operator-(const simatrix_subv& v1, const cvector& v2) {
11651 return sivector(v1) - v2;
11652}
11653
11655inline civector operator-(const scimatrix_subv& v1, const rvector_slice& v2) {
11656 return scivector(v1) - v2;
11657}
11658
11660inline civector operator-(const scimatrix_subv& v1, const cvector_slice& v2) {
11661 return scivector(v1) - v2;
11662}
11663
11665inline civector operator-(const scimatrix_subv& v1, const ivector_slice& v2) {
11666 return scivector(v1) - v2;
11667}
11668
11670inline civector operator-(const scimatrix_subv& v1, const civector_slice& v2) {
11671 return scivector(v1) - v2;
11672}
11673
11675inline civector operator-(const srmatrix_subv& v1, const civector_slice& v2) {
11676 return srvector(v1) - v2;
11677}
11678
11680inline civector operator-(const scmatrix_subv& v1, const civector_slice& v2) {
11681 return scvector(v1) - v2;
11682}
11683
11685inline civector operator-(const simatrix_subv& v1, const civector_slice& v2) {
11686 return sivector(v1) - v2;
11687}
11688
11690inline civector operator-(const simatrix_subv& v1, const cvector_slice& v2) {
11691 return sivector(v1) - v2;
11692}
11693
11695inline civector operator-(const scmatrix_subv& v1, const ivector_slice& v2) {
11696 return scvector(v1) - v2;
11697}
11698
11700inline scivector operator-(const scivector& v1, const srmatrix_subv& v2) {
11701 return v1 - srvector(v2);
11702}
11703
11705inline scivector operator-(const scivector& v1, const scmatrix_subv& v2) {
11706 return v1 - scvector(v2);
11707}
11708
11710inline scivector operator-(const scivector& v1, const simatrix_subv& v2) {
11711 return v1 - sivector(v2);
11712}
11713
11715inline scivector operator-(const scivector& v1, const scimatrix_subv& v2) {
11716 return v1 - scivector(v2);
11717}
11718
11720inline scivector operator-(const srvector& v1, const scimatrix_subv& v2) {
11721 return v1 - scivector(v2);
11722}
11723
11725inline scivector operator-(const scvector& v1, const scimatrix_subv& v2) {
11726 return v1 - scivector(v2);
11727}
11728
11730inline scivector operator-(const sivector& v1, const scimatrix_subv& v2) {
11731 return v1 - scivector(v2);
11732}
11733
11735inline scivector operator-(const sivector& v1, const scmatrix_subv& v2) {
11736 return v1 - scvector(v2);
11737}
11738
11740inline scivector operator-(const scvector& v1, const simatrix_subv& v2) {
11741 return v1 - sivector(v2);
11742}
11743
11745inline scivector operator-(const scivector_slice& v1, const srmatrix_subv& v2) {
11746 return v1 - srvector(v2);
11747}
11748
11750inline scivector operator-(const scivector_slice& v1, const scmatrix_subv& v2) {
11751 return v1 - scvector(v2);
11752}
11753
11755inline scivector operator-(const scivector_slice& v1, const simatrix_subv& v2) {
11756 return v1 - sivector(v2);
11757}
11758
11760inline scivector operator-(const scivector_slice& v1, const scimatrix_subv& v2) {
11761 return v1 - scivector(v2);
11762}
11763
11765inline scivector operator-(const srvector_slice& v1, const scimatrix_subv& v2) {
11766 return v1 - scivector(v2);
11767}
11768
11770inline scivector operator-(const scvector_slice& v1, const scimatrix_subv& v2) {
11771 return v1 - scivector(v2);
11772}
11773
11775inline scivector operator-(const sivector_slice& v1, const scimatrix_subv& v2) {
11776 return v1 - scivector(v2);
11777}
11778
11780inline scivector operator-(const sivector_slice& v1, const scmatrix_subv& v2) {
11781 return v1 - scvector(v2);
11782}
11783
11785inline scivector operator-(const scvector_slice& v1, const simatrix_subv& v2) {
11786 return v1 - sivector(v2);
11787}
11788
11790inline civector operator-(const civector& v1, const srmatrix_subv& v2) {
11791 return v1 - srvector(v2);
11792}
11793
11795inline civector operator-(const civector& v1, const scmatrix_subv& v2) {
11796 return v1 - scvector(v2);
11797}
11798
11800inline civector operator-(const civector& v1, const simatrix_subv& v2) {
11801 return v1 - sivector(v2);
11802}
11803
11805inline civector operator-(const civector& v1, const scimatrix_subv& v2) {
11806 return v1 - scivector(v2);
11807}
11808
11810inline civector operator-(const rvector& v1, const scimatrix_subv& v2) {
11811 return v1 - scivector(v2);
11812}
11813
11815inline civector operator-(const cvector& v1, const scimatrix_subv& v2) {
11816 return v1 - scivector(v2);
11817}
11818
11820inline civector operator-(const ivector& v1, const scimatrix_subv& v2) {
11821 return v1 - scivector(v2);
11822}
11823
11825inline civector operator-(const ivector& v1, const scmatrix_subv& v2) {
11826 return v1 - scvector(v2);
11827}
11828
11830inline civector operator-(const cvector& v1, const simatrix_subv& v2) {
11831 return v1 - sivector(v2);
11832}
11833
11835inline civector operator-(const civector_slice& v1, const srmatrix_subv& v2) {
11836 return v1 - srvector(v2);
11837}
11838
11840inline civector operator-(const civector_slice& v1, const scmatrix_subv& v2) {
11841 return v1 - scvector(v2);
11842}
11843
11845inline civector operator-(const civector_slice& v1, const simatrix_subv& v2) {
11846 return v1 - sivector(v2);
11847}
11848
11850inline civector operator-(const civector_slice& v1, const scimatrix_subv& v2) {
11851 return v1 - scivector(v2);
11852}
11853
11855inline civector operator-(const rvector_slice& v1, const scimatrix_subv& v2) {
11856 return v1 - scivector(v2);
11857}
11858
11860inline civector operator-(const cvector_slice& v1, const scimatrix_subv& v2) {
11861 return v1 - scivector(v2);
11862}
11863
11865inline civector operator-(const ivector_slice& v1, const scimatrix_subv& v2) {
11866 return v1 - scivector(v2);
11867}
11868
11870inline civector operator-(const ivector_slice& v1, const scmatrix_subv& v2) {
11871 return v1 - scvector(v2);
11872}
11873
11875inline civector operator-(const cvector_slice& v1, const simatrix_subv& v2) {
11876 return v1 - sivector(v2);
11877}
11878
11880inline scivector operator|(const scimatrix_subv& v1, const srvector& v2) {
11881 return scivector(v1) | v2;
11882}
11883
11885inline scivector operator|(const scimatrix_subv& v1, const scvector& v2) {
11886 return scivector(v1) | v2;
11887}
11888
11890inline scivector operator|(const scimatrix_subv& v1, const sivector& v2) {
11891 return scivector(v1) | v2;
11892}
11893
11895inline scivector operator|(const scimatrix_subv& v1, const scivector& v2) {
11896 return scivector(v1) | v2;
11897}
11898
11900inline scivector operator|(const srmatrix_subv& v1, const scivector& v2) {
11901 return srvector(v1) | v2;
11902}
11903
11905inline scivector operator|(const scmatrix_subv& v1, const scivector& v2) {
11906 return scvector(v1) | v2;
11907}
11908
11910inline scivector operator|(const simatrix_subv& v1, const scivector& v2) {
11911 return sivector(v1) | v2;
11912}
11913
11915inline scivector operator|(const scmatrix_subv& v1, const sivector& v2) {
11916 return scvector(v1) | v2;
11917}
11918
11920inline scivector operator|(const simatrix_subv& v1, const scvector& v2) {
11921 return sivector(v1) | v2;
11922}
11923
11925inline scivector operator|(const scimatrix_subv& v1, const srvector_slice& v2) {
11926 return scivector(v1) | v2;
11927}
11928
11930inline scivector operator|(const scimatrix_subv& v1, const scvector_slice& v2) {
11931 return scivector(v1) | v2;
11932}
11933
11935inline scivector operator|(const scimatrix_subv& v1, const sivector_slice& v2) {
11936 return scivector(v1) | v2;
11937}
11938
11940inline scivector operator|(const scimatrix_subv& v1, const scivector_slice& v2) {
11941 return scivector(v1) | v2;
11942}
11943
11945inline scivector operator|(const srmatrix_subv& v1, const scivector_slice& v2) {
11946 return srvector(v1) | v2;
11947}
11948
11950inline scivector operator|(const scmatrix_subv& v1, const scivector_slice& v2) {
11951 return scvector(v1) | v2;
11952}
11953
11955inline scivector operator|(const simatrix_subv& v1, const scivector_slice& v2) {
11956 return sivector(v1) | v2;
11957}
11958
11960inline scivector operator|(const simatrix_subv& v1, const scvector_slice& v2) {
11961 return sivector(v1) | v2;
11962}
11963
11965inline scivector operator|(const scmatrix_subv& v1, const sivector_slice& v2) {
11966 return scvector(v1) | v2;
11967}
11968
11970inline civector operator|(const scimatrix_subv& v1, const rvector& v2) {
11971 return scivector(v1) | v2;
11972}
11973
11975inline civector operator|(const scimatrix_subv& v1, const cvector& v2) {
11976 return scivector(v1) | v2;
11977}
11978
11980inline civector operator|(const scimatrix_subv& v1, const ivector& v2) {
11981 return scivector(v1) | v2;
11982}
11983
11985inline civector operator|(const scimatrix_subv& v1, const civector& v2) {
11986 return scivector(v1) | v2;
11987}
11988
11990inline civector operator|(const srmatrix_subv& v1, const civector& v2) {
11991 return srvector(v1) | v2;
11992}
11993
11995inline civector operator|(const simatrix_subv& v1, const civector& v2) {
11996 return sivector(v1) | v2;
11997}
11998
12000inline civector operator|(const scmatrix_subv& v1, const civector& v2) {
12001 return scvector(v1) | v2;
12002}
12003
12005inline civector operator|(const scmatrix_subv& v1, const ivector& v2) {
12006 return scvector(v1) | v2;
12007}
12008
12010inline civector operator|(const simatrix_subv& v1, const cvector& v2) {
12011 return sivector(v1) | v2;
12012}
12013
12015inline civector operator|(const scimatrix_subv& v1, const rvector_slice& v2) {
12016 return scivector(v1) | v2;
12017}
12018
12020inline civector operator|(const scimatrix_subv& v1, const cvector_slice& v2) {
12021 return scivector(v1) | v2;
12022}
12023
12025inline civector operator|(const scimatrix_subv& v1, const ivector_slice& v2) {
12026 return scivector(v1) | v2;
12027}
12028
12030inline civector operator|(const scimatrix_subv& v1, const civector_slice& v2) {
12031 return scivector(v1) | v2;
12032}
12033
12035inline civector operator|(const srmatrix_subv& v1, const civector_slice& v2) {
12036 return srvector(v1) | v2;
12037}
12038
12040inline civector operator|(const scmatrix_subv& v1, const civector_slice& v2) {
12041 return scvector(v1) | v2;
12042}
12043
12045inline civector operator|(const simatrix_subv& v1, const civector_slice& v2) {
12046 return sivector(v1) | v2;
12047}
12048
12050inline civector operator|(const simatrix_subv& v1, const cvector_slice& v2) {
12051 return sivector(v1) | v2;
12052}
12053
12055inline civector operator|(const scmatrix_subv& v1, const ivector_slice& v2) {
12056 return scvector(v1) | v2;
12057}
12058
12060inline scivector operator|(const scivector& v1, const srmatrix_subv& v2) {
12061 return v1 | srvector(v2);
12062}
12063
12065inline scivector operator|(const scivector& v1, const scmatrix_subv& v2) {
12066 return v1 | scvector(v2);
12067}
12068
12070inline scivector operator|(const scivector& v1, const simatrix_subv& v2) {
12071 return v1 | sivector(v2);
12072}
12073
12075inline scivector operator|(const scivector& v1, const scimatrix_subv& v2) {
12076 return v1 | scivector(v2);
12077}
12078
12080inline scivector operator|(const srvector& v1, const scimatrix_subv& v2) {
12081 return v1 | scivector(v2);
12082}
12083
12085inline scivector operator|(const scvector& v1, const scimatrix_subv& v2) {
12086 return v1 | scivector(v2);
12087}
12088
12090inline scivector operator|(const sivector& v1, const scimatrix_subv& v2) {
12091 return v1 | scivector(v2);
12092}
12093
12095inline scivector operator|(const sivector& v1, const scmatrix_subv& v2) {
12096 return v1 | scvector(v2);
12097}
12098
12100inline scivector operator|(const scvector& v1, const simatrix_subv& v2) {
12101 return v1 | sivector(v2);
12102}
12103
12105inline scivector operator|(const scivector_slice& v1, const srmatrix_subv& v2) {
12106 return v1 | srvector(v2);
12107}
12108
12110inline scivector operator|(const scivector_slice& v1, const scmatrix_subv& v2) {
12111 return v1 | scvector(v2);
12112}
12113
12115inline scivector operator|(const scivector_slice& v1, const simatrix_subv& v2) {
12116 return v1 | sivector(v2);
12117}
12118
12120inline scivector operator|(const scivector_slice& v1, const scimatrix_subv& v2) {
12121 return v1 | scivector(v2);
12122}
12123
12125inline scivector operator|(const srvector_slice& v1, const scimatrix_subv& v2) {
12126 return v1 | scivector(v2);
12127}
12128
12130inline scivector operator|(const scvector_slice& v1, const scimatrix_subv& v2) {
12131 return v1 | scivector(v2);
12132}
12133
12135inline scivector operator|(const sivector_slice& v1, const scimatrix_subv& v2) {
12136 return v1 | scivector(v2);
12137}
12138
12140inline scivector operator|(const sivector_slice& v1, const scmatrix_subv& v2) {
12141 return v1 | scvector(v2);
12142}
12143
12145inline scivector operator|(const scvector_slice& v1, const simatrix_subv& v2) {
12146 return v1 | sivector(v2);
12147}
12148
12150inline civector operator|(const civector& v1, const srmatrix_subv& v2) {
12151 return v1 | srvector(v2);
12152}
12153
12155inline civector operator|(const civector& v1, const scmatrix_subv& v2) {
12156 return v1 | scvector(v2);
12157}
12158
12160inline civector operator|(const civector& v1, const simatrix_subv& v2) {
12161 return v1 | sivector(v2);
12162}
12163
12165inline civector operator|(const civector& v1, const scimatrix_subv& v2) {
12166 return v1 | scivector(v2);
12167}
12168
12170inline civector operator|(const rvector& v1, const scimatrix_subv& v2) {
12171 return v1 | scivector(v2);
12172}
12173
12175inline civector operator|(const cvector& v1, const scimatrix_subv& v2) {
12176 return v1 | scivector(v2);
12177}
12178
12180inline civector operator|(const ivector& v1, const scimatrix_subv& v2) {
12181 return v1 | scivector(v2);
12182}
12183
12185inline civector operator|(const ivector& v1, const scmatrix_subv& v2) {
12186 return v1 | scvector(v2);
12187}
12188
12190inline civector operator|(const cvector& v1, const simatrix_subv& v2) {
12191 return v1 | sivector(v2);
12192}
12193
12195inline civector operator|(const civector_slice& v1, const srmatrix_subv& v2) {
12196 return v1 | srvector(v2);
12197}
12198
12200inline civector operator|(const civector_slice& v1, const scmatrix_subv& v2) {
12201 return v1 | scvector(v2);
12202}
12203
12205inline civector operator|(const civector_slice& v1, const simatrix_subv& v2) {
12206 return v1 | sivector(v2);
12207}
12208
12210inline civector operator|(const civector_slice& v1, const scimatrix_subv& v2) {
12211 return v1 | scivector(v2);
12212}
12213
12215inline civector operator|(const rvector_slice& v1, const scimatrix_subv& v2) {
12216 return v1 | scivector(v2);
12217}
12218
12220inline civector operator|(const cvector_slice& v1, const scimatrix_subv& v2) {
12221 return v1 | scivector(v2);
12222}
12223
12225inline civector operator|(const ivector_slice& v1, const scimatrix_subv& v2) {
12226 return v1 | scivector(v2);
12227}
12228
12230inline civector operator|(const ivector_slice& v1, const scmatrix_subv& v2) {
12231 return v1 | scvector(v2);
12232}
12233
12235inline civector operator|(const cvector_slice& v1, const simatrix_subv& v2) {
12236 return v1 | sivector(v2);
12237}
12238
12240inline scivector operator|(const scmatrix_subv& v1, const srvector& v2) {
12241 return scvector(v1) | v2;
12242}
12243
12245inline scivector operator|(const srmatrix_subv& v1, const scvector& v2) {
12246 return srvector(v1) | v2;
12247}
12248
12250inline scivector operator|(const scmatrix_subv& v1, const scvector& v2) {
12251 return scvector(v1) | v2;
12252}
12253
12255inline scivector operator|(const scmatrix_subv& v1, const srvector_slice& v2) {
12256 return scvector(v1) | v2;
12257}
12258
12260inline scivector operator|(const srmatrix_subv& v1, const scvector_slice& v2) {
12261 return srvector(v1) | v2;
12262}
12263
12265inline scivector operator|(const scmatrix_subv& v1, const scvector_slice& v2) {
12266 return scvector(v1) | v2;
12267}
12268
12270inline civector operator|(const scmatrix_subv& v1, const rvector& v2) {
12271 return scvector(v1) | v2;
12272}
12273
12275inline civector operator|(const srmatrix_subv& v1, const cvector& v2) {
12276 return srvector(v1) | v2;
12277}
12278
12280inline civector operator|(const scmatrix_subv& v1, const cvector& v2) {
12281 return scvector(v1) | v2;
12282}
12283
12285inline civector operator|(const scmatrix_subv& v1, const rvector_slice& v2) {
12286 return scvector(v1) | v2;
12287}
12288
12290inline civector operator|(const srmatrix_subv& v1, const cvector_slice& v2) {
12291 return srvector(v1) | v2;
12292}
12293
12295inline civector operator|(const scmatrix_subv& v1, const cvector_slice& v2) {
12296 return scvector(v1) | v2;
12297}
12298
12300inline scivector operator|(const scvector& v1, const srmatrix_subv& v2) {
12301 return v1 | srvector(v2);
12302}
12303
12305inline scivector operator|(const srvector& v1, const scmatrix_subv& v2) {
12306 return v1 | scvector(v2);
12307}
12308
12310inline scivector operator|(const scvector& v1, const scmatrix_subv& v2) {
12311 return v1 | scvector(v2);
12312}
12313
12315inline scivector operator|(const scvector_slice& v1, const srmatrix_subv& v2) {
12316 return v1 | srvector(v2);
12317}
12318
12320inline scivector operator|(const srvector_slice& v1, const scmatrix_subv& v2) {
12321 return v1 | scvector(v2);
12322}
12323
12325inline scivector operator|(const scvector_slice& v1, const scmatrix_subv& v2) {
12326 return v1 | scvector(v2);
12327}
12328
12330inline civector operator|(const cvector& v1, const srmatrix_subv& v2) {
12331 return v1 | srvector(v2);
12332}
12333
12335inline civector operator|(const rvector& v1, const scmatrix_subv& v2) {
12336 return v1 | scvector(v2);
12337}
12338
12340inline civector operator|(const cvector& v1, const scmatrix_subv& v2) {
12341 return v1 | scvector(v2);
12342}
12343
12345inline civector operator|(const cvector_slice& v1, const srmatrix_subv& v2) {
12346 return v1 | srvector(v2);
12347}
12348
12350inline civector operator|(const rvector_slice& v1, const scmatrix_subv& v2) {
12351 return v1 | scvector(v2);
12352}
12353
12355inline civector operator|(const cvector_slice& v1, const scmatrix_subv& v2) {
12356 return v1 | scvector(v2);
12357}
12358
12360 *this = *this * v;
12361 return *this;
12362}
12363
12365 *this = *this * v;
12366 return *this;
12367}
12368
12370 *this = *this * v;
12371 return *this;
12372}
12373
12375 *this = *this * v;
12376 return *this;
12377}
12378
12380 *this = *this / v;
12381 return *this;
12382}
12383
12385 *this = *this / v;
12386 return *this;
12387}
12388
12390 *this = *this / v;
12391 return *this;
12392}
12393
12395 *this = *this / v;
12396 return *this;
12397}
12398
12400 *this = *this + v;
12401 return *this;
12402}
12403
12405 *this = *this + v;
12406 return *this;
12407}
12408
12410 *this = *this + v;
12411 return *this;
12412}
12413
12415 *this = *this + v;
12416 return *this;
12417}
12418
12420 *this = *this - v;
12421 return *this;
12422}
12423
12425 *this = *this - v;
12426 return *this;
12427}
12428
12430 *this = *this - v;
12431 return *this;
12432}
12433
12435 *this = *this - v;
12436 return *this;
12437}
12438
12440 *this = *this + v;
12441 return *this;
12442}
12443
12445 *this = *this + v;
12446 return *this;
12447}
12448
12450 *this = *this + v;
12451 return *this;
12452}
12453
12455 *this = *this + v;
12456 return *this;
12457}
12458
12460 *this = *this - v;
12461 return *this;
12462}
12463
12465 *this = *this - v;
12466 return *this;
12467}
12468
12470 *this = *this - v;
12471 return *this;
12472}
12473
12475 *this = *this - v;
12476 return *this;
12477}
12478
12480 *this = *this + v;
12481 return *this;
12482}
12483
12485 *this = *this + v;
12486 return *this;
12487}
12488
12490 *this = *this + v;
12491 return *this;
12492}
12493
12495 *this = *this + v;
12496 return *this;
12497}
12498
12500 *this = *this - v;
12501 return *this;
12502}
12503
12505 *this = *this - v;
12506 return *this;
12507}
12508
12510 *this = *this - v;
12511 return *this;
12512}
12513
12515 *this = *this - v;
12516 return *this;
12517}
12518
12520 *this = *this + v;
12521 return *this;
12522}
12523
12525 *this = *this + v;
12526 return *this;
12527}
12528
12530 *this = *this + v;
12531 return *this;
12532}
12533
12535 *this = *this + v;
12536 return *this;
12537}
12538
12540 *this = *this - v;
12541 return *this;
12542}
12543
12545 *this = *this - v;
12546 return *this;
12547}
12548
12550 *this = *this - v;
12551 return *this;
12552}
12553
12555 *this = *this - v;
12556 return *this;
12557}
12558
12560 *this = *this | v;
12561 return *this;
12562}
12563
12565 *this = *this | v;
12566 return *this;
12567}
12568
12570 *this = *this | v;
12571 return *this;
12572}
12573
12575 *this = *this | v;
12576 return *this;
12577}
12578
12580 *this = *this | v;
12581 return *this;
12582}
12583
12585 *this = *this | v;
12586 return *this;
12587}
12588
12590 *this = *this | v;
12591 return *this;
12592}
12593
12595 *this = *this | v;
12596 return *this;
12597}
12598
12600 *this = *this | v;
12601 return *this;
12602}
12603
12605 *this = *this | v;
12606 return *this;
12607}
12608
12610 *this = *this | v;
12611 return *this;
12612}
12613
12615 *this = *this | v;
12616 return *this;
12617}
12618
12620 *this = *this | v;
12621 return *this;
12622}
12623
12625 *this = *this | v;
12626 return *this;
12627}
12628
12630 *this = *this | v;
12631 return *this;
12632}
12633
12635 *this = *this | v;
12636 return *this;
12637}
12638
12640 *this += rvector(v);
12641 return *this;
12642}
12643
12645 *this += cvector(v);
12646 return *this;
12647}
12648
12650 *this += ivector(v);
12651 return *this;
12652}
12653
12655 *this += civector(v);
12656 return *this;
12657}
12658
12660 *this += rvector(v);
12661 return *this;
12662}
12663
12665 *this += cvector(v);
12666 return *this;
12667}
12668
12670 *this += ivector(v);
12671 return *this;
12672}
12673
12675 *this += civector(v);
12676 return *this;
12677}
12678
12680 *this += rvector(v);
12681 return *this;
12682}
12683
12685 *this += cvector(v);
12686 return *this;
12687}
12688
12690 *this += ivector(v);
12691 return *this;
12692}
12693
12695 *this += civector(v);
12696 return *this;
12697}
12698
12700 *this -= rvector(v);
12701 return *this;
12702}
12703
12705 *this -= cvector(v);
12706 return *this;
12707}
12708
12710 *this -= ivector(v);
12711 return *this;
12712}
12713
12715 *this -= civector(v);
12716 return *this;
12717}
12718
12720 *this -= rvector(v);
12721 return *this;
12722}
12723
12725 *this -= cvector(v);
12726 return *this;
12727}
12728
12730 *this -= ivector(v);
12731 return *this;
12732}
12733
12735 *this -= civector(v);
12736 return *this;
12737}
12738
12740 *this -= rvector(v);
12741 return *this;
12742}
12743
12745 *this -= cvector(v);
12746 return *this;
12747}
12748
12750 *this -= ivector(v);
12751 return *this;
12752}
12753
12755 *this -= civector(v);
12756 return *this;
12757}
12758
12760 *this |= rvector(v);
12761 return *this;
12762}
12763
12765 *this |= cvector(v);
12766 return *this;
12767}
12768
12770 *this |= ivector(v);
12771 return *this;
12772}
12773
12775 *this |= civector(v);
12776 return *this;
12777}
12778
12780 *this |= rvector(v);
12781 return *this;
12782}
12783
12785 *this |= cvector(v);
12786 return *this;
12787}
12788
12790 *this |= ivector(v);
12791 return *this;
12792}
12793
12795 *this |= civector(v);
12796 return *this;
12797}
12798
12800 *this |= rvector(v);
12801 return *this;
12802}
12803
12805 *this |= cvector(v);
12806 return *this;
12807}
12808
12810 *this |= ivector(v);
12811 return *this;
12812}
12813
12815 *this |= civector(v);
12816 return *this;
12817}
12818
12820 *this = rvector(v);
12821 return *this;
12822}
12823
12825 *this = cvector(v);
12826 return *this;
12827}
12828
12830 *this = ivector(v);
12831 return *this;
12832}
12833
12835 *this = civector(v);
12836 return *this;
12837}
12838
12840 *this = rvector(v);
12841 return *this;
12842}
12843
12845 *this = cvector(v);
12846 return *this;
12847}
12848
12850 *this = ivector(v);
12851 return *this;
12852}
12853
12855 *this = civector(v);
12856 return *this;
12857}
12858
12860 *this = rvector(v);
12861 return *this;
12862}
12863
12865 *this = ivector(v);
12866 return *this;
12867}
12868
12870 *this = cvector(v);
12871 return *this;
12872}
12873
12875 *this = civector(v);
12876 return *this;
12877}
12878
12880 *this &= ivector(v);
12881 return *this;
12882}
12883
12885 *this &= civector(v);
12886 return *this;
12887}
12888
12890 *this &= ivector(v);
12891 return *this;
12892}
12893
12895 *this &= civector(v);
12896 return *this;
12897}
12898
12900 *this &= ivector(v);
12901 return *this;
12902}
12903
12905 *this &= civector(v);
12906 return *this;
12907}
12908
12910inline bool operator==(const scimatrix_subv& v1, const srvector& v2) {
12911 return scivector(v1) == v2;
12912}
12913
12915inline bool operator==(const scimatrix_subv& v1, const scvector& v2) {
12916 return scivector(v1) == v2;
12917}
12918
12920inline bool operator==(const scimatrix_subv& v1, const sivector& v2) {
12921 return scivector(v1) == v2;
12922}
12923
12925inline bool operator==(const scimatrix_subv& v1, const scivector& v2) {
12926 return scivector(v1) == v2;
12927}
12928
12930inline bool operator==(const srmatrix_subv& v1, const scivector& v2) {
12931 return srvector(v1) == v2;
12932}
12933
12935inline bool operator==(const scmatrix_subv& v1, const scivector& v2) {
12936 return scvector(v1) == v2;
12937}
12938
12940inline bool operator==(const simatrix_subv& v1, const scivector& v2) {
12941 return sivector(v1) == v2;
12942}
12943
12945inline bool operator==(const scimatrix_subv& v1, const srvector_slice& v2) {
12946 return scivector(v1) == v2;
12947}
12948
12950inline bool operator==(const scimatrix_subv& v1, const sivector_slice& v2) {
12951 return scivector(v1) == v2;
12952}
12953
12955inline bool operator==(const scimatrix_subv& v1, const scvector_slice& v2) {
12956 return scivector(v1) == v2;
12957}
12958
12960inline bool operator==(const scimatrix_subv& v1, const scivector_slice& v2) {
12961 return scivector(v1) == v2;
12962}
12963
12965inline bool operator==(const srmatrix_subv& v1, const scivector_slice& v2) {
12966 return srvector(v1) == v2;
12967}
12968
12970inline bool operator==(const scmatrix_subv& v1, const scivector_slice& v2) {
12971 return scvector(v1) == v2;
12972}
12973
12975inline bool operator==(const simatrix_subv& v1, const scivector_slice& v2) {
12976 return sivector(v1) == v2;
12977}
12978
12980inline bool operator==(const scimatrix_subv& v1, const rvector& v2) {
12981 return scivector(v1) == v2;
12982}
12983
12985inline bool operator==(const scimatrix_subv& v1, const cvector& v2) {
12986 return scivector(v1) == v2;
12987}
12988
12990inline bool operator==(const scimatrix_subv& v1, const ivector& v2) {
12991 return scivector(v1) == v2;
12992}
12993
12995inline bool operator==(const scimatrix_subv& v1, const civector& v2) {
12996 return scivector(v1) == v2;
12997}
12998
13000inline bool operator==(const srmatrix_subv& v1, const civector& v2) {
13001 return srvector(v1) == v2;
13002}
13003
13005inline bool operator==(const simatrix_subv& v1, const civector& v2) {
13006 return sivector(v1) == v2;
13007}
13008
13010inline bool operator==(const scmatrix_subv& v1, const civector& v2) {
13011 return scivector(v1) == v2;
13012}
13013
13015inline bool operator==(const scimatrix_subv& v1, const rvector_slice& v2) {
13016 return scivector(v1) == v2;
13017}
13018
13020inline bool operator==(const scimatrix_subv& v1, const cvector_slice& v2) {
13021 return scivector(v1) == v2;
13022}
13023
13025inline bool operator==(const scimatrix_subv& v1, const ivector_slice& v2) {
13026 return scivector(v1) == v2;
13027}
13028
13030inline bool operator==(const scimatrix_subv& v1, const civector_slice& v2) {
13031 return scivector(v1) == v2;
13032}
13033
13035inline bool operator==(const srmatrix_subv& v1, const civector_slice& v2) {
13036 return srvector(v1) == v2;
13037}
13038
13040inline bool operator==(const scmatrix_subv& v1, const civector_slice& v2) {
13041 return scivector(v1) == v2;
13042}
13043
13045inline bool operator==(const simatrix_subv& v1, const civector_slice& v2) {
13046 return scivector(v1) == v2;
13047}
13048
13050inline bool operator==(const scivector& v1, const srmatrix_subv& v2) {
13051 return v1 == srvector(v2);
13052}
13053
13055inline bool operator==(const scivector& v1, const scmatrix_subv& v2) {
13056 return v1 == scvector(v2);
13057}
13058
13060inline bool operator==(const scivector& v1, const simatrix_subv& v2) {
13061 return v1 == sivector(v2);
13062}
13063
13065inline bool operator==(const scivector& v1, const scimatrix_subv& v2) {
13066 return v1 == scivector(v2);
13067}
13068
13070inline bool operator==(const srvector& v1, const scimatrix_subv& v2) {
13071 return v1 == scivector(v2);
13072}
13073
13075inline bool operator==(const scvector& v1, const scimatrix_subv& v2) {
13076 return v1 == scivector(v2);
13077}
13078
13080inline bool operator==(const sivector& v1, const scimatrix_subv& v2) {
13081 return v1 == scivector(v2);
13082}
13083
13085inline bool operator==(const scivector_slice& v1, const srmatrix_subv& v2) {
13086 return v1 == srvector(v2);
13087}
13088
13090inline bool operator==(const scivector_slice& v1, const simatrix_subv& v2) {
13091 return v1 == sivector(v2);
13092}
13093
13095inline bool operator==(const scivector_slice& v1, const scmatrix_subv& v2) {
13096 return v1 == scvector(v2);
13097}
13098
13100inline bool operator==(const scivector_slice& v1, const scimatrix_subv& v2) {
13101 return v1 == scivector(v2);
13102}
13103
13105inline bool operator==(const srvector_slice& v1, const scimatrix_subv& v2) {
13106 return v1 == scivector(v2);
13107}
13108
13110inline bool operator==(const scvector_slice& v1, const scimatrix_subv& v2) {
13111 return v1 == scivector(v2);
13112}
13113
13115inline bool operator==(const sivector_slice& v1, const scimatrix_subv& v2) {
13116 return v1 == scivector(v2);
13117}
13118
13120inline bool operator==(const civector& v1, const srmatrix_subv& v2) {
13121 return v1 == srvector(v2);
13122}
13123
13125inline bool operator==(const civector& v1, const simatrix_subv& v2) {
13126 return v1 == sivector(v2);
13127}
13128
13130inline bool operator==(const civector& v1, const scmatrix_subv& v2) {
13131 return v1 == scvector(v2);
13132}
13133
13135inline bool operator==(const civector& v1, const scimatrix_subv& v2) {
13136 return v1 == scivector(v2);
13137}
13138
13140inline bool operator==(const rvector& v1, const scimatrix_subv& v2) {
13141 return v1 == scivector(v2);
13142}
13143
13145inline bool operator==(const cvector& v1, const scimatrix_subv& v2) {
13146 return v1 == scivector(v2);
13147}
13148
13150inline bool operator==(const ivector& v1, const scimatrix_subv& v2) {
13151 return v1 == scivector(v2);
13152}
13153
13155inline bool operator==(const civector_slice& v1, const srmatrix_subv& v2) {
13156 return v1 == srvector(v2);
13157}
13158
13160inline bool operator==(const civector_slice& v1, const simatrix_subv& v2) {
13161 return v1 == sivector(v2);
13162}
13163
13165inline bool operator==(const civector_slice& v1, const scmatrix_subv& v2) {
13166 return v1 == scvector(v2);
13167}
13168
13170inline bool operator==(const civector_slice& v1, const scimatrix_subv& v2) {
13171 return v1 == scivector(v2);
13172}
13173
13175inline bool operator==(const rvector_slice& v1, const scimatrix_subv& v2) {
13176 return v1 == scivector(v2);
13177}
13178
13180inline bool operator==(const cvector_slice& v1, const scimatrix_subv& v2) {
13181 return v1 == scivector(v2);
13182}
13183
13185inline bool operator==(const ivector_slice& v1, const scimatrix_subv& v2) {
13186 return v1 == scivector(v2);
13187}
13188
13190inline bool operator!=(const scimatrix_subv& v1, const srvector& v2) {
13191 return scivector(v1) != v2;
13192}
13193
13195inline bool operator!=(const scimatrix_subv& v1, const scvector& v2) {
13196 return scivector(v1) != v2;
13197}
13198
13200inline bool operator!=(const scimatrix_subv& v1, const sivector& v2) {
13201 return scivector(v1) != v2;
13202}
13203
13205inline bool operator!=(const scimatrix_subv& v1, const scivector& v2) {
13206 return scivector(v1) != v2;
13207}
13208
13210inline bool operator!=(const srmatrix_subv& v1, const scivector& v2) {
13211 return srvector(v1) != v2;
13212}
13213
13215inline bool operator!=(const scmatrix_subv& v1, const scivector& v2) {
13216 return scvector(v1) != v2;
13217}
13218
13220inline bool operator!=(const simatrix_subv& v1, const scivector& v2) {
13221 return sivector(v1) != v2;
13222}
13223
13225inline bool operator!=(const scimatrix_subv& v1, const srvector_slice& v2) {
13226 return scivector(v1) != v2;
13227}
13228
13230inline bool operator!=(const scimatrix_subv& v1, const sivector_slice& v2) {
13231 return scivector(v1) != v2;
13232}
13233
13235inline bool operator!=(const scimatrix_subv& v1, const scvector_slice& v2) {
13236 return scivector(v1) != v2;
13237}
13238
13240inline bool operator!=(const scimatrix_subv& v1, const scivector_slice& v2) {
13241 return scivector(v1) != v2;
13242}
13243
13245inline bool operator!=(const srmatrix_subv& v1, const scivector_slice& v2) {
13246 return srvector(v1) != v2;
13247}
13248
13250inline bool operator!=(const scmatrix_subv& v1, const scivector_slice& v2) {
13251 return scvector(v1) != v2;
13252}
13253
13255inline bool operator!=(const simatrix_subv& v1, const scivector_slice& v2) {
13256 return sivector(v1) != v2;
13257}
13258
13260inline bool operator!=(const scimatrix_subv& v1, const rvector& v2) {
13261 return scivector(v1) != v2;
13262}
13263
13265inline bool operator!=(const scimatrix_subv& v1, const cvector& v2) {
13266 return scivector(v1) != v2;
13267}
13268
13270inline bool operator!=(const scimatrix_subv& v1, const ivector& v2) {
13271 return scivector(v1) != v2;
13272}
13273
13275inline bool operator!=(const scimatrix_subv& v1, const civector& v2) {
13276 return scivector(v1) != v2;
13277}
13278
13280inline bool operator!=(const srmatrix_subv& v1, const civector& v2) {
13281 return srvector(v1) != v2;
13282}
13283
13285inline bool operator!=(const simatrix_subv& v1, const civector& v2) {
13286 return sivector(v1) != v2;
13287}
13288
13290inline bool operator!=(const scmatrix_subv& v1, const civector& v2) {
13291 return scivector(v1) != v2;
13292}
13293
13295inline bool operator!=(const scimatrix_subv& v1, const rvector_slice& v2) {
13296 return scivector(v1) != v2;
13297}
13298
13300inline bool operator!=(const scimatrix_subv& v1, const cvector_slice& v2) {
13301 return scivector(v1) != v2;
13302}
13303
13305inline bool operator!=(const scimatrix_subv& v1, const ivector_slice& v2) {
13306 return scivector(v1) != v2;
13307}
13308
13310inline bool operator!=(const scimatrix_subv& v1, const civector_slice& v2) {
13311 return scivector(v1) != v2;
13312}
13313
13315inline bool operator!=(const srmatrix_subv& v1, const civector_slice& v2) {
13316 return srvector(v1) != v2;
13317}
13318
13320inline bool operator!=(const scmatrix_subv& v1, const civector_slice& v2) {
13321 return scivector(v1) != v2;
13322}
13323
13325inline bool operator!=(const simatrix_subv& v1, const civector_slice& v2) {
13326 return scivector(v1) != v2;
13327}
13328
13330inline bool operator!=(const scivector& v1, const srmatrix_subv& v2) {
13331 return v1 != srvector(v2);
13332}
13333
13335inline bool operator!=(const scivector& v1, const scmatrix_subv& v2) {
13336 return v1 != scvector(v2);
13337}
13338
13340inline bool operator!=(const scivector& v1, const simatrix_subv& v2) {
13341 return v1 != sivector(v2);
13342}
13343
13345inline bool operator!=(const scivector& v1, const scimatrix_subv& v2) {
13346 return v1 != scivector(v2);
13347}
13348
13350inline bool operator!=(const srvector& v1, const scimatrix_subv& v2) {
13351 return v1 != scivector(v2);
13352}
13353
13355inline bool operator!=(const scvector& v1, const scimatrix_subv& v2) {
13356 return v1 != scivector(v2);
13357}
13358
13360inline bool operator!=(const sivector& v1, const scimatrix_subv& v2) {
13361 return v1 != scivector(v2);
13362}
13363
13365inline bool operator!=(const scivector_slice& v1, const srmatrix_subv& v2) {
13366 return v1 != srvector(v2);
13367}
13368
13370inline bool operator!=(const scivector_slice& v1, const simatrix_subv& v2) {
13371 return v1 != sivector(v2);
13372}
13373
13375inline bool operator!=(const scivector_slice& v1, const scmatrix_subv& v2) {
13376 return v1 != scvector(v2);
13377}
13378
13380inline bool operator!=(const scivector_slice& v1, const scimatrix_subv& v2) {
13381 return v1 != scivector(v2);
13382}
13383
13385inline bool operator!=(const srvector_slice& v1, const scimatrix_subv& v2) {
13386 return v1 != scivector(v2);
13387}
13388
13390inline bool operator!=(const scvector_slice& v1, const scimatrix_subv& v2) {
13391 return v1 != scivector(v2);
13392}
13393
13395inline bool operator!=(const sivector_slice& v1, const scimatrix_subv& v2) {
13396 return v1 != scivector(v2);
13397}
13398
13400inline bool operator!=(const civector& v1, const srmatrix_subv& v2) {
13401 return v1 != srvector(v2);
13402}
13403
13405inline bool operator!=(const civector& v1, const simatrix_subv& v2) {
13406 return v1 != sivector(v2);
13407}
13408
13410inline bool operator!=(const civector& v1, const scmatrix_subv& v2) {
13411 return v1 != scivector(v2);
13412}
13413
13415inline bool operator!=(const civector& v1, const scimatrix_subv& v2) {
13416 return v1 != scivector(v2);
13417}
13418
13420inline bool operator!=(const rvector& v1, const scimatrix_subv& v2) {
13421 return v1 != scivector(v2);
13422}
13423
13425inline bool operator!=(const cvector& v1, const scimatrix_subv& v2) {
13426 return v1 != scivector(v2);
13427}
13428
13430inline bool operator!=(const ivector& v1, const scimatrix_subv& v2) {
13431 return v1 != scivector(v2);
13432}
13433
13435inline bool operator!=(const civector_slice& v1, const srmatrix_subv& v2) {
13436 return v1 != srvector(v2);
13437}
13438
13440inline bool operator!=(const civector_slice& v1, const simatrix_subv& v2) {
13441 return v1 != sivector(v2);
13442}
13443
13445inline bool operator!=(const civector_slice& v1, const scmatrix_subv& v2) {
13446 return v1 != scvector(v2);
13447}
13448
13450inline bool operator!=(const civector_slice& v1, const scimatrix_subv& v2) {
13451 return v1 != scivector(v2);
13452}
13453
13455inline bool operator!=(const rvector_slice& v1, const scimatrix_subv& v2) {
13456 return v1 != scivector(v2);
13457}
13458
13460inline bool operator!=(const cvector_slice& v1, const scimatrix_subv& v2) {
13461 return v1 != scivector(v2);
13462}
13463
13465inline bool operator!=(const ivector_slice& v1, const scimatrix_subv& v2) {
13466 return v1 != scivector(v2);
13467}
13468
13470inline bool operator<(const scimatrix_subv& v1, const sivector& v2) {
13471 return scivector(v1) < v2;
13472}
13473
13475inline bool operator<(const scimatrix_subv& v1, const scivector& v2) {
13476 return scivector(v1) < v2;
13477}
13478
13480inline bool operator<(const srmatrix_subv& v1, const scivector& v2) {
13481 return srvector(v1) < v2;
13482}
13483
13485inline bool operator<(const scmatrix_subv& v1, const scivector& v2) {
13486 return scvector(v1) < v2;
13487}
13488
13490inline bool operator<(const simatrix_subv& v1, const scivector& v2) {
13491 return sivector(v1) < v2;
13492}
13493
13495inline bool operator<(const scimatrix_subv& v1, const sivector_slice& v2) {
13496 return scivector(v1) < v2;
13497}
13498
13500inline bool operator<(const scimatrix_subv& v1, const scivector_slice& v2) {
13501 return scivector(v1) < v2;
13502}
13503
13505inline bool operator<(const srmatrix_subv& v1, const scivector_slice& v2) {
13506 return srvector(v1) < v2;
13507}
13508
13510inline bool operator<(const scmatrix_subv& v1, const scivector_slice& v2) {
13511 return scvector(v1) < v2;
13512}
13513
13515inline bool operator<(const simatrix_subv& v1, const scivector_slice& v2) {
13516 return sivector(v1) < v2;
13517}
13518
13520inline bool operator<(const scimatrix_subv& v1, const ivector& v2) {
13521 return scivector(v1) < v2;
13522}
13523
13525inline bool operator<(const scimatrix_subv& v1, const civector& v2) {
13526 return scivector(v1) < v2;
13527}
13528
13530inline bool operator<(const srmatrix_subv& v1, const civector& v2) {
13531 return srvector(v1) < v2;
13532}
13533
13535inline bool operator<(const simatrix_subv& v1, const civector& v2) {
13536 return sivector(v1) < v2;
13537}
13538
13540inline bool operator<(const scmatrix_subv& v1, const civector& v2) {
13541 return scivector(v1) < v2;
13542}
13543
13545inline bool operator<(const scimatrix_subv& v1, const ivector_slice& v2) {
13546 return scivector(v1) < v2;
13547}
13548
13550inline bool operator<(const scimatrix_subv& v1, const civector_slice& v2) {
13551 return scivector(v1) < v2;
13552}
13553
13555inline bool operator<(const srmatrix_subv& v1, const civector_slice& v2) {
13556 return srvector(v1) < v2;
13557}
13558
13560inline bool operator<(const scmatrix_subv& v1, const civector_slice& v2) {
13561 return scivector(v1) < v2;
13562}
13563
13565inline bool operator<(const simatrix_subv& v1, const civector_slice& v2) {
13566 return scivector(v1) < v2;
13567}
13568
13570inline bool operator<(const scivector& v1, const simatrix_subv& v2) {
13571 return v1 < sivector(v2);
13572}
13573
13575inline bool operator<(const scivector& v1, const scimatrix_subv& v2) {
13576 return v1 < scivector(v2);
13577}
13578
13580inline bool operator<(const srvector& v1, const scimatrix_subv& v2) {
13581 return v1 < scivector(v2);
13582}
13583
13585inline bool operator<(const scvector& v1, const scimatrix_subv& v2) {
13586 return v1 < scivector(v2);
13587}
13588
13590inline bool operator<(const sivector& v1, const scimatrix_subv& v2) {
13591 return v1 < scivector(v2);
13592}
13593
13595inline bool operator<(const scivector_slice& v1, const simatrix_subv& v2) {
13596 return v1 < sivector(v2);
13597}
13598
13600inline bool operator<(const scivector_slice& v1, const scimatrix_subv& v2) {
13601 return v1 < scivector(v2);
13602}
13603
13605inline bool operator<(const srvector_slice& v1, const scimatrix_subv& v2) {
13606 return v1 < scivector(v2);
13607}
13608
13610inline bool operator<(const scvector_slice& v1, const scimatrix_subv& v2) {
13611 return v1 < scivector(v2);
13612}
13613
13615inline bool operator<(const sivector_slice& v1, const scimatrix_subv& v2) {
13616 return v1 < scivector(v2);
13617}
13618
13620inline bool operator<(const civector& v1, const simatrix_subv& v2) {
13621 return v1 < sivector(v2);
13622}
13623
13625inline bool operator<(const civector& v1, const scimatrix_subv& v2) {
13626 return v1 < scivector(v2);
13627}
13628
13630inline bool operator<(const rvector& v1, const scimatrix_subv& v2) {
13631 return v1 < scivector(v2);
13632}
13633
13635inline bool operator<(const cvector& v1, const scimatrix_subv& v2) {
13636 return v1 < scivector(v2);
13637}
13638
13640inline bool operator<(const ivector& v1, const scimatrix_subv& v2) {
13641 return v1 < scivector(v2);
13642}
13643
13645inline bool operator<(const civector_slice& v1, const simatrix_subv& v2) {
13646 return v1 < sivector(v2);
13647}
13648
13650inline bool operator<(const civector_slice& v1, const scimatrix_subv& v2) {
13651 return v1 < scivector(v2);
13652}
13653
13655inline bool operator<(const rvector_slice& v1, const scimatrix_subv& v2) {
13656 return v1 < scivector(v2);
13657}
13658
13660inline bool operator<(const cvector_slice& v1, const scimatrix_subv& v2) {
13661 return v1 < scivector(v2);
13662}
13663
13665inline bool operator<(const ivector_slice& v1, const scimatrix_subv& v2) {
13666 return v1 < scivector(v2);
13667}
13668
13670inline bool operator<=(const scimatrix_subv& v1, const sivector& v2) {
13671 return scivector(v1) <= v2;
13672}
13673
13675inline bool operator<=(const scimatrix_subv& v1, const scivector& v2) {
13676 return scivector(v1) <= v2;
13677}
13678
13680inline bool operator<=(const srmatrix_subv& v1, const scivector& v2) {
13681 return srvector(v1) <= v2;
13682}
13683
13685inline bool operator<=(const scmatrix_subv& v1, const scivector& v2) {
13686 return scvector(v1) <= v2;
13687}
13688
13690inline bool operator<=(const simatrix_subv& v1, const scivector& v2) {
13691 return sivector(v1) <= v2;
13692}
13693
13695inline bool operator<=(const scimatrix_subv& v1, const sivector_slice& v2) {
13696 return scivector(v1) <= v2;
13697}
13698
13700inline bool operator<=(const scimatrix_subv& v1, const scivector_slice& v2) {
13701 return scivector(v1) <= v2;
13702}
13703
13705inline bool operator<=(const srmatrix_subv& v1, const scivector_slice& v2) {
13706 return srvector(v1) <= v2;
13707}
13708
13710inline bool operator<=(const scmatrix_subv& v1, const scivector_slice& v2) {
13711 return scvector(v1) <= v2;
13712}
13713
13715inline bool operator<=(const simatrix_subv& v1, const scivector_slice& v2) {
13716 return sivector(v1) <= v2;
13717}
13718
13720inline bool operator<=(const scimatrix_subv& v1, const ivector& v2) {
13721 return scivector(v1) <= v2;
13722}
13723
13725inline bool operator<=(const scimatrix_subv& v1, const civector& v2) {
13726 return scivector(v1) <= v2;
13727}
13728
13730inline bool operator<=(const srmatrix_subv& v1, const civector& v2) {
13731 return srvector(v1) <= v2;
13732}
13733
13735inline bool operator<=(const simatrix_subv& v1, const civector& v2) {
13736 return sivector(v1) <= v2;
13737}
13738
13740inline bool operator<=(const scmatrix_subv& v1, const civector& v2) {
13741 return scivector(v1) <= v2;
13742}
13743
13745inline bool operator<=(const scimatrix_subv& v1, const ivector_slice& v2) {
13746 return scivector(v1) <= v2;
13747}
13748
13750inline bool operator<=(const scimatrix_subv& v1, const civector_slice& v2) {
13751 return scivector(v1) <= v2;
13752}
13753
13755inline bool operator<=(const srmatrix_subv& v1, const civector_slice& v2) {
13756 return srvector(v1) <= v2;
13757}
13758
13760inline bool operator<=(const scmatrix_subv& v1, const civector_slice& v2) {
13761 return scivector(v1) <= v2;
13762}
13763
13765inline bool operator<=(const simatrix_subv& v1, const civector_slice& v2) {
13766 return scivector(v1) <= v2;
13767}
13768
13770inline bool operator<=(const scivector& v1, const simatrix_subv& v2) {
13771 return v1 <= sivector(v2);
13772}
13773
13775inline bool operator<=(const scivector& v1, const scimatrix_subv& v2) {
13776 return v1 <= scivector(v2);
13777}
13778
13780inline bool operator<=(const srvector& v1, const scimatrix_subv& v2) {
13781 return v1 <= scivector(v2);
13782}
13783
13785inline bool operator<=(const scvector& v1, const scimatrix_subv& v2) {
13786 return v1 <= scivector(v2);
13787}
13788
13790inline bool operator<=(const sivector& v1, const scimatrix_subv& v2) {
13791 return v1 <= scivector(v2);
13792}
13793
13795inline bool operator<=(const scivector_slice& v1, const simatrix_subv& v2) {
13796 return v1 <= sivector(v2);
13797}
13798
13800inline bool operator<=(const scivector_slice& v1, const scimatrix_subv& v2) {
13801 return v1 <= scivector(v2);
13802}
13803
13805inline bool operator<=(const srvector_slice& v1, const scimatrix_subv& v2) {
13806 return v1 <= scivector(v2);
13807}
13808
13810inline bool operator<=(const scvector_slice& v1, const scimatrix_subv& v2) {
13811 return v1 <= scivector(v2);
13812}
13813
13815inline bool operator<=(const sivector_slice& v1, const scimatrix_subv& v2) {
13816 return v1 <= scivector(v2);
13817}
13818
13820inline bool operator<=(const civector& v1, const simatrix_subv& v2) {
13821 return v1 <= sivector(v2);
13822}
13823
13825inline bool operator<=(const civector& v1, const scimatrix_subv& v2) {
13826 return v1 <= scivector(v2);
13827}
13828
13830inline bool operator<=(const rvector& v1, const scimatrix_subv& v2) {
13831 return v1 <= scivector(v2);
13832}
13833
13835inline bool operator<=(const cvector& v1, const scimatrix_subv& v2) {
13836 return v1 <= scivector(v2);
13837}
13838
13840inline bool operator<=(const ivector& v1, const scimatrix_subv& v2) {
13841 return v1 <= scivector(v2);
13842}
13843
13845inline bool operator<=(const civector_slice& v1, const simatrix_subv& v2) {
13846 return v1 <= sivector(v2);
13847}
13848
13850inline bool operator<=(const civector_slice& v1, const scimatrix_subv& v2) {
13851 return v1 <= scivector(v2);
13852}
13853
13855inline bool operator<=(const rvector_slice& v1, const scimatrix_subv& v2) {
13856 return v1 <= scivector(v2);
13857}
13858
13860inline bool operator<=(const cvector_slice& v1, const scimatrix_subv& v2) {
13861 return v1 <= scivector(v2);
13862}
13863
13865inline bool operator<=(const ivector_slice& v1, const scimatrix_subv& v2) {
13866 return v1 <= scivector(v2);
13867}
13868
13870inline bool operator>(const scimatrix_subv& v1, const srvector& v2) {
13871 return scivector(v1) > v2;
13872}
13873
13875inline bool operator>(const scimatrix_subv& v1, const scvector& v2) {
13876 return scivector(v1) > v2;
13877}
13878
13880inline bool operator>(const scimatrix_subv& v1, const sivector& v2) {
13881 return scivector(v1) > v2;
13882}
13883
13885inline bool operator>(const scimatrix_subv& v1, const scivector& v2) {
13886 return scivector(v1) > v2;
13887}
13888
13890inline bool operator>(const simatrix_subv& v1, const scivector& v2) {
13891 return sivector(v1) > v2;
13892}
13893
13895inline bool operator>(const scimatrix_subv& v1, const srvector_slice& v2) {
13896 return scivector(v1) > v2;
13897}
13898
13900inline bool operator>(const scimatrix_subv& v1, const sivector_slice& v2) {
13901 return scivector(v1) > v2;
13902}
13903
13905inline bool operator>(const scimatrix_subv& v1, const scvector_slice& v2) {
13906 return scivector(v1) > v2;
13907}
13908
13910inline bool operator>(const scimatrix_subv& v1, const scivector_slice& v2) {
13911 return scivector(v1) > v2;
13912}
13913
13915inline bool operator>(const simatrix_subv& v1, const scivector_slice& v2) {
13916 return sivector(v1) > v2;
13917}
13918
13920inline bool operator>(const scimatrix_subv& v1, const rvector& v2) {
13921 return scivector(v1) > v2;
13922}
13923
13925inline bool operator>(const scimatrix_subv& v1, const cvector& v2) {
13926 return scivector(v1) > v2;
13927}
13928
13930inline bool operator>(const scimatrix_subv& v1, const ivector& v2) {
13931 return scivector(v1) > v2;
13932}
13933
13935inline bool operator>(const scimatrix_subv& v1, const civector& v2) {
13936 return scivector(v1) > v2;
13937}
13938
13940inline bool operator>(const simatrix_subv& v1, const civector& v2) {
13941 return sivector(v1) > v2;
13942}
13943
13945inline bool operator>(const scimatrix_subv& v1, const rvector_slice& v2) {
13946 return scivector(v1) > v2;
13947}
13948
13950inline bool operator>(const scimatrix_subv& v1, const cvector_slice& v2) {
13951 return scivector(v1) > v2;
13952}
13953
13955inline bool operator>(const scimatrix_subv& v1, const ivector_slice& v2) {
13956 return scivector(v1) > v2;
13957}
13958
13960inline bool operator>(const scimatrix_subv& v1, const civector_slice& v2) {
13961 return scivector(v1) > v2;
13962}
13963
13965inline bool operator>(const simatrix_subv& v1, const civector_slice& v2) {
13966 return scivector(v1) > v2;
13967}
13968
13970inline bool operator>(const scivector& v1, const srmatrix_subv& v2) {
13971 return v1 > srvector(v2);
13972}
13973
13975inline bool operator>(const scivector& v1, const scmatrix_subv& v2) {
13976 return v1 > scvector(v2);
13977}
13978
13980inline bool operator>(const scivector& v1, const simatrix_subv& v2) {
13981 return v1 > sivector(v2);
13982}
13983
13985inline bool operator>(const scivector& v1, const scimatrix_subv& v2) {
13986 return v1 > scivector(v2);
13987}
13988
13990inline bool operator>(const sivector& v1, const scimatrix_subv& v2) {
13991 return v1 > scivector(v2);
13992}
13993
13995inline bool operator>(const scivector_slice& v1, const srmatrix_subv& v2) {
13996 return v1 > srvector(v2);
13997}
13998
14000inline bool operator>(const scivector_slice& v1, const simatrix_subv& v2) {
14001 return v1 > sivector(v2);
14002}
14003
14005inline bool operator>(const scivector_slice& v1, const scmatrix_subv& v2) {
14006 return v1 > scvector(v2);
14007}
14008
14010inline bool operator>(const scivector_slice& v1, const scimatrix_subv& v2) {
14011 return v1 > scivector(v2);
14012}
14013
14015inline bool operator>(const sivector_slice& v1, const scimatrix_subv& v2) {
14016 return v1 > scivector(v2);
14017}
14018
14020inline bool operator>(const civector& v1, const srmatrix_subv& v2) {
14021 return v1 > srvector(v2);
14022}
14023
14025inline bool operator>(const civector& v1, const simatrix_subv& v2) {
14026 return v1 > sivector(v2);
14027}
14028
14030inline bool operator>(const civector& v1, const scmatrix_subv& v2) {
14031 return v1 > scvector(v2);
14032}
14033
14035inline bool operator>(const civector& v1, const scimatrix_subv& v2) {
14036 return v1 > scivector(v2);
14037}
14038
14040inline bool operator>(const ivector& v1, const scimatrix_subv& v2) {
14041 return v1 > scivector(v2);
14042}
14043
14045inline bool operator>(const civector_slice& v1, const srmatrix_subv& v2) {
14046 return v1 > srvector(v2);
14047}
14048
14050inline bool operator>(const civector_slice& v1, const simatrix_subv& v2) {
14051 return v1 > sivector(v2);
14052}
14053
14055inline bool operator>(const civector_slice& v1, const scmatrix_subv& v2) {
14056 return v1 > scvector(v2);
14057}
14058
14060inline bool operator>(const civector_slice& v1, const scimatrix_subv& v2) {
14061 return v1 > scivector(v2);
14062}
14063
14065inline bool operator>(const ivector_slice& v1, const scimatrix_subv& v2) {
14066 return v1 > scivector(v2);
14067}
14068
14070inline bool operator>=(const scimatrix_subv& v1, const srvector& v2) {
14071 return scivector(v1) >= v2;
14072}
14073
14075inline bool operator>=(const scimatrix_subv& v1, const scvector& v2) {
14076 return scivector(v1) >= v2;
14077}
14078
14080inline bool operator>=(const scimatrix_subv& v1, const sivector& v2) {
14081 return scivector(v1) >= v2;
14082}
14083
14085inline bool operator>=(const scimatrix_subv& v1, const scivector& v2) {
14086 return scivector(v1) >= v2;
14087}
14088
14090inline bool operator>=(const simatrix_subv& v1, const scivector& v2) {
14091 return sivector(v1) >= v2;
14092}
14093
14095inline bool operator>=(const scimatrix_subv& v1, const srvector_slice& v2) {
14096 return scivector(v1) >= v2;
14097}
14098
14100inline bool operator>=(const scimatrix_subv& v1, const sivector_slice& v2) {
14101 return scivector(v1) >= v2;
14102}
14103
14105inline bool operator>=(const scimatrix_subv& v1, const scvector_slice& v2) {
14106 return scivector(v1) >= v2;
14107}
14108
14110inline bool operator>=(const scimatrix_subv& v1, const scivector_slice& v2) {
14111 return scivector(v1) >= v2;
14112}
14113
14115inline bool operator>=(const simatrix_subv& v1, const scivector_slice& v2) {
14116 return sivector(v1) >= v2;
14117}
14118
14120inline bool operator>=(const scimatrix_subv& v1, const rvector& v2) {
14121 return scivector(v1) >= v2;
14122}
14123
14125inline bool operator>=(const scimatrix_subv& v1, const cvector& v2) {
14126 return scivector(v1) >= v2;
14127}
14128
14130inline bool operator>=(const scimatrix_subv& v1, const ivector& v2) {
14131 return scivector(v1) >= v2;
14132}
14133
14135inline bool operator>=(const scimatrix_subv& v1, const civector& v2) {
14136 return scivector(v1) >= v2;
14137}
14138
14140inline bool operator>=(const simatrix_subv& v1, const civector& v2) {
14141 return sivector(v1) >= v2;
14142}
14143
14145inline bool operator>=(const scimatrix_subv& v1, const rvector_slice& v2) {
14146 return scivector(v1) >= v2;
14147}
14148
14150inline bool operator>=(const scimatrix_subv& v1, const cvector_slice& v2) {
14151 return scivector(v1) >= v2;
14152}
14153
14155inline bool operator>=(const scimatrix_subv& v1, const ivector_slice& v2) {
14156 return scivector(v1) >= v2;
14157}
14158
14160inline bool operator>=(const scimatrix_subv& v1, const civector_slice& v2) {
14161 return scivector(v1) >= v2;
14162}
14163
14165inline bool operator>=(const simatrix_subv& v1, const civector_slice& v2) {
14166 return scivector(v1) >= v2;
14167}
14168
14170inline bool operator>=(const scivector& v1, const srmatrix_subv& v2) {
14171 return v1 >= srvector(v2);
14172}
14173
14175inline bool operator>=(const scivector& v1, const scmatrix_subv& v2) {
14176 return v1 >= scvector(v2);
14177}
14178
14180inline bool operator>=(const scivector& v1, const simatrix_subv& v2) {
14181 return v1 >= sivector(v2);
14182}
14183
14185inline bool operator>=(const scivector& v1, const scimatrix_subv& v2) {
14186 return v1 >= scivector(v2);
14187}
14188
14190inline bool operator>=(const sivector& v1, const scimatrix_subv& v2) {
14191 return v1 >= scivector(v2);
14192}
14193
14195inline bool operator>=(const scivector_slice& v1, const srmatrix_subv& v2) {
14196 return v1 >= srvector(v2);
14197}
14198
14200inline bool operator>=(const scivector_slice& v1, const simatrix_subv& v2) {
14201 return v1 >= sivector(v2);
14202}
14203
14205inline bool operator>=(const scivector_slice& v1, const scmatrix_subv& v2) {
14206 return v1 >= scvector(v2);
14207}
14208
14210inline bool operator>=(const scivector_slice& v1, const scimatrix_subv& v2) {
14211 return v1 >= scivector(v2);
14212}
14213
14215inline bool operator>=(const sivector_slice& v1, const scimatrix_subv& v2) {
14216 return v1 >= scivector(v2);
14217}
14218
14220inline bool operator>=(const civector& v1, const srmatrix_subv& v2) {
14221 return v1 >= srvector(v2);
14222}
14223
14225inline bool operator>=(const civector& v1, const simatrix_subv& v2) {
14226 return v1 >= sivector(v2);
14227}
14228
14230inline bool operator>=(const civector& v1, const scmatrix_subv& v2) {
14231 return v1 >= scvector(v2);
14232}
14233
14235inline bool operator>=(const civector& v1, const scimatrix_subv& v2) {
14236 return v1 >= scivector(v2);
14237}
14238
14240inline bool operator>=(const ivector& v1, const scimatrix_subv& v2) {
14241 return v1 >= scivector(v2);
14242}
14243
14245inline bool operator>=(const civector_slice& v1, const srmatrix_subv& v2) {
14246 return v1 >= srvector(v2);
14247}
14248
14250inline bool operator>=(const civector_slice& v1, const simatrix_subv& v2) {
14251 return v1 >= sivector(v2);
14252}
14253
14255inline bool operator>=(const civector_slice& v1, const scmatrix_subv& v2) {
14256 return v1 >= scvector(v2);
14257}
14258
14260inline bool operator>=(const civector_slice& v1, const scimatrix_subv& v2) {
14261 return v1 >= scivector(v2);
14262}
14263
14265inline bool operator>=(const ivector_slice& v1, const scimatrix_subv& v2) {
14266 return v1 >= scivector(v2);
14267}
14268
14270inline bool operator!(const scimatrix_subv& x) {
14271 return sv_v_not(x);
14272}
14273
14274
14276
14279inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scimatrix_subv& v2) {
14280 accumulate(dot,scivector(v1),scivector(v2));
14281}
14282
14283
14285
14288inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scmatrix_subv& v2) {
14289 accumulate(dot,scivector(v1),scvector(v2));
14290}
14291
14293
14296inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const simatrix_subv& v2) {
14297 accumulate(dot,scivector(v1),sivector(v2));
14298}
14299
14301
14304inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const srmatrix_subv& v2) {
14305 accumulate(dot,scivector(v1),srvector(v2));
14306}
14307
14309
14312inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const scimatrix_subv& v2) {
14313 accumulate(dot,scvector(v1),scivector(v2));
14314}
14315
14317
14320inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scimatrix_subv& v2) {
14321 accumulate(dot,sivector(v1),scivector(v2));
14322}
14323
14325
14328inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const scimatrix_subv& v2) {
14329 accumulate(dot,srvector(v1),scivector(v2));
14330}
14331
14333
14336inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const srvector& v2) {
14337 accumulate(dot,scivector(v1),v2);
14338}
14339
14341
14344inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scvector& v2) {
14345 accumulate(dot,scivector(v1),v2);
14346}
14347
14349
14352inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const sivector& v2) {
14353 accumulate(dot,scivector(v1),v2);
14354}
14355
14357
14360inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scivector& v2) {
14361 accumulate(dot,scivector(v1),v2);
14362}
14363
14365
14368inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const scivector& v2) {
14369 accumulate(dot,srvector(v1),v2);
14370}
14371
14373
14376inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const scivector& v2) {
14377 accumulate(dot,scvector(v1),v2);
14378}
14379
14381
14384inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scivector& v2) {
14385 accumulate(dot,sivector(v1),v2);
14386}
14387
14389
14392inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const sivector& v2) {
14393 accumulate(dot,scvector(v1),v2);
14394}
14395
14397
14400inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scvector& v2) {
14401 accumulate(dot,sivector(v1),v2);
14402}
14403
14405
14408inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const srvector_slice& v2) {
14409 accumulate(dot,scivector(v1),v2);
14410}
14411
14413
14416inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scvector_slice& v2) {
14417 accumulate(dot,scivector(v1),v2);
14418}
14419
14421
14424inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const sivector_slice& v2) {
14425 accumulate(dot,scivector(v1),v2);
14426}
14427
14429
14432inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scivector_slice& v2) {
14433 accumulate(dot,scivector(v1),v2);
14434}
14435
14437
14440inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const scivector_slice& v2) {
14441 accumulate(dot,srvector(v1),v2);
14442}
14443
14445
14448inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const scivector_slice& v2) {
14449 accumulate(dot,scvector(v1),v2);
14450}
14451
14453
14456inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scivector_slice& v2) {
14457 accumulate(dot,sivector(v1),v2);
14458}
14459
14461
14464inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const sivector_slice& v2) {
14465 accumulate(dot,scvector(v1),v2);
14466}
14467
14469
14472inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scvector_slice& v2) {
14473 accumulate(dot,sivector(v1),v2);
14474}
14475
14477
14480inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const rvector& v2) {
14481 accumulate(dot,scivector(v1),v2);
14482}
14483
14485
14488inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const ivector& v2) {
14489 accumulate(dot,scivector(v1),v2);
14490}
14491
14493
14496inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const cvector& v2) {
14497 accumulate(dot,scivector(v1),v2);
14498}
14499
14501
14504inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const civector& v2) {
14505 accumulate(dot,scivector(v1),v2);
14506}
14507
14509
14512inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const civector& v2) {
14513 accumulate(dot,srvector(v1),v2);
14514}
14515
14517
14520inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const civector& v2) {
14521 accumulate(dot,sivector(v1),v2);
14522}
14523
14525
14528inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const civector& v2) {
14529 accumulate(dot,scvector(v1),v2);
14530}
14531
14533
14536inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const ivector& v2) {
14537 accumulate(dot,scvector(v1),v2);
14538}
14539
14541
14544inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const cvector& v2) {
14545 accumulate(dot,sivector(v1),v2);
14546}
14547
14549
14552inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const rvector_slice& v2) {
14553 accumulate(dot,scivector(v1),v2);
14554}
14555
14557
14560inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const ivector_slice& v2) {
14561 accumulate(dot,scivector(v1),v2);
14562}
14563
14565
14568inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const cvector_slice& v2) {
14569 accumulate(dot,scivector(v1),v2);
14570}
14571
14573
14576inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const civector_slice& v2) {
14577 accumulate(dot,scivector(v1),v2);
14578}
14579
14581
14584inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const civector_slice& v2) {
14585 accumulate(dot,srvector(v1),v2);
14586}
14587
14589
14592inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const civector_slice& v2) {
14593 accumulate(dot,scvector(v1),v2);
14594}
14595
14597
14600inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const civector_slice& v2) {
14601 accumulate(dot,sivector(v1),v2);
14602}
14603
14605
14608inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const ivector_slice& v2) {
14609 accumulate(dot,scvector(v1),v2);
14610}
14611
14613
14616inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const cvector_slice& v2) {
14617 accumulate(dot,sivector(v1),v2);
14618}
14619
14621
14624inline void accumulate(cidotprecision& dot,const scivector& v1, const srmatrix_subv& v2) {
14625 accumulate(dot,v1,srvector(v2));
14626}
14627
14629
14632inline void accumulate(cidotprecision& dot,const scivector& v1, const scmatrix_subv& v2) {
14633 accumulate(dot,v1,scvector(v2));
14634}
14635
14637
14640inline void accumulate(cidotprecision& dot,const scivector& v1, const simatrix_subv& v2) {
14641 accumulate(dot,v1,sivector(v2));
14642}
14643
14645
14648inline void accumulate(cidotprecision& dot,const scivector& v1, const scimatrix_subv& v2) {
14649 accumulate(dot,v1,scivector(v2));
14650}
14651
14653
14656inline void accumulate(cidotprecision& dot,const srvector& v1, const scimatrix_subv& v2) {
14657 accumulate(dot,v1,scivector(v2));
14658}
14659
14661
14664inline void accumulate(cidotprecision& dot,const scvector& v1, const scimatrix_subv& v2) {
14665 accumulate(dot,v1,scivector(v2));
14666}
14667
14669
14672inline void accumulate(cidotprecision& dot,const sivector& v1, const scimatrix_subv& v2) {
14673 accumulate(dot,v1,scivector(v2));
14674}
14675
14677
14680inline void accumulate(cidotprecision& dot,const scvector& v1, const simatrix_subv& v2) {
14681 accumulate(dot,v1,sivector(v2));
14682}
14683
14685
14688inline void accumulate(cidotprecision& dot,const sivector& v1, const scmatrix_subv& v2) {
14689 accumulate(dot,v1,scvector(v2));
14690}
14691
14693
14696inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const srmatrix_subv& v2) {
14697 accumulate(dot,v1,srvector(v2));
14698}
14699
14701
14704inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const scmatrix_subv& v2) {
14705 accumulate(dot,v1,scvector(v2));
14706}
14707
14709
14712inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const simatrix_subv& v2) {
14713 accumulate(dot,v1,sivector(v2));
14714}
14715
14717
14720inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const scimatrix_subv& v2) {
14721 accumulate(dot,v1,scivector(v2));
14722}
14723
14725
14728inline void accumulate(cidotprecision& dot,const srvector_slice& v1, const scimatrix_subv& v2) {
14729 accumulate(dot,v1,scivector(v2));
14730}
14731
14733
14736inline void accumulate(cidotprecision& dot,const sivector_slice& v1, const scimatrix_subv& v2) {
14737 accumulate(dot,v1,scivector(v2));
14738}
14739
14741
14744inline void accumulate(cidotprecision& dot,const scvector_slice& v1, const scimatrix_subv& v2) {
14745 accumulate(dot,v1,scivector(v2));
14746}
14747
14749
14752inline void accumulate(cidotprecision& dot,const scvector_slice& v1, const simatrix_subv& v2) {
14753 accumulate(dot,v1,sivector(v2));
14754}
14755
14757
14760inline void accumulate(cidotprecision& dot,const sivector_slice& v1, const scmatrix_subv& v2) {
14761 accumulate(dot,v1,scvector(v2));
14762}
14763
14765
14768inline void accumulate(cidotprecision& dot,const civector& v1, const srmatrix_subv& v2) {
14769 accumulate(dot,v1,srvector(v2));
14770}
14771
14773
14776inline void accumulate(cidotprecision& dot,const civector& v1, const scmatrix_subv& v2) {
14777 accumulate(dot,v1,scvector(v2));
14778}
14779
14781
14784inline void accumulate(cidotprecision& dot,const civector& v1, const simatrix_subv& v2) {
14785 accumulate(dot,v1,sivector(v2));
14786}
14787
14789
14792inline void accumulate(cidotprecision& dot,const civector& v1, const scimatrix_subv& v2) {
14793 accumulate(dot,v1,scivector(v2));
14794}
14795
14797
14800inline void accumulate(cidotprecision& dot,const rvector& v1, const scimatrix_subv& v2) {
14801 accumulate(dot,v1,scivector(v2));
14802}
14803
14805
14808inline void accumulate(cidotprecision& dot,const cvector& v1, const scimatrix_subv& v2) {
14809 accumulate(dot,v1,scivector(v2));
14810}
14811
14813
14816inline void accumulate(cidotprecision& dot,const ivector& v1, const scimatrix_subv& v2) {
14817 accumulate(dot,v1,scivector(v2));
14818}
14819
14821
14824inline void accumulate(cidotprecision& dot,const ivector& v1, const scmatrix_subv& v2) {
14825 accumulate(dot,v1,scvector(v2));
14826}
14827
14829
14832inline void accumulate(cidotprecision& dot,const cvector& v1, const simatrix_subv& v2) {
14833 accumulate(dot,v1,sivector(v2));
14834}
14835
14837
14840inline void accumulate(cidotprecision& dot,const civector_slice& v1, const srmatrix_subv& v2) {
14841 accumulate(dot,v1,srvector(v2));
14842}
14843
14845
14848inline void accumulate(cidotprecision& dot,const civector_slice& v1, const scmatrix_subv& v2) {
14849 accumulate(dot,v1,scvector(v2));
14850}
14851
14853
14856inline void accumulate(cidotprecision& dot,const civector_slice& v1, const simatrix_subv& v2) {
14857 accumulate(dot,v1,sivector(v2));
14858}
14859
14861
14864inline void accumulate(cidotprecision& dot,const civector_slice& v1, const scimatrix_subv& v2) {
14865 accumulate(dot,v1,scivector(v2));
14866}
14867
14869
14872inline void accumulate(cidotprecision& dot,const rvector_slice& v1, const scimatrix_subv& v2) {
14873 accumulate(dot,v1,scivector(v2));
14874}
14875
14877
14880inline void accumulate(cidotprecision& dot,const cvector_slice& v1, const scimatrix_subv& v2) {
14881 accumulate(dot,v1,scivector(v2));
14882}
14883
14885
14888inline void accumulate(cidotprecision& dot,const ivector_slice& v1, const scimatrix_subv& v2) {
14889 accumulate(dot,v1,scivector(v2));
14890}
14891
14893
14896inline void accumulate(cidotprecision& dot,const ivector_slice& v1, const scmatrix_subv& v2) {
14897 accumulate(dot,v1,scvector(v2));
14898}
14899
14901
14904inline void accumulate(cidotprecision& dot,const cvector_slice& v1, const simatrix_subv& v2) {
14905 accumulate(dot,v1,sivector(v2));
14906}
14907
14908
14909} //namespace cxsc;
14910
14911#include "sparsematrix.inl"
14912
14913#endif
14914
The Data Type cidotprecision.
Definition cidot.hpp:58
The Data Type cimatrix_slice.
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix_slice & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
cimatrix_slice & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
cimatrix_slice & operator=(const cimatrix &m) noexcept
Implementation of standard assigning operator.
Definition cimatrix.inl:581
cimatrix_slice & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
The Data Type cimatrix_subv.
Definition cimatrix.hpp:68
cimatrix_subv & operator&=(const scivector &rv)
Implementation of intersection and allocation operation.
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
cimatrix_subv & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
Definition cimatrix.inl:734
cimatrix_subv & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
Definition cimatrix.inl:735
The Data Type cimatrix.
Definition cimatrix.hpp:908
cimatrix & operator*=(const scimatrix &m1)
Implementation of multiplication and allocation operation.
cimatrix & operator=(const cinterval &r) noexcept
Implementation of standard assigning operator.
Definition cimatrix.inl:555
cimatrix() noexcept
Constructor of class cimatrix.
Definition cimatrix.inl:31
cimatrix & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix & operator+=(const scimatrix &m1)
Implementation of addition and allocation operation.
cimatrix & operator-=(const scimatrix &m1)
Implementation of substraction and allocation operation.
The Scalar Type cinterval.
Definition cinterval.hpp:55
The Data Type civector_slice.
The Data Type civector.
Definition civector.hpp:57
The Data Type cmatrix_slice.
Definition cmatrix.hpp:1203
The Data Type cmatrix.
Definition cmatrix.hpp:514
The Scalar Type complex.
Definition complex.hpp:50
The Data Type cvector_slice.
Definition cvector.hpp:845
The Data Type cvector.
Definition cvector.hpp:58
The Data Type imatrix_slice.
Definition imatrix.hpp:1442
The Data Type imatrix.
Definition imatrix.hpp:660
The Scalar Type interval.
Definition interval.hpp:55
The Data Type intmatrix.
The Data Type intvector.
Definition intvector.hpp:52
The Data Type ivector_slice.
Definition ivector.hpp:963
The Data Type ivector.
Definition ivector.hpp:55
The Scalar Type real.
Definition real.hpp:114
The Data Type rmatrix_slice.
Definition rmatrix.hpp:1443
The Data Type rmatrix.
Definition rmatrix.hpp:471
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
A slice of a sparse complex interval matrix.
scimatrix_slice & operator=(const srmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator=(const srmatrix &C)
Assing C to the slice.
friend srmatrix SupRe(const scimatrix_slice &)
Returns the real part of the supremum of the slice S.
scimatrix_slice & operator=(const cimatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator-=(const scmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const rmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const cmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const simatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const simatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const simatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
friend srmatrix InfRe(const scimatrix_slice &)
Returns the real part of the infimum of the slice S.
scimatrix_slice & operator+=(const rmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const rmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const scimatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cimatrix &C)
Assing C to the slice.
scimatrix_slice & operator-=(const scimatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const scmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
cinterval & element(const int i, const int j)
Returns a reference to the element (i,j) of the matrix.
scimatrix_slice & operator+=(const imatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
friend int Ub(const scimatrix_slice &, const int)
Returns the upper index bound of the rows (if i==ROW) or columns (if i==COL) of the slice.
scimatrix_slice & operator=(const scmatrix &C)
Assing C to the slice.
scimatrix_slice & operator|=(const cimatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const scimatrix &C)
Assing C to the slice.
scimatrix_slice & operator+=(const scimatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
friend scmatrix Inf(const scimatrix_slice &)
Returns the infimum of the slice S.
scimatrix_slice & operator*=(const imatrix &M)
Assigns the product of the sparse slice and M to the slice.
const cinterval operator()(const int i, const int j) const
Returns a copy of the element (i,j) of the matrix.
friend simatrix Im(const scimatrix_slice &)
Returns the imaginary part of the slice S.
scimatrix_slice & operator*=(const scimatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const cmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const complex &C)
Assing C to all elements of the slice.
scimatrix_slice & operator*=(const cimatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const simatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_subv operator[](const int)
Returns a row of the matrix.
scimatrix_slice & operator/=(const real &r)
Assigns the component wise division of the sparse slice and M to the slice.
friend srmatrix SupIm(const scimatrix_slice &)
Returns the imaginary part of the supremum of the slice S.
scimatrix_slice & operator-=(const cimatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
friend int RowLen(const scimatrix_slice &)
Returns the number columns of the matrix slice.
scimatrix_slice & operator-=(const srmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const imatrix &C)
Assing C to the slice.
scimatrix_slice & operator*=(const imatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const srmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cimatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const imatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator=(const simatrix &C)
Assing C to the slice.
scimatrix_slice & operator=(const rmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator/=(const interval &r)
Assigns the component wise division of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const rmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const rmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const interval &C)
Assing C to all elements of the slice.
scimatrix_slice & operator=(const rmatrix &C)
Assing C to the slice.
scimatrix_slice & operator*=(const simatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const cmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
friend simatrix Re(const scimatrix_slice &)
Returns the real part of the slice S.
scimatrix_slice & operator-=(const rmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const real &C)
Assing C to all elements of the slice.
friend int ColLen(const scimatrix_slice &)
Returns the number of rows of the matrix slice.
scimatrix_slice & operator=(const scmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator+=(const simatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator=(const imatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator+=(const cmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const cimatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const scmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator/=(const complex &r)
Assigns the component wise division of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const imatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator/=(const cinterval &r)
Assigns the component wise division of the sparse slice and M to the slice.
friend scmatrix Sup(const scimatrix_slice &)
Returns the supremum of the slice S.
scimatrix_slice & operator|=(const scimatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
friend int Lb(const scimatrix_slice &, const int)
Returns the lower index bound of the rows (if i==ROW) or columns (if i==COL) of the slice.
scimatrix_slice & operator-=(const simatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const scmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const rmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const scmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const imatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const srmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const srmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const simatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const cmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const cmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const srmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const srmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const rmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const cimatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cinterval &r)
Assigns the component wise product of the sparse slice and r to the slice.
friend std::ostream & operator<<(std::ostream &, const scimatrix_slice &)
Standard output operator for sparse matrix slice.
scimatrix_slice & operator*=(const complex &r)
Assigns the component wise product of the sparse slice and r to the slice.
scimatrix_slice & operator|=(const scmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const scimatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator*=(const scmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const srmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const srmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const cimatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cmatrix &C)
Assing C to the slice.
scimatrix_slice & operator-=(const imatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const scimatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator=(const simatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator|=(const cimatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const scimatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const imatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cinterval &C)
Assing C to all elements of the slice.
scimatrix_slice & operator*=(const interval &r)
Assigns the component wise product of the sparse slice and r to the slice.
friend srmatrix InfIm(const scimatrix_slice &)
Returns the imaginary part of the infimum of the slice S.
scimatrix_slice & operator+=(const scimatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const real &r)
Assigns the component wise product of the sparse slice and r to the slice.
scimatrix_slice & operator*=(const scmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Represents a row or column vector of a sparse matrix.
friend srvector InfIm(const scimatrix_subv &)
Returns the imaginary part of the infimum of the subvector.
scimatrix_subv & operator-=(const srvector &)
Assign the difference of the subvector with a vector to the subvector.
friend srvector SupRe(const scimatrix_subv &)
Returns the real part of the supremum of the subvector.
scimatrix_subv & operator=(const rvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const srvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator+=(const srvector &)
Assign the sum of the subvector with a vector to the subvector.
scimatrix_subv & operator=(const sivector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const scivector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const cvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator|=(const srvector &)
Assign the convex hull of the subvector and a vector to the subvector.
scimatrix_subv & operator=(const sivector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const srvector_slice &v)
Assigns a vector to a subvector.
friend int Lb(const scimatrix_subv &)
Returns the lower index bound of the subvector.
scimatrix_subv & operator=(const scimatrix_subv &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const srmatrix_subv &v)
Assigns a vector to a subvector.
friend int Ub(const scimatrix_subv &)
Returns the upper index bound of the subvector.
friend sivector Im(const scimatrix_subv &)
Returns the imaginary part of the subvector.
scimatrix_subv & operator/=(const real &)
Assign the componentwise division of the subvector with a scalar to the subvector.
scimatrix_subv & operator=(const scivector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const cinterval &v)
Assigns v to all elements of the subvector.
friend scvector Inf(const scimatrix_subv &)
Returns the infimum of the subvector.
scimatrix_subv & operator=(const ivector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const real &v)
Assigns v to all elements of the subvector.
friend scivector operator-(const scimatrix_subv &)
Unary negation operator.
friend std::istream & operator>>(std::istream &, scimatrix_subv &)
Standard input operator for subvectors.
scimatrix_subv & operator=(const complex &v)
Assigns v to all elements of the subvector.
scimatrix_subv & operator=(const civector &v)
Assigns a vector to a subvector.
friend int VecLen(const scimatrix_subv &)
Returns the length of the subvector.
friend srvector SupIm(const scimatrix_subv &)
Returns the imaginary part of the supremum of the subvector.
const cinterval operator[](const int i) const
Returns a copy of the i-th element of the subvector.
scimatrix_subv & operator=(const simatrix_subv &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const interval &v)
Assigns v to all elements of the subvector.
scimatrix_subv & operator=(const scmatrix_subv &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const civector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const cvector_slice &v)
Assigns a vector to a subvector.
cinterval & operator[](const int i)
Returns a reference to the i-th element of the subvector.
friend srvector InfRe(const scimatrix_subv &)
Returns the real part of the infimum of the subvector.
scimatrix_subv & operator=(const rvector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator*=(const real &)
Assign the componentwise product of the subvector with a scalar to the subvector.
friend scvector Sup(const scimatrix_subv &)
Returns the supremum of the subvector.
friend sivector Re(const scimatrix_subv &)
Returns the real part of the subvector.
scimatrix_subv & operator=(const scvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const ivector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const scvector_slice &v)
Assigns a vector to a subvector.
A sparse complex interval matrix.
Definition scimatrix.hpp:71
scimatrix & operator*=(const imatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator&=(const imatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
friend scimatrix Id(const scimatrix &)
Return a sparse unity matrix of the same dimension as A.
scimatrix & operator*=(const cimatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix(const imatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
friend scimatrix transp(const scimatrix &)
Returns the transpose of A.
scimatrix & operator*=(const rmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator|=(const cimatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix(const simatrix &A)
Creates a sparse interval matrix out of a sparse interval matrix A.
scimatrix(const srmatrix &A)
Creates a sparse interval matrix out of a sparse real matrix A.
scimatrix operator()(const intvector &pervec)
Performs a row permutation using a permutation vector.
scimatrix & operator&=(const cimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator=(const complex &A)
Assigns a complex value to all elements of the matrix (resulting in a dense matrix!...
scimatrix & operator|=(const srmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator&=(const scimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator+=(const srmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const imatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator+=(const scimatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const cmatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix_subv operator[](const cxscmatrix_column &)
Returns a column of the matrix as a sparse subvector object.
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
scimatrix & operator|=(const cimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator-=(const simatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator|=(const rmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
friend scmatrix mid(const scimatrix &)
Returns the componentwise midpoint of the matrix A.
scimatrix & operator*=(const srmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator+=(const cimatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator+=(const imatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const real &A)
Assigns a real value to all elements of the matrix (resulting in a dense matrix!)
std::vector< cinterval > & values()
Returns a reference to the vector containing the stored values (the array)
Definition scimatrix.hpp:94
friend scmatrix Sup(const scimatrix &)
Returns the Supremum of the matrix A.
scimatrix(const int r, const int c)
Creates an empty matrix with r rows and c columns, pre-reserving space for 2*(r+c) elements.
scimatrix & operator|=(const scimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
friend int RowLen(const scimatrix &)
Returns the number of columns of the matrix.
const std::vector< int > & row_indices() const
Returns a constant reference to the vector containing the row indices (the array)
friend int Lb(const scimatrix &, int)
Returns the lower index bound for the rows or columns of A.
friend srmatrix InfIm(const scimatrix &)
Returns the imaginary part of the infimum of the matrix A.
friend scmatrix diam(const scimatrix &)
Returns the componentwise diameter of the matrix A.
void full(cimatrix &A) const
Creates a full matrix out of the sparse matrix and stores it in A. This should normally be done using...
scimatrix & operator|=(const scmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator+=(const scmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator/=(const interval &r)
Divide all elements of the sparse matrix by r and assign the result to it.
scimatrix & operator|=(const imatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator&=(const cimatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator=(const simatrix &A)
Assign a sparse complex to a sparse interval matrix.
scimatrix & operator-=(const rmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator-=(const cmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator-=(const imatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator-=(const cimatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator/=(const real &r)
Divide all elements of the sparse matrix by r and assign the result to it.
scimatrix(const cimatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
scimatrix & operator-=(const cmatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator+=(const cmatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator*=(const complex &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
scimatrix(const cmatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
scimatrix operator()(const intmatrix &P)
Performs a row permutation using the permutation matrix P. Faster than explicitly computing the produ...
scimatrix & operator|=(const imatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator|=(const cmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator=(const rmatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator*=(const scimatrix &B)
Multiply the sparse matrix by B and assign the result to it.
friend srmatrix SupRe(const scimatrix &)
Returns the real part of the supremum of the matrix A.
scimatrix(const rmatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
friend int Ub(const scimatrix &, int)
Returns the upper index bound for the rows or columns of A.
scimatrix & operator+=(const simatrix &B)
Add B to the sparse matrix and assign the result to it.
friend srmatrix CompMat(const scimatrix &)
Returns Ostroswkis comparison matrix for A.
scimatrix & operator*=(const simatrix &B)
Multiply the sparse matrix by B and assign the result to it.
const std::vector< int > & column_pointers() const
Returns a constant reference to the vector containing the column pointers (the array)
Definition scimatrix.hpp:99
friend simatrix Im(const scimatrix &)
Returns the imaginary part of the matrix A.
scimatrix operator()(const intvector &pervec, const intvector &q)
Performs a row and column permutation using two permutation vectors.
friend std::istream & operator>>(std::istream &, scimatrix_slice &)
Standard input operator for sparse matrix slice.
scimatrix & operator+=(const cmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator|=(const cmatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix(const int m, const int n, const int nnz, const int *rows, const int *cols, const cinterval *values, const enum STORAGE_TYPE t=triplet)
Creates a sparse matrix out of three arrays forming a matrix stored in triplet, compressed row or com...
scimatrix & operator=(const cmatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator-=(const cimatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator*=(const rmatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
std::vector< int > & row_indices()
Returns a reference to the vector containing the row indices (the array)
Definition scimatrix.hpp:89
scimatrix(const int r, const int c, const int e)
Creates an empty matrix with r rows and c columns, pre-reserving space for e elements.
scimatrix & operator*=(const scmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator-=(const rmatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
friend int ColLen(const scimatrix &)
Returns the number of rows of the matrix.
friend srmatrix InfRe(const scimatrix &)
Returns the real part of the infimum of the matrix A.
scimatrix & operator&=(const simatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator|=(const rmatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix(const int m, const int n, const int nnz, const intvector &rows, const intvector &cols, const civector &values, const enum STORAGE_TYPE t=triplet)
Creates a sparse matrix out of three vectors (arrays) forming a matrix stored in triplet,...
scimatrix & operator=(const cinterval &A)
Assigns a complex interval value to all elements of the matrix (resulting in a dense matrix!...
scimatrix & operator*=(const cmatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
friend void SetLb(scimatrix &, const int, const int)
Sets the lower index bound of the rows (i==ROW) or columns (i==COL) to j.
scimatrix & operator-=(const scmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
void dropzeros()
Drops explicitly stored zeros from the data structure.
scimatrix(const int ms, const int ns, const cimatrix &A)
Constructor for banded matrices.
std::vector< int > & column_pointers()
Returns a reference to the vector containing the column pointers (the array)
Definition scimatrix.hpp:84
scimatrix & operator/=(const complex &r)
Divide all elements of the sparse matrix by r and assign the result to it.
scimatrix()
Standard constructor, creates an empty matrix of dimension 0x0.
scimatrix & operator=(const imatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator+=(const imatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator+=(const rmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const rmatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator*=(const real &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
scimatrix & operator=(const cimatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator=(const cimatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator-=(const imatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator*=(const cimatrix &B)
Multiply the sparse matrix by B and assign the result to it.
const cinterval operator()(int i, int j) const
Returns a copy of the element in row i and column j.
scimatrix & operator/=(const cinterval &r)
Divide all elements of the sparse matrix by r and assign the result to it.
friend simatrix Re(const scimatrix &)
Returns the real part of the matrix A.
scimatrix & operator=(const interval &A)
Assigns an interval value to all elements of the matrix (resulting in a dense matrix!...
scimatrix(const scmatrix &A)
Creates a sparse interval matrix out of a sparse complex matrix A.
scimatrix & operator|=(const simatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
cinterval & element(int i, int j)
Returns a reference to the element (i,j) of the matrix.
scimatrix & operator=(const srmatrix &A)
Assign a sparse real to a sparse complex interval matrix.
scimatrix & operator+=(const rmatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator*=(const imatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
friend srmatrix SupIm(const scimatrix &)
Returns the imaginary part of the supremum of the matrix A.
const std::vector< cinterval > & values() const
Returns a constant reference to the vector containing the stored values (the array)
scimatrix & operator-=(const scimatrix &B)
Subtract B from the sparse matrix and assign the result to it.
friend void SetUb(scimatrix &, const int, const int)
Sets the upper index bound of the rows (i==ROW) or columns (i==COL) to j.
scimatrix & operator-=(const srmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
friend simatrix abs(const scimatrix &)
Returns the componentwise absolute value of the matrix A.
scimatrix & operator=(const scmatrix &A)
Assign a sparse complex to a sparse complex interval matrix.
scimatrix & operator*=(const cmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator&=(const imatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator*=(const interval &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
scimatrix & operator+=(const cimatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator*=(const cinterval &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
friend scimatrix conj(const scimatrix &)
Returns the conjugate complex of the matrix A.
scimatrix operator()(const intmatrix &P, const intmatrix &Q)
Performs row and column permutations using the two permutation matrices P and Q. Faster than explicit...
friend scmatrix Inf(const scimatrix &)
Returns the Infimum of the matrix A.
real density() const
Returns the density (the number of non-zeros divided by the number of elements) of the matrix.
Helper class for slices of sparse vectors.
A sparse complex interval vector.
Definition scivector.hpp:62
scivector()
Default constructor, creates an empty vector of size 0
Definition scivector.hpp:72
A slice of a sparse complex matrix.
Represents a row or column vector of a sparse matrix.
A sparse complex matrix.
Definition scmatrix.hpp:69
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
Definition scmatrix.hpp:684
void dropzeros()
Drops explicitly stored zeros from the data structure.
Definition scmatrix.hpp:473
Helper class for slices of sparse vectors.
A sparse complex vector.
Definition scvector.hpp:58
A slice of a sparse real interval matrix.
Represents a row or column vector of a sparse matrix.
A sparse interval matrix.
Definition simatrix.hpp:69
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
Definition simatrix.hpp:684
void dropzeros()
Drops explicitly stored zeros from the data structure.
Definition simatrix.hpp:473
Helper class for slices of sparse vectors.
A sparse interval vector.
Definition sivector.hpp:59
A slice of a sparse real matrix.
Represents a row or column vector of a sparse matrix.
A sparse real matrix.
Definition srmatrix.hpp:77
void dropzeros()
Drops explicitly stored zeros from the data structure.
Definition srmatrix.hpp:449
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
Definition srmatrix.hpp:630
Helper class for slices of sparse vectors.
Definition srvector.hpp:868
A sparse real vector.
Definition srvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
int ColLen(const cimatrix &)
Returns the column dimension.
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski's comparison matrix.
Definition cimatrix.cpp:45
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
Definition cimatrix.cpp:74
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int RowLen(const cimatrix &)
Returns the row dimension.
STORAGE_TYPE
Enumeration depicting the storage type of a sparse matrix (Triplet storage, Compressed column storage...
Definition srmatrix.hpp:42
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition cimatrix.cpp:61
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.