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 
46 namespace cxsc {
47 
48 //definiert in srmatrix.hpp
49 //enum STORAGE_TYPE{triplet,compressed_row,compressed_column};
50 
51 class scimatrix_slice;
52 class scimatrix_subv;
53 
54 inline bool comp_pair_ci(std::pair<int,cinterval> p1, std::pair<int,cinterval> p2) {
55  return p1.first < p2.first;
56 }
57 
59 
71 class 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 
513  scimatrix(const srmatrix_slice&);
515  scimatrix(const scmatrix_slice&);
517  scimatrix(const simatrix_slice&);
519  scimatrix(const scimatrix_slice&);
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 
561  scimatrix& operator=(const real& A) {
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 
766  scimatrix operator()(const intvector& pervec) {
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 
790  scimatrix operator()(const intmatrix& P, const intmatrix& Q) {
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 
1165 inline cimatrix::cimatrix(const srmatrix& A) {
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 
1178 inline cimatrix::cimatrix(const simatrix& A) {
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 
1191 inline cimatrix::cimatrix(const scmatrix& A) {
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 
1204 inline cimatrix::cimatrix(const scimatrix& A) {
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 
1218 inline 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 
1241 inline 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 
1266 inline 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 
1306 inline 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 
1321 inline 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 
1335 inline 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 
1348 inline 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 
1358 inline int RowLen(const scimatrix& A) {
1359  return A.n;
1360 }
1361 
1363 inline int ColLen(const scimatrix& A) {
1364  return A.m;
1365 }
1366 
1368 inline void Resize(scimatrix& A) {
1369  sp_m_resize(A);
1370 }
1371 
1373 inline void Resize(scimatrix& A, const int m, const int n) {
1374  sp_m_resize(A,m,n);
1375 }
1376 
1378 inline 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 
1383 inline 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 
1401 inline 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 
1419 inline 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 
1437 inline 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 
1455 inline 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 
1473 inline 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 
1491 inline 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 
1509 inline 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 
1527 inline 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 
1545 inline 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 
1563 inline 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 
1581 inline 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 
1605 inline cimatrix operator*(const cimatrix& A, const srmatrix& B) {
1606  return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(A,B);
1607 }
1608 
1610 
1616 inline cimatrix operator*(const cimatrix& A, const scmatrix& B) {
1617  return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
1618 }
1619 
1621 
1627 inline cimatrix operator*(const cimatrix& A, const simatrix& B) {
1628  return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(A,B);
1629 }
1630 
1632 
1638 inline cimatrix operator*(const cimatrix& A, const scimatrix& B) {
1639  return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1640 }
1641 
1643 
1649 inline cimatrix operator*(const rmatrix& A, const scimatrix& B) {
1650  return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1651 }
1652 
1654 
1660 inline cimatrix operator*(const cmatrix& A, const scimatrix& B) {
1661  return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1662 }
1663 
1665 
1671 inline cimatrix operator*(const imatrix& A, const scimatrix& B) {
1672  return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1673 }
1674 
1676 
1682 inline cimatrix operator*(const cmatrix& A, const simatrix& B) {
1683  return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(A,B);
1684 }
1685 
1687 
1693 inline cimatrix operator*(const imatrix& A, const scmatrix& B) {
1694  return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
1695 }
1696 
1698 
1704 inline cimatrix operator*(const scimatrix& A, const rmatrix& B) {
1705  return spf_mm_mult<scimatrix,rmatrix,cimatrix,sparse_cidot>(A,B);
1706 }
1707 
1709 
1715 inline cimatrix operator*(const scimatrix& A, const cmatrix& B) {
1716  return spf_mm_mult<scimatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
1717 }
1718 
1720 
1726 inline cimatrix operator*(const scimatrix& A, const imatrix& B) {
1727  return spf_mm_mult<scimatrix,imatrix,cimatrix,sparse_cidot>(A,B);
1728 }
1729 
1731 
1737 inline cimatrix operator*(const scimatrix& A, const cimatrix& B) {
1738  return spf_mm_mult<scimatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1739 }
1740 
1742 
1748 inline cimatrix operator*(const srmatrix& A, const cimatrix& B) {
1749  return spf_mm_mult<srmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1750 }
1751 
1753 
1759 inline cimatrix operator*(const scmatrix& A, const cimatrix& B) {
1760  return spf_mm_mult<scmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1761 }
1762 
1764 
1770 inline cimatrix operator*(const simatrix& A, const cimatrix& B) {
1771  return spf_mm_mult<simatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1772 }
1773 
1775 
1781 inline cimatrix operator*(const scmatrix& A, const imatrix& B) {
1782  return spf_mm_mult<scmatrix,imatrix,cimatrix,sparse_cidot>(A,B);
1783 }
1784 
1786 
1792 inline cimatrix operator*(const simatrix& A, const cmatrix& B) {
1793  return spf_mm_mult<simatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
1794 }
1795 
1797 
1803 inline 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 
1814 inline 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 
1825 inline 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 
1836 inline 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 
1847 inline 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 
1858 inline 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 
1869 inline 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 
1880 inline 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 
1891 inline 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 
1902 inline 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 
1913 inline 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 
1924 inline 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 
1935 inline 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 
1946 inline 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 
1957 inline 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 
1968 inline 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 
1979 inline 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 
1990 inline 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 
2001 inline scimatrix operator*(const scimatrix& A, const srmatrix& B) {
2002  return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2003 }
2004 
2006 
2012 inline scimatrix operator*(const scimatrix& A, const scmatrix& B) {
2013  return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2014 }
2015 
2017 
2023 inline scimatrix operator*(const scimatrix& A, const simatrix& B) {
2024  return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2025 }
2026 
2028 
2034 inline scimatrix operator*(const scimatrix& A, const scimatrix& B) {
2035  return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2036 }
2037 
2039 
2045 inline scimatrix operator*(const srmatrix& A, const scimatrix& B) {
2046  return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2047 }
2048 
2050 
2056 inline scimatrix operator*(const scmatrix& A, const scimatrix& B) {
2057  return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2058 }
2059 
2061 
2067 inline scimatrix operator*(const simatrix& A, const scimatrix& B) {
2068  return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2069 }
2070 
2072 
2078 inline scimatrix operator*(const scmatrix& A, const simatrix& B) {
2079  return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2080 }
2081 
2083 
2089 inline scimatrix operator*(const simatrix& A, const scmatrix& B) {
2090  return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2091 }
2092 
2094 inline scimatrix operator/(const scimatrix& A, const real& r) {
2095  return sp_ms_div<scimatrix,real,scimatrix>(A,r);
2096 }
2097 
2099 inline scimatrix operator/(const scimatrix& A, const complex& r) {
2100  return sp_ms_div<scimatrix,complex,scimatrix>(A,r);
2101 }
2102 
2104 inline scimatrix operator/(const scimatrix& A, const interval& r) {
2105  return sp_ms_div<scimatrix,interval,scimatrix>(A,r);
2106 }
2107 
2109 inline scimatrix operator/(const scimatrix& A, const cinterval& r) {
2110  return sp_ms_div<scimatrix,cinterval,scimatrix>(A,r);
2111 }
2112 
2114 inline scimatrix operator/(const srmatrix& A, const cinterval& r) {
2115  return sp_ms_div<srmatrix,cinterval,scimatrix>(A,r);
2116 }
2117 
2119 inline scimatrix operator/(const simatrix& A, const cinterval& r) {
2120  return sp_ms_div<simatrix,cinterval,scimatrix>(A,r);
2121 }
2122 
2124 inline scimatrix operator/(const scmatrix& A, const cinterval& r) {
2125  return sp_ms_div<scmatrix,cinterval,scimatrix>(A,r);
2126 }
2127 
2129 inline scimatrix operator/(const scmatrix& A, const interval& r) {
2130  return sp_ms_div<scmatrix,interval,scimatrix>(A,r);
2131 }
2132 
2134 inline scimatrix operator/(const simatrix& A, const complex& r) {
2135  return sp_ms_div<simatrix,complex,scimatrix>(A,r);
2136 }
2137 
2139 inline scimatrix operator*(const scimatrix& A, const real& r) {
2140  return sp_ms_mult<scimatrix,real,scimatrix>(A,r);
2141 }
2142 
2144 inline scimatrix operator*(const scimatrix& A, const complex& r) {
2145  return sp_ms_mult<scimatrix,complex,scimatrix>(A,r);
2146 }
2147 
2149 inline scimatrix operator*(const scimatrix& A, const interval& r) {
2150  return sp_ms_mult<scimatrix,interval,scimatrix>(A,r);
2151 }
2152 
2154 inline scimatrix operator*(const scimatrix& A, const cinterval& r) {
2155  return sp_ms_mult<scimatrix,cinterval,scimatrix>(A,r);
2156 }
2157 
2159 inline scimatrix operator*(const srmatrix& A, const cinterval& r) {
2160  return sp_ms_mult<srmatrix,cinterval,scimatrix>(A,r);
2161 }
2162 
2164 inline scimatrix operator*(const simatrix& A, const cinterval& r) {
2165  return sp_ms_mult<simatrix,cinterval,scimatrix>(A,r);
2166 }
2167 
2169 inline scimatrix operator*(const scmatrix& A, const cinterval& r) {
2170  return sp_ms_mult<scmatrix,cinterval,scimatrix>(A,r);
2171 }
2172 
2174 inline scimatrix operator*(const scmatrix& A, const interval& r) {
2175  return sp_ms_mult<scmatrix,interval,scimatrix>(A,r);
2176 }
2177 
2179 inline scimatrix operator*(const simatrix& A, const complex& r) {
2180  return sp_ms_mult<simatrix,complex,scimatrix>(A,r);
2181 }
2182 
2184 inline scimatrix operator*(const real& r, const scimatrix& A) {
2185  return sp_sm_mult<real,scimatrix,scimatrix>(r,A);
2186 }
2187 
2189 inline scimatrix operator*(const complex& r, const scimatrix& A) {
2190  return sp_sm_mult<complex,scimatrix,scimatrix>(r,A);
2191 }
2192 
2194 inline scimatrix operator*(const interval& r, const scimatrix& A) {
2195  return sp_sm_mult<interval,scimatrix,scimatrix>(r,A);
2196 }
2197 
2199 inline scimatrix operator*(const cinterval& r, const scimatrix& A) {
2200  return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,A);
2201 }
2202 
2204 inline scimatrix operator*(const cinterval& r, const srmatrix& A) {
2205  return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,A);
2206 }
2207 
2209 inline scimatrix operator*(const cinterval& r, const simatrix& A) {
2210  return sp_sm_mult<cinterval,simatrix,scimatrix>(r,A);
2211 }
2212 
2214 inline scimatrix operator*(const cinterval& r, const scmatrix& A) {
2215  return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,A);
2216 }
2217 
2219 inline scimatrix operator*(const complex& r, const simatrix& A) {
2220  return sp_sm_mult<complex,simatrix,scimatrix>(r,A);
2221 }
2222 
2224 inline scimatrix operator*(const interval& r, const scmatrix& A) {
2225  return sp_sm_mult<interval,scmatrix,scimatrix>(r,A);
2226 }
2227 
2229 
2235 inline civector operator*(const scimatrix& A, const rvector& v) {
2236  return spf_mv_mult<scimatrix,rvector,civector,sparse_cidot>(A,v);
2237 }
2238 
2240 
2246 inline civector operator*(const scimatrix& A, const cvector& v) {
2247  return spf_mv_mult<scimatrix,cvector,civector,sparse_cidot>(A,v);
2248 }
2249 
2251 
2257 inline civector operator*(const scimatrix& A, const ivector& v) {
2258  return spf_mv_mult<scimatrix,ivector,civector,sparse_cidot>(A,v);
2259 }
2260 
2262 
2268 inline civector operator*(const scimatrix& A, const civector& v) {
2269  return spf_mv_mult<scimatrix,civector,civector,sparse_cidot>(A,v);
2270 }
2271 
2273 
2279 inline civector operator*(const srmatrix& A, const civector& v) {
2280  return spf_mv_mult<srmatrix,civector,civector,sparse_cidot>(A,v);
2281 }
2282 
2284 
2290 inline civector operator*(const scmatrix& A, const civector& v) {
2291  return spf_mv_mult<scmatrix,civector,civector,sparse_cidot>(A,v);
2292 }
2293 
2295 
2301 inline civector operator*(const simatrix& A, const civector& v) {
2302  return spf_mv_mult<simatrix,civector,civector,sparse_cidot>(A,v);
2303 }
2304 
2306 
2312 inline civector operator*(const scmatrix& A, const ivector& v) {
2313  return spf_mv_mult<scmatrix,ivector,civector,sparse_cidot>(A,v);
2314 }
2315 
2317 
2323 inline civector operator*(const simatrix& A, const cvector& v) {
2324  return spf_mv_mult<simatrix,cvector,civector,sparse_cidot>(A,v);
2325 }
2326 
2328 
2334 inline 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 
2345 inline 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 
2356 inline 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 
2367 inline 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 
2378 inline 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 
2389 inline 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 
2400 inline 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 
2411 inline 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 
2422 inline 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 
2433 inline scivector operator*(const scimatrix& A, const srvector& v) {
2434  return spsp_mv_mult<scimatrix,srvector,scivector,sparse_cidot,cinterval>(A,v);
2435 }
2436 
2438 
2444 inline scivector operator*(const scimatrix& A, const sivector& v) {
2445  return spsp_mv_mult<scimatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
2446 }
2447 
2449 
2455 inline scivector operator*(const scimatrix& A, const scvector& v) {
2456  return spsp_mv_mult<scimatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
2457 }
2458 
2460 
2466 inline scivector operator*(const scimatrix& A, const scivector& v) {
2467  return spsp_mv_mult<scimatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2468 }
2469 
2471 
2477 inline scivector operator*(const srmatrix& A, const scivector& v) {
2478  return spsp_mv_mult<srmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2479 }
2480 
2482 
2488 inline scivector operator*(const scmatrix& A, const scivector& v) {
2489  return spsp_mv_mult<scmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2490 }
2491 
2493 
2499 inline scivector operator*(const simatrix& A, const scivector& v) {
2500  return spsp_mv_mult<simatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2501 }
2503 
2509 inline scivector operator*(const scmatrix& A, const sivector& v) {
2510  return spsp_mv_mult<scmatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
2511 }
2512 
2514 
2520 inline scivector operator*(const simatrix& A, const scvector& v) {
2521  return spsp_mv_mult<simatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
2522 }
2523 
2525 
2531 inline 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 
2542 inline 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 
2553 inline 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 
2564 inline 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 
2575 inline 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 
2586 inline 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 
2597 inline 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 
2608 inline 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 
2619 inline 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 
2630 inline civector operator*(const cimatrix& A, const srvector& v) {
2631  return fsp_mv_mult<cimatrix,srvector,civector,sparse_cidot>(A,v);
2632 }
2633 
2635 
2641 inline civector operator*(const cimatrix& A, const sivector& v) {
2642  return fsp_mv_mult<cimatrix,sivector,civector,sparse_cidot>(A,v);
2643 }
2644 
2646 
2652 inline civector operator*(const cimatrix& A, const scvector& v) {
2653  return fsp_mv_mult<cimatrix,scvector,civector,sparse_cidot>(A,v);
2654 }
2655 
2657 
2663 inline civector operator*(const cimatrix& A, const scivector& v) {
2664  return fsp_mv_mult<cimatrix,scivector,civector,sparse_cidot>(A,v);
2665 }
2666 
2668 
2674 inline civector operator*(const rmatrix& A, const scivector& v) {
2675  return fsp_mv_mult<rmatrix,scivector,civector,sparse_cidot>(A,v);
2676 }
2677 
2679 
2685 inline civector operator*(const cmatrix& A, const scivector& v) {
2686  return fsp_mv_mult<cmatrix,scivector,civector,sparse_cidot>(A,v);
2687 }
2688 
2690 
2696 inline civector operator*(const imatrix& A, const scivector& v) {
2697  return fsp_mv_mult<imatrix,scivector,civector,sparse_cidot>(A,v);
2698 }
2699 
2701 
2707 inline civector operator*(const cmatrix& A, const sivector& v) {
2708  return fsp_mv_mult<cmatrix,sivector,civector,sparse_cidot>(A,v);
2709 }
2710 
2712 
2718 inline civector operator*(const imatrix& A, const scvector& v) {
2719  return fsp_mv_mult<imatrix,scvector,civector,sparse_cidot>(A,v);
2720 }
2721 
2723 
2729 inline 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 
2740 inline 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 
2751 inline 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 
2762 inline 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 
2773 inline 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 
2784 inline 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 
2795 inline 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 
2806 inline 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 
2817 inline 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 
2828 inline 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 
2839 inline 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 
2850 inline 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 
2861 inline 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 
2872 inline 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 
2883 inline 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 
2894 inline 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 
2905 inline 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 
2916 inline 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 
2927 inline civector operator*(const cimatrix_slice& A, const srvector_slice& v) {
2928  return fsl_mv_mult<cimatrix_slice,srvector_slice,civector,sparse_cidot>(A,v);
2929 }
2930 
2932 
2938 inline civector operator*(const cimatrix_slice& A, const scvector_slice& v) {
2939  return fsl_mv_mult<cimatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
2940 }
2941 
2943 
2949 inline civector operator*(const cimatrix_slice& A, const sivector_slice& v) {
2950  return fsl_mv_mult<cimatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
2951 }
2952 
2954 
2960 inline civector operator*(const cimatrix_slice& A, const scivector_slice& v) {
2961  return fsl_mv_mult<cimatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2962 }
2963 
2965 
2971 inline civector operator*(const rmatrix_slice& A, const scivector_slice& v) {
2972  return fsl_mv_mult<rmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2973 }
2974 
2976 
2982 inline civector operator*(const imatrix_slice& A, const scivector_slice& v) {
2983  return fsl_mv_mult<imatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2984 }
2985 
2987 
2993 inline civector operator*(const cmatrix_slice& A, const scivector_slice& v) {
2994  return fsl_mv_mult<cmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2995 }
2996 
2998 
3004 inline civector operator*(const cmatrix_slice& A, const sivector_slice& v) {
3005  return fsl_mv_mult<cmatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
3006 }
3007 
3009 
3015 inline civector operator*(const imatrix_slice& A, const scvector_slice& v) {
3016  return fsl_mv_mult<imatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
3017 }
3018 
3020 inline cimatrix operator+(const cimatrix& A, const srmatrix& B) {
3021  return fsp_mm_add<cimatrix,srmatrix,cimatrix>(A,B);
3022 }
3023 
3025 inline cimatrix operator+(const cimatrix& A, const scmatrix& B) {
3026  return fsp_mm_add<cimatrix,scmatrix,cimatrix>(A,B);
3027 }
3028 
3030 inline cimatrix operator+(const cimatrix& A, const simatrix& B) {
3031  return fsp_mm_add<cimatrix,simatrix,cimatrix>(A,B);
3032 }
3033 
3035 inline cimatrix operator+(const cimatrix& A, const scimatrix& B) {
3036  return fsp_mm_add<cimatrix,scimatrix,cimatrix>(A,B);
3037 }
3038 
3040 inline cimatrix operator+(const rmatrix& A, const scimatrix& B) {
3041  return fsp_mm_add<rmatrix,scimatrix,cimatrix>(A,B);
3042 }
3043 
3045 inline cimatrix operator+(const cmatrix& A, const scimatrix& B) {
3046  return fsp_mm_add<cmatrix,scimatrix,cimatrix>(A,B);
3047 }
3048 
3050 inline cimatrix operator+(const imatrix& A, const scimatrix& B) {
3051  return fsp_mm_add<imatrix,scimatrix,cimatrix>(A,B);
3052 }
3053 
3055 inline cimatrix operator+(const imatrix& A, const scmatrix& B) {
3056  return fsp_mm_add<imatrix,scmatrix,cimatrix>(A,B);
3057 }
3058 
3060 inline cimatrix operator+(const cmatrix& A, const simatrix& B) {
3061  return fsp_mm_add<cmatrix,simatrix,cimatrix>(A,B);
3062 }
3063 
3065 inline cimatrix operator+(const scimatrix& A, const rmatrix& B) {
3066  return spf_mm_add<scimatrix,rmatrix,cimatrix>(A,B);
3067 }
3068 
3070 inline cimatrix operator+(const scimatrix& A, const cmatrix& B) {
3071  return spf_mm_add<scimatrix,cmatrix,cimatrix>(A,B);
3072 }
3073 
3075 inline cimatrix operator+(const scimatrix& A, const imatrix& B) {
3076  return spf_mm_add<scimatrix,imatrix,cimatrix>(A,B);
3077 }
3078 
3080 inline cimatrix operator+(const scimatrix& A, const cimatrix& B) {
3081  return spf_mm_add<scimatrix,cimatrix,cimatrix>(A,B);
3082 }
3083 
3085 inline cimatrix operator+(const srmatrix& A, const cimatrix& B) {
3086  return spf_mm_add<srmatrix,cimatrix,cimatrix>(A,B);
3087 }
3088 
3090 inline cimatrix operator+(const scmatrix& A, const cimatrix& B) {
3091  return spf_mm_add<scmatrix,cimatrix,cimatrix>(A,B);
3092 }
3093 
3095 inline cimatrix operator+(const simatrix& A, const cimatrix& B) {
3096  return spf_mm_add<simatrix,cimatrix,cimatrix>(A,B);
3097 }
3098 
3100 inline cimatrix operator+(const simatrix& A, const cmatrix& B) {
3101  return spf_mm_add<simatrix,cmatrix,cimatrix>(A,B);
3102 }
3103 
3105 inline cimatrix operator+(const scmatrix& A, const imatrix& B) {
3106  return spf_mm_add<scmatrix,imatrix,cimatrix>(A,B);
3107 }
3108 
3110 inline cimatrix operator+(const cimatrix_slice& A, const srmatrix& B) {
3111  return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(A,B);
3112 }
3113 
3115 inline cimatrix operator+(const cimatrix_slice& A, const simatrix& B) {
3116  return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(A,B);
3117 }
3118 
3120 inline cimatrix operator+(const cimatrix_slice& A, const scmatrix& B) {
3121  return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(A,B);
3122 }
3123 
3125 inline cimatrix operator+(const cimatrix_slice& A, const scimatrix& B) {
3126  return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(A,B);
3127 }
3128 
3130 inline cimatrix operator+(const rmatrix_slice& A, const scimatrix& B) {
3131  return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(A,B);
3132 }
3133 
3135 inline cimatrix operator+(const imatrix_slice& A, const scimatrix& B) {
3136  return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(A,B);
3137 }
3138 
3140 inline cimatrix operator+(const cmatrix_slice& A, const scimatrix& B) {
3141  return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(A,B);
3142 }
3143 
3145 inline cimatrix operator+(const cmatrix_slice& A, const simatrix& B) {
3146  return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(A,B);
3147 }
3148 
3150 inline cimatrix operator+(const imatrix_slice& A, const scmatrix& B) {
3151  return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(A,B);
3152 }
3153 
3155 inline cimatrix operator+(const scimatrix& A, const rmatrix_slice& B) {
3156  return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(A,B);
3157 }
3158 
3160 inline cimatrix operator+(const scimatrix& A, const cmatrix_slice& B) {
3161  return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(A,B);
3162 }
3163 
3165 inline cimatrix operator+(const scimatrix& A, const imatrix_slice& B) {
3166  return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(A,B);
3167 }
3168 
3170 inline cimatrix operator+(const scimatrix& A, const cimatrix_slice& B) {
3171  return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(A,B);
3172 }
3173 
3175 inline cimatrix operator+(const srmatrix& A, const cimatrix_slice& B) {
3176  return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(A,B);
3177 }
3178 
3180 inline cimatrix operator+(const scmatrix& A, const cimatrix_slice& B) {
3181  return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(A,B);
3182 }
3183 
3185 inline cimatrix operator+(const simatrix& A, const cimatrix_slice& B) {
3186  return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(A,B);
3187 }
3188 
3190 inline cimatrix operator+(const simatrix& A, const cmatrix_slice& B) {
3191  return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(A,B);
3192 }
3193 
3195 inline cimatrix operator+(const scmatrix& A, const imatrix_slice& B) {
3196  return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(A,B);
3197 }
3198 
3200 inline scimatrix operator+(const scimatrix& A, const srmatrix& B) {
3201  return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3202 }
3203 
3205 inline scimatrix operator+(const scimatrix& A, const scmatrix& B) {
3206  return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3207 }
3208 
3210 inline scimatrix operator+(const scimatrix& A, const simatrix& B) {
3211  return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3212 }
3213 
3215 inline scimatrix operator+(const scimatrix& A, const scimatrix& B) {
3216  return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3217 }
3218 
3220 inline scimatrix operator+(const srmatrix& A, const scimatrix& B) {
3221  return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3222 }
3223 
3225 inline scimatrix operator+(const scmatrix& A, const scimatrix& B) {
3226  return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3227 }
3228 
3230 inline scimatrix operator+(const simatrix& A, const scimatrix& B) {
3231  return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3232 }
3233 
3235 inline scimatrix operator+(const simatrix& A, const scmatrix& B) {
3236  return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3237 }
3238 
3240 inline scimatrix operator+(const scmatrix& A, const simatrix& B) {
3241  return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3242 }
3243 
3245 inline cimatrix operator-(const cimatrix& A, const srmatrix& B) {
3246  return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(A,B);
3247 }
3248 
3250 inline cimatrix operator-(const cimatrix& A, const scmatrix& B) {
3251  return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(A,B);
3252 }
3253 
3255 inline cimatrix operator-(const cimatrix& A, const simatrix& B) {
3256  return fsp_mm_sub<cimatrix,simatrix,cimatrix>(A,B);
3257 }
3258 
3260 inline cimatrix operator-(const cimatrix& A, const scimatrix& B) {
3261  return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(A,B);
3262 }
3263 
3265 inline cimatrix operator-(const rmatrix& A, const scimatrix& B) {
3266  return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(A,B);
3267 }
3268 
3270 inline cimatrix operator-(const cmatrix& A, const scimatrix& B) {
3271  return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(A,B);
3272 }
3273 
3275 inline cimatrix operator-(const imatrix& A, const scimatrix& B) {
3276  return fsp_mm_sub<imatrix,scimatrix,cimatrix>(A,B);
3277 }
3278 
3280 inline cimatrix operator-(const imatrix& A, const scmatrix& B) {
3281  return fsp_mm_sub<imatrix,scmatrix,cimatrix>(A,B);
3282 }
3283 
3285 inline cimatrix operator-(const cmatrix& A, const simatrix& B) {
3286  return fsp_mm_sub<cmatrix,simatrix,cimatrix>(A,B);
3287 }
3288 
3290 inline cimatrix operator-(const scimatrix& A, const rmatrix& B) {
3291  return spf_mm_sub<scimatrix,rmatrix,cimatrix>(A,B);
3292 }
3293 
3295 inline cimatrix operator-(const scimatrix& A, const cmatrix& B) {
3296  return spf_mm_sub<scimatrix,cmatrix,cimatrix>(A,B);
3297 }
3298 
3300 inline cimatrix operator-(const scimatrix& A, const imatrix& B) {
3301  return spf_mm_sub<scimatrix,imatrix,cimatrix>(A,B);
3302 }
3303 
3305 inline cimatrix operator-(const scimatrix& A, const cimatrix& B) {
3306  return spf_mm_sub<scimatrix,cimatrix,cimatrix>(A,B);
3307 }
3308 
3310 inline cimatrix operator-(const srmatrix& A, const cimatrix& B) {
3311  return spf_mm_sub<srmatrix,cimatrix,cimatrix>(A,B);
3312 }
3313 
3315 inline cimatrix operator-(const scmatrix& A, const cimatrix& B) {
3316  return spf_mm_sub<scmatrix,cimatrix,cimatrix>(A,B);
3317 }
3318 
3320 inline cimatrix operator-(const simatrix& A, const cimatrix& B) {
3321  return spf_mm_sub<simatrix,cimatrix,cimatrix>(A,B);
3322 }
3323 
3325 inline cimatrix operator-(const simatrix& A, const cmatrix& B) {
3326  return spf_mm_sub<simatrix,cmatrix,cimatrix>(A,B);
3327 }
3328 
3330 inline cimatrix operator-(const scmatrix& A, const imatrix& B) {
3331  return spf_mm_sub<scmatrix,imatrix,cimatrix>(A,B);
3332 }
3333 
3335 inline cimatrix operator-(const cimatrix_slice& A, const srmatrix& B) {
3336  return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(A,B);
3337 }
3338 
3340 inline cimatrix operator-(const cimatrix_slice& A, const simatrix& B) {
3341  return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(A,B);
3342 }
3343 
3345 inline cimatrix operator-(const cimatrix_slice& A, const scmatrix& B) {
3346  return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(A,B);
3347 }
3348 
3350 inline cimatrix operator-(const cimatrix_slice& A, const scimatrix& B) {
3351  return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(A,B);
3352 }
3353 
3355 inline cimatrix operator-(const rmatrix_slice& A, const scimatrix& B) {
3356  return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(A,B);
3357 }
3358 
3360 inline cimatrix operator-(const imatrix_slice& A, const scimatrix& B) {
3361  return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(A,B);
3362 }
3363 
3365 inline cimatrix operator-(const cmatrix_slice& A, const scimatrix& B) {
3366  return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(A,B);
3367 }
3368 
3370 inline cimatrix operator-(const cmatrix_slice& A, const simatrix& B) {
3371  return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(A,B);
3372 }
3373 
3375 inline cimatrix operator-(const imatrix_slice& A, const scmatrix& B) {
3376  return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(A,B);
3377 }
3378 
3380 inline cimatrix operator-(const scimatrix& A, const rmatrix_slice& B) {
3381  return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(A,B);
3382 }
3383 
3385 inline cimatrix operator-(const scimatrix& A, const cmatrix_slice& B) {
3386  return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(A,B);
3387 }
3388 
3390 inline cimatrix operator-(const scimatrix& A, const imatrix_slice& B) {
3391  return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(A,B);
3392 }
3393 
3395 inline cimatrix operator-(const scimatrix& A, const cimatrix_slice& B) {
3396  return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(A,B);
3397 }
3398 
3400 inline cimatrix operator-(const srmatrix& A, const cimatrix_slice& B) {
3401  return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(A,B);
3402 }
3403 
3405 inline cimatrix operator-(const scmatrix& A, const cimatrix_slice& B) {
3406  return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(A,B);
3407 }
3408 
3410 inline cimatrix operator-(const simatrix& A, const cimatrix_slice& B) {
3411  return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(A,B);
3412 }
3413 
3415 inline cimatrix operator-(const simatrix& A, const cmatrix_slice& B) {
3416  return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(A,B);
3417 }
3418 
3420 inline cimatrix operator-(const scmatrix& A, const imatrix_slice& B) {
3421  return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(A,B);
3422 }
3423 
3425 inline scimatrix operator-(const scimatrix& A, const srmatrix& B) {
3426  return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3427 }
3428 
3430 inline scimatrix operator-(const scimatrix& A, const scmatrix& B) {
3431  return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3432 }
3433 
3435 inline scimatrix operator-(const scimatrix& A, const simatrix& B) {
3436  return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3437 }
3438 
3440 inline scimatrix operator-(const scimatrix& A, const scimatrix& B) {
3441  return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3442 }
3443 
3445 inline scimatrix operator-(const srmatrix& A, const scimatrix& B) {
3446  return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3447 }
3448 
3450 inline scimatrix operator-(const scmatrix& A, const scimatrix& B) {
3451  return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3452 }
3453 
3455 inline scimatrix operator-(const simatrix& A, const scimatrix& B) {
3456  return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3457 }
3458 
3460 inline scimatrix operator-(const simatrix& A, const scmatrix& B) {
3461  return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3462 }
3463 
3465 inline scimatrix operator-(const scmatrix& A, const simatrix& B) {
3466  return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3467 }
3468 
3470 inline cimatrix operator|(const cimatrix& A, const srmatrix& B) {
3471  return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(A,B);
3472 }
3473 
3475 inline cimatrix operator|(const cimatrix& A, const scmatrix& B) {
3476  return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(A,B);
3477 }
3478 
3480 inline cimatrix operator|(const cimatrix& A, const simatrix& B) {
3481  return fsp_mm_hull<cimatrix,simatrix,cimatrix>(A,B);
3482 }
3483 
3485 inline cimatrix operator|(const cimatrix& A, const scimatrix& B) {
3486  return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(A,B);
3487 }
3488 
3490 inline cimatrix operator|(const rmatrix& A, const scimatrix& B) {
3491  return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(A,B);
3492 }
3493 
3495 inline cimatrix operator|(const cmatrix& A, const scimatrix& B) {
3496  return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(A,B);
3497 }
3498 
3500 inline cimatrix operator|(const imatrix& A, const scimatrix& B) {
3501  return fsp_mm_hull<imatrix,scimatrix,cimatrix>(A,B);
3502 }
3503 
3505 inline cimatrix operator|(const imatrix& A, const scmatrix& B) {
3506  return fsp_mm_hull<imatrix,scmatrix,cimatrix>(A,B);
3507 }
3508 
3510 inline cimatrix operator|(const cmatrix& A, const simatrix& B) {
3511  return fsp_mm_hull<cmatrix,simatrix,cimatrix>(A,B);
3512 }
3513 
3515 inline cimatrix operator|(const scimatrix& A, const rmatrix& B) {
3516  return spf_mm_hull<scimatrix,rmatrix,cimatrix>(A,B);
3517 }
3518 
3520 inline cimatrix operator|(const scimatrix& A, const cmatrix& B) {
3521  return spf_mm_hull<scimatrix,cmatrix,cimatrix>(A,B);
3522 }
3523 
3525 inline cimatrix operator|(const scimatrix& A, const imatrix& B) {
3526  return spf_mm_hull<scimatrix,imatrix,cimatrix>(A,B);
3527 }
3528 
3530 inline cimatrix operator|(const scimatrix& A, const cimatrix& B) {
3531  return spf_mm_hull<scimatrix,cimatrix,cimatrix>(A,B);
3532 }
3533 
3535 inline cimatrix operator|(const srmatrix& A, const cimatrix& B) {
3536  return spf_mm_hull<srmatrix,cimatrix,cimatrix>(A,B);
3537 }
3538 
3540 inline cimatrix operator|(const scmatrix& A, const cimatrix& B) {
3541  return spf_mm_hull<scmatrix,cimatrix,cimatrix>(A,B);
3542 }
3543 
3545 inline cimatrix operator|(const simatrix& A, const cimatrix& B) {
3546  return spf_mm_hull<simatrix,cimatrix,cimatrix>(A,B);
3547 }
3548 
3550 inline cimatrix operator|(const simatrix& A, const cmatrix& B) {
3551  return spf_mm_hull<simatrix,cmatrix,cimatrix>(A,B);
3552 }
3553 
3555 inline cimatrix operator|(const scmatrix& A, const imatrix& B) {
3556  return spf_mm_hull<scmatrix,imatrix,cimatrix>(A,B);
3557 }
3558 
3560 inline cimatrix operator|(const cimatrix_slice& A, const srmatrix& B) {
3561  return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(A,B);
3562 }
3563 
3565 inline cimatrix operator|(const cimatrix_slice& A, const simatrix& B) {
3566  return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(A,B);
3567 }
3568 
3570 inline cimatrix operator|(const cimatrix_slice& A, const scmatrix& B) {
3571  return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(A,B);
3572 }
3573 
3575 inline cimatrix operator|(const cimatrix_slice& A, const scimatrix& B) {
3576  return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(A,B);
3577 }
3578 
3580 inline cimatrix operator|(const rmatrix_slice& A, const scimatrix& B) {
3581  return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(A,B);
3582 }
3583 
3585 inline cimatrix operator|(const imatrix_slice& A, const scimatrix& B) {
3586  return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(A,B);
3587 }
3588 
3590 inline cimatrix operator|(const cmatrix_slice& A, const scimatrix& B) {
3591  return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(A,B);
3592 }
3593 
3595 inline cimatrix operator|(const cmatrix_slice& A, const simatrix& B) {
3596  return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(A,B);
3597 }
3598 
3600 inline cimatrix operator|(const imatrix_slice& A, const scmatrix& B) {
3601  return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(A,B);
3602 }
3603 
3605 inline cimatrix operator|(const scimatrix& A, const rmatrix_slice& B) {
3606  return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(A,B);
3607 }
3608 
3610 inline cimatrix operator|(const scimatrix& A, const cmatrix_slice& B) {
3611  return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(A,B);
3612 }
3613 
3615 inline cimatrix operator|(const scimatrix& A, const imatrix_slice& B) {
3616  return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(A,B);
3617 }
3618 
3620 inline cimatrix operator|(const scimatrix& A, const cimatrix_slice& B) {
3621  return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(A,B);
3622 }
3623 
3625 inline cimatrix operator|(const srmatrix& A, const cimatrix_slice& B) {
3626  return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(A,B);
3627 }
3628 
3630 inline cimatrix operator|(const scmatrix& A, const cimatrix_slice& B) {
3631  return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(A,B);
3632 }
3633 
3635 inline cimatrix operator|(const simatrix& A, const cimatrix_slice& B) {
3636  return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(A,B);
3637 }
3638 
3640 inline cimatrix operator|(const simatrix& A, const cmatrix_slice& B) {
3641  return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(A,B);
3642 }
3643 
3645 inline cimatrix operator|(const scmatrix& A, const imatrix_slice& B) {
3646  return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(A,B);
3647 }
3648 
3650 inline scimatrix operator|(const scimatrix& A, const srmatrix& B) {
3651  return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3652 }
3653 
3655 inline scimatrix operator|(const scimatrix& A, const scmatrix& B) {
3656  return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3657 }
3658 
3660 inline scimatrix operator|(const scimatrix& A, const simatrix& B) {
3661  return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3662 }
3663 
3665 inline scimatrix operator|(const scimatrix& A, const scimatrix& B) {
3666  return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3667 }
3668 
3670 inline scimatrix operator|(const srmatrix& A, const scimatrix& B) {
3671  return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3672 }
3673 
3675 inline scimatrix operator|(const scmatrix& A, const scimatrix& B) {
3676  return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3677 }
3678 
3680 inline scimatrix operator|(const simatrix& A, const scimatrix& B) {
3681  return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3682 }
3683 
3685 inline scimatrix operator|(const simatrix& A, const scmatrix& B) {
3686  return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3687 }
3688 
3690 inline scimatrix operator|(const scmatrix& A, const simatrix& B) {
3691  return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3692 }
3693 
3695 inline cimatrix operator|(const cmatrix& A, const srmatrix& B) {
3696  return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(A,B);
3697 }
3698 
3700 inline cimatrix operator|(const rmatrix& A, const scmatrix& B) {
3701  return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(A,B);
3702 }
3703 
3705 inline cimatrix operator|(const cmatrix& A, const scmatrix& B) {
3706  return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(A,B);
3707 }
3708 
3710 inline cimatrix operator|(const scmatrix& A, const rmatrix& B) {
3711  return spf_mm_hull<scmatrix,rmatrix,cimatrix>(A,B);
3712 }
3713 
3715 inline cimatrix operator|(const srmatrix& A, const cmatrix& B) {
3716  return spf_mm_hull<srmatrix,cmatrix,cimatrix>(A,B);
3717 }
3718 
3720 inline cimatrix operator|(const scmatrix& A, const cmatrix& B) {
3721  return spf_mm_hull<scmatrix,cmatrix,cimatrix>(A,B);
3722 }
3723 
3725 inline cimatrix operator|(const cmatrix_slice& A, const srmatrix& B) {
3726  return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(A,B);
3727 }
3728 
3730 inline cimatrix operator|(const rmatrix_slice& A, const scmatrix& B) {
3731  return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(A,B);
3732 }
3733 
3735 inline cimatrix operator|(const cmatrix_slice& A, const scmatrix& B) {
3736  return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(A,B);
3737 }
3738 
3740 inline cimatrix operator|(const scmatrix& A, const rmatrix_slice& B) {
3741  return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(A,B);
3742 }
3743 
3745 inline cimatrix operator|(const srmatrix& A, const cmatrix_slice& B) {
3746  return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(A,B);
3747 }
3748 
3750 inline cimatrix operator|(const scmatrix& A, const cmatrix_slice& B) {
3751  return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(A,B);
3752 }
3753 
3755 inline scimatrix operator|(const scmatrix& A, const srmatrix& B) {
3756  return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(A,B);
3757 }
3758 
3760 inline scimatrix operator|(const srmatrix& A, const scmatrix& B) {
3761  return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(A,B);
3762 }
3763 
3765 inline scimatrix operator|(const scmatrix& A, const scmatrix& B) {
3766  return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(A,B);
3767 }
3768 
3770 inline cimatrix operator&(const cimatrix& A, const simatrix& B) {
3771  return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(A,B);
3772 }
3773 
3775 inline cimatrix operator&(const cimatrix& A, const scimatrix& B) {
3776  return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(A,B);
3777 }
3778 
3780 inline cimatrix operator&(const imatrix& A, const scimatrix& B) {
3781  return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(A,B);
3782 }
3783 
3785 inline cimatrix operator&(const scimatrix& A, const imatrix& B) {
3786  return spf_mm_intersect<scimatrix,imatrix,cimatrix>(A,B);
3787 }
3788 
3790 inline cimatrix operator&(const scimatrix& A, const cimatrix& B) {
3791  return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(A,B);
3792 }
3793 
3795 inline cimatrix operator&(const simatrix& A, const cimatrix& B) {
3796  return spf_mm_intersect<simatrix,cimatrix,cimatrix>(A,B);
3797 }
3798 
3800 inline cimatrix operator&(const cimatrix_slice& A, const simatrix& B) {
3801  return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(A,B);
3802 }
3803 
3805 inline cimatrix operator&(const cimatrix_slice& A, const scimatrix& B) {
3806  return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(A,B);
3807 }
3808 
3810 inline cimatrix operator&(const imatrix_slice& A, const scimatrix& B) {
3811  return fsp_mm_intersect<imatrix_slice,scimatrix,cimatrix>(A,B);
3812 }
3813 
3815 inline cimatrix operator&(const scimatrix& A, const imatrix_slice& B) {
3816  return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(A,B);
3817 }
3818 
3820 inline cimatrix operator&(const scimatrix& A, const cimatrix_slice& B) {
3821  return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(A,B);
3822 }
3823 
3825 inline cimatrix operator&(const simatrix& A, const cimatrix_slice& B) {
3826  return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(A,B);
3827 }
3828 
3830 inline scimatrix operator&(const scimatrix& A, const simatrix& B) {
3831  return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3832 }
3833 
3835 inline scimatrix operator&(const scimatrix& A, const scimatrix& B) {
3836  return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3837 }
3838 
3840 inline scimatrix operator&(const simatrix& A, const scimatrix& B) {
3841  return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3842 }
3843 
3845 inline scimatrix operator-(const scimatrix& M) {
3846  return sp_m_negative<scimatrix,scimatrix>(M);
3847 }
3848 
3850 inline 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 
4039 inline bool operator==(const scimatrix& A, const srmatrix& B) {
4040  return spsp_mm_comp(A,B);
4041 }
4042 
4044 inline bool operator==(const scimatrix& A, const scmatrix& B) {
4045  return spsp_mm_comp(A,B);
4046 }
4047 
4049 inline bool operator==(const scimatrix& A, const simatrix& B) {
4050  return spsp_mm_comp(A,B);
4051 }
4052 
4054 inline bool operator==(const scimatrix& A, const scimatrix& B) {
4055  return spsp_mm_comp(A,B);
4056 }
4057 
4059 inline bool operator==(const srmatrix& A, const scimatrix& B) {
4060  return spsp_mm_comp(A,B);
4061 }
4062 
4064 inline bool operator==(const scmatrix& A, const scimatrix& B) {
4065  return spsp_mm_comp(A,B);
4066 }
4067 
4069 inline bool operator==(const simatrix& A, const scimatrix& B) {
4070  return spsp_mm_comp(A,B);
4071 }
4072 
4074 inline bool operator==(const scimatrix& A, const rmatrix& B) {
4075  return spf_mm_comp(A,B);
4076 }
4077 
4079 inline bool operator==(const scimatrix& A, const imatrix& B) {
4080  return spf_mm_comp(A,B);
4081 }
4082 
4084 inline bool operator==(const scimatrix& A, const cmatrix& B) {
4085  return spf_mm_comp(A,B);
4086 }
4087 
4089 inline bool operator==(const scimatrix& A, const cimatrix& B) {
4090  return spf_mm_comp(A,B);
4091 }
4092 
4094 inline bool operator==(const srmatrix& A, const cimatrix& B) {
4095  return spf_mm_comp(A,B);
4096 }
4097 
4099 inline bool operator==(const scmatrix& A, const cimatrix& B) {
4100  return spf_mm_comp(A,B);
4101 }
4102 
4104 inline bool operator==(const simatrix& A, const cimatrix& B) {
4105  return spf_mm_comp(A,B);
4106 }
4107 
4109 inline bool operator==(const cimatrix& A, const srmatrix& B) {
4110  return fsp_mm_comp(A,B);
4111 }
4112 
4114 inline bool operator==(const cimatrix& A, const simatrix& B) {
4115  return fsp_mm_comp(A,B);
4116 }
4117 
4119 inline bool operator==(const cimatrix& A, const scmatrix& B) {
4120  return fsp_mm_comp(A,B);
4121 }
4122 
4124 inline bool operator==(const cimatrix& A, const scimatrix& B) {
4125  return fsp_mm_comp(A,B);
4126 }
4127 
4129 inline bool operator==(const rmatrix& A, const scimatrix& B) {
4130  return fsp_mm_comp(A,B);
4131 }
4132 
4134 inline bool operator==(const cmatrix& A, const scimatrix& B) {
4135  return fsp_mm_comp(A,B);
4136 }
4137 
4139 inline bool operator==(const imatrix& A, const scimatrix& B) {
4140  return fsp_mm_comp(A,B);
4141 }
4142 
4144 inline bool operator==(const cimatrix_slice& A, const srmatrix& B) {
4145  return fsp_mm_comp(A,B);
4146 }
4147 
4149 inline bool operator==(const cimatrix_slice& A, const scmatrix& B) {
4150  return fsp_mm_comp(A,B);
4151 }
4152 
4154 inline bool operator==(const cimatrix_slice& A, const simatrix& B) {
4155  return fsp_mm_comp(A,B);
4156 }
4157 
4159 inline bool operator==(const cimatrix_slice& A, const scimatrix& B) {
4160  return fsp_mm_comp(A,B);
4161 }
4162 
4164 inline bool operator==(const rmatrix_slice& A, const scimatrix& B) {
4165  return fsp_mm_comp(A,B);
4166 }
4167 
4169 inline bool operator==(const cmatrix_slice& A, const scimatrix& B) {
4170  return fsp_mm_comp(A,B);
4171 }
4172 
4174 inline bool operator==(const imatrix_slice& A, const scimatrix& B) {
4175  return fsp_mm_comp(A,B);
4176 }
4177 
4179 inline bool operator==(const scimatrix& A, const rmatrix_slice& B) {
4180  return spf_mm_comp(A,B);
4181 }
4182 
4184 inline bool operator==(const scimatrix& A, const imatrix_slice& B) {
4185  return spf_mm_comp(A,B);
4186 }
4187 
4189 inline bool operator==(const scimatrix& A, const cmatrix_slice& B) {
4190  return spf_mm_comp(A,B);
4191 }
4192 
4194 inline bool operator==(const scimatrix& A, const cimatrix_slice& B) {
4195  return spf_mm_comp(A,B);
4196 }
4197 
4199 inline bool operator==(const srmatrix& A, const cimatrix_slice& B) {
4200  return spf_mm_comp(A,B);
4201 }
4202 
4204 inline bool operator==(const scmatrix& A, const cimatrix_slice& B) {
4205  return spf_mm_comp(A,B);
4206 }
4207 
4209 inline bool operator==(const simatrix& A, const cimatrix_slice& B) {
4210  return spf_mm_comp(A,B);
4211 }
4212 
4214 inline bool operator!=(const scimatrix& A, const srmatrix& B) {
4215  return !spsp_mm_comp(A,B);
4216 }
4217 
4219 inline bool operator!=(const scimatrix& A, const scmatrix& B) {
4220  return !spsp_mm_comp(A,B);
4221 }
4222 
4224 inline bool operator!=(const scimatrix& A, const simatrix& B) {
4225  return !spsp_mm_comp(A,B);
4226 }
4227 
4229 inline bool operator!=(const scimatrix& A, const scimatrix& B) {
4230  return !spsp_mm_comp(A,B);
4231 }
4232 
4234 inline bool operator!=(const srmatrix& A, const scimatrix& B) {
4235  return !spsp_mm_comp(A,B);
4236 }
4237 
4239 inline bool operator!=(const scmatrix& A, const scimatrix& B) {
4240  return !spsp_mm_comp(A,B);
4241 }
4242 
4244 inline bool operator!=(const simatrix& A, const scimatrix& B) {
4245  return !spsp_mm_comp(A,B);
4246 }
4247 
4249 inline bool operator!=(const scimatrix& A, const rmatrix& B) {
4250  return !spf_mm_comp(A,B);
4251 }
4252 
4254 inline bool operator!=(const scimatrix& A, const imatrix& B) {
4255  return !spf_mm_comp(A,B);
4256 }
4257 
4259 inline bool operator!=(const scimatrix& A, const cmatrix& B) {
4260  return !spf_mm_comp(A,B);
4261 }
4262 
4264 inline bool operator!=(const scimatrix& A, const cimatrix& B) {
4265  return !spf_mm_comp(A,B);
4266 }
4267 
4269 inline bool operator!=(const srmatrix& A, const cimatrix& B) {
4270  return !spf_mm_comp(A,B);
4271 }
4272 
4274 inline bool operator!=(const scmatrix& A, const cimatrix& B) {
4275  return !spf_mm_comp(A,B);
4276 }
4277 
4279 inline bool operator!=(const simatrix& A, const cimatrix& B) {
4280  return !spf_mm_comp(A,B);
4281 }
4282 
4284 inline bool operator!=(const cimatrix& A, const srmatrix& B) {
4285  return !fsp_mm_comp(A,B);
4286 }
4287 
4289 inline bool operator!=(const cimatrix& A, const simatrix& B) {
4290  return !fsp_mm_comp(A,B);
4291 }
4292 
4294 inline bool operator!=(const cimatrix& A, const scmatrix& B) {
4295  return !fsp_mm_comp(A,B);
4296 }
4297 
4299 inline bool operator!=(const cimatrix& A, const scimatrix& B) {
4300  return !fsp_mm_comp(A,B);
4301 }
4302 
4304 inline bool operator!=(const rmatrix& A, const scimatrix& B) {
4305  return !fsp_mm_comp(A,B);
4306 }
4307 
4309 inline bool operator!=(const cmatrix& A, const scimatrix& B) {
4310  return !fsp_mm_comp(A,B);
4311 }
4312 
4314 inline bool operator!=(const imatrix& A, const scimatrix& B) {
4315  return !fsp_mm_comp(A,B);
4316 }
4317 
4319 inline bool operator!=(const cimatrix_slice& A, const srmatrix& B) {
4320  return !fsp_mm_comp(A,B);
4321 }
4322 
4324 inline bool operator!=(const cimatrix_slice& A, const scmatrix& B) {
4325  return !fsp_mm_comp(A,B);
4326 }
4327 
4329 inline bool operator!=(const cimatrix_slice& A, const simatrix& B) {
4330  return !fsp_mm_comp(A,B);
4331 }
4332 
4334 inline bool operator!=(const cimatrix_slice& A, const scimatrix& B) {
4335  return !fsp_mm_comp(A,B);
4336 }
4337 
4339 inline bool operator!=(const rmatrix_slice& A, const scimatrix& B) {
4340  return !fsp_mm_comp(A,B);
4341 }
4342 
4344 inline bool operator!=(const cmatrix_slice& A, const scimatrix& B) {
4345  return !fsp_mm_comp(A,B);
4346 }
4347 
4349 inline bool operator!=(const imatrix_slice& A, const scimatrix& B) {
4350  return !fsp_mm_comp(A,B);
4351 }
4352 
4354 inline bool operator!=(const scimatrix& A, const rmatrix_slice& B) {
4355  return !spf_mm_comp(A,B);
4356 }
4357 
4359 inline bool operator!=(const scimatrix& A, const imatrix_slice& B) {
4360  return !spf_mm_comp(A,B);
4361 }
4362 
4364 inline bool operator!=(const scimatrix& A, const cmatrix_slice& B) {
4365  return !spf_mm_comp(A,B);
4366 }
4367 
4369 inline bool operator!=(const scimatrix& A, const cimatrix_slice& B) {
4370  return !spf_mm_comp(A,B);
4371 }
4372 
4374 inline bool operator!=(const srmatrix& A, const cimatrix_slice& B) {
4375  return !spf_mm_comp(A,B);
4376 }
4377 
4379 inline bool operator!=(const scmatrix& A, const cimatrix_slice& B) {
4380  return !spf_mm_comp(A,B);
4381 }
4382 
4384 inline bool operator!=(const simatrix& A, const cimatrix_slice& B) {
4385  return !spf_mm_comp(A,B);
4386 }
4387 
4389 inline bool operator<(const scimatrix& A, const simatrix& B) {
4390  return spsp_mm_less<scimatrix,simatrix,cinterval>(A,B);
4391 }
4392 
4394 inline bool operator<(const scimatrix& A, const scimatrix& B) {
4395  return spsp_mm_less<scimatrix,scimatrix,cinterval>(A,B);
4396 }
4397 
4399 inline bool operator<(const srmatrix& A, const scimatrix& B) {
4400  return spsp_mm_less<srmatrix,scimatrix,cinterval>(A,B);
4401 }
4402 
4404 inline bool operator<(const scmatrix& A, const scimatrix& B) {
4405  return spsp_mm_less<scmatrix,scimatrix,cinterval>(A,B);
4406 }
4407 
4409 inline bool operator<(const simatrix& A, const scimatrix& B) {
4410  return spsp_mm_less<simatrix,scimatrix,cinterval>(A,B);
4411 }
4412 
4414 inline bool operator<(const scimatrix& A, const imatrix& B) {
4415  return spf_mm_less<scimatrix,imatrix,cinterval>(A,B);
4416 }
4417 
4419 inline bool operator<(const scimatrix& A, const cimatrix& B) {
4420  return spf_mm_less<scimatrix,cimatrix,cinterval>(A,B);
4421 }
4422 
4424 inline bool operator<(const srmatrix& A, const cimatrix& B) {
4425  return spf_mm_less<srmatrix,cimatrix,cinterval>(A,B);
4426 }
4427 
4429 inline bool operator<(const scmatrix& A, const cimatrix& B) {
4430  return spf_mm_less<scmatrix,cimatrix,cinterval>(A,B);
4431 }
4432 
4434 inline bool operator<(const simatrix& A, const cimatrix& B) {
4435  return spf_mm_less<simatrix,cimatrix,cinterval>(A,B);
4436 }
4437 
4439 inline bool operator<(const cimatrix& A, const simatrix& B) {
4440  return fsp_mm_less<cimatrix,simatrix,cinterval>(A,B);
4441 }
4442 
4444 inline bool operator<(const cimatrix& A, const scimatrix& B) {
4445  return fsp_mm_less<cimatrix,scimatrix,cinterval>(A,B);
4446 }
4447 
4449 inline bool operator<(const rmatrix& A, const scimatrix& B) {
4450  return fsp_mm_less<rmatrix,scimatrix,cinterval>(A,B);
4451 }
4452 
4454 inline bool operator<(const cmatrix& A, const scimatrix& B) {
4455  return fsp_mm_less<cmatrix,scimatrix,cinterval>(A,B);
4456 }
4457 
4459 inline bool operator<(const imatrix& A, const scimatrix& B) {
4460  return fsp_mm_less<imatrix,scimatrix,cinterval>(A,B);
4461 }
4462 
4464 inline bool operator<(const cimatrix_slice& A, const simatrix& B) {
4465  return fsp_mm_less<cimatrix_slice,simatrix,cinterval>(A,B);
4466 }
4467 
4469 inline bool operator<(const cimatrix_slice& A, const scimatrix& B) {
4470  return fsp_mm_less<cimatrix_slice,scimatrix,cinterval>(A,B);
4471 }
4472 
4474 inline bool operator<(const rmatrix_slice& A, const scimatrix& B) {
4475  return fsp_mm_less<rmatrix_slice,scimatrix,cinterval>(A,B);
4476 }
4477 
4479 inline bool operator<(const cmatrix_slice& A, const scimatrix& B) {
4480  return fsp_mm_less<cmatrix_slice,scimatrix,cinterval>(A,B);
4481 }
4482 
4484 inline bool operator<(const imatrix_slice& A, const scimatrix& B) {
4485  return fsp_mm_less<imatrix_slice,scimatrix,cinterval>(A,B);
4486 }
4487 
4489 inline bool operator<(const scimatrix& A, const imatrix_slice& B) {
4490  return spf_mm_less<scimatrix,imatrix_slice,cinterval>(A,B);
4491 }
4492 
4494 inline bool operator<(const scimatrix& A, const cimatrix_slice& B) {
4495  return spf_mm_less<scimatrix,cimatrix_slice,cinterval>(A,B);
4496 }
4497 
4499 inline bool operator<(const srmatrix& A, const cimatrix_slice& B) {
4500  return spf_mm_less<srmatrix,cimatrix_slice,cinterval>(A,B);
4501 }
4502 
4504 inline bool operator<(const scmatrix& A, const cimatrix_slice& B) {
4505  return spf_mm_less<scmatrix,cimatrix_slice,cinterval>(A,B);
4506 }
4507 
4509 inline bool operator<(const simatrix& A, const cimatrix_slice& B) {
4510  return spf_mm_less<simatrix,cimatrix_slice,cinterval>(A,B);
4511 }
4512 
4514 inline bool operator<=(const scimatrix& A, const simatrix& B) {
4515  return spsp_mm_leq<scimatrix,simatrix,cinterval>(A,B);
4516 }
4517 
4519 inline bool operator<=(const scimatrix& A, const scimatrix& B) {
4520  return spsp_mm_leq<scimatrix,scimatrix,cinterval>(A,B);
4521 }
4522 
4524 inline bool operator<=(const srmatrix& A, const scimatrix& B) {
4525  return spsp_mm_leq<srmatrix,scimatrix,cinterval>(A,B);
4526 }
4527 
4529 inline bool operator<=(const scmatrix& A, const scimatrix& B) {
4530  return spsp_mm_leq<scmatrix,scimatrix,cinterval>(A,B);
4531 }
4532 
4534 inline bool operator<=(const simatrix& A, const scimatrix& B) {
4535  return spsp_mm_leq<simatrix,scimatrix,cinterval>(A,B);
4536 }
4537 
4539 inline bool operator<=(const scimatrix& A, const imatrix& B) {
4540  return spf_mm_leq<scimatrix,imatrix,cinterval>(A,B);
4541 }
4542 
4544 inline bool operator<=(const scimatrix& A, const cimatrix& B) {
4545  return spf_mm_leq<scimatrix,cimatrix,cinterval>(A,B);
4546 }
4547 
4549 inline bool operator<=(const srmatrix& A, const cimatrix& B) {
4550  return spf_mm_leq<srmatrix,cimatrix,cinterval>(A,B);
4551 }
4552 
4554 inline bool operator<=(const scmatrix& A, const cimatrix& B) {
4555  return spf_mm_leq<scmatrix,cimatrix,cinterval>(A,B);
4556 }
4557 
4559 inline bool operator<=(const simatrix& A, const cimatrix& B) {
4560  return spf_mm_leq<simatrix,cimatrix,cinterval>(A,B);
4561 }
4562 
4564 inline bool operator<=(const cimatrix& A, const simatrix& B) {
4565  return fsp_mm_leq<cimatrix,simatrix,cinterval>(A,B);
4566 }
4567 
4569 inline bool operator<=(const cimatrix& A, const scimatrix& B) {
4570  return fsp_mm_leq<cimatrix,scimatrix,cinterval>(A,B);
4571 }
4572 
4574 inline bool operator<=(const rmatrix& A, const scimatrix& B) {
4575  return fsp_mm_leq<rmatrix,scimatrix,cinterval>(A,B);
4576 }
4577 
4579 inline bool operator<=(const cmatrix& A, const scimatrix& B) {
4580  return fsp_mm_leq<cmatrix,scimatrix,cinterval>(A,B);
4581 }
4582 
4584 inline bool operator<=(const imatrix& A, const scimatrix& B) {
4585  return fsp_mm_leq<imatrix,scimatrix,cinterval>(A,B);
4586 }
4587 
4589 inline bool operator<=(const cimatrix_slice& A, const simatrix& B) {
4590  return fsp_mm_leq<cimatrix_slice,simatrix,cinterval>(A,B);
4591 }
4592 
4594 inline bool operator<=(const cimatrix_slice& A, const scimatrix& B) {
4595  return fsp_mm_leq<cimatrix_slice,scimatrix,cinterval>(A,B);
4596 }
4597 
4599 inline bool operator<=(const rmatrix_slice& A, const scimatrix& B) {
4600  return fsp_mm_leq<rmatrix_slice,scimatrix,cinterval>(A,B);
4601 }
4602 
4604 inline bool operator<=(const cmatrix_slice& A, const scimatrix& B) {
4605  return fsp_mm_leq<cmatrix_slice,scimatrix,cinterval>(A,B);
4606 }
4607 
4609 inline bool operator<=(const imatrix_slice& A, const scimatrix& B) {
4610  return fsp_mm_leq<imatrix_slice,scimatrix,cinterval>(A,B);
4611 }
4612 
4614 inline bool operator<=(const scimatrix& A, const imatrix_slice& B) {
4615  return spf_mm_leq<scimatrix,imatrix_slice,cinterval>(A,B);
4616 }
4617 
4619 inline bool operator<=(const scimatrix& A, const cimatrix_slice& B) {
4620  return spf_mm_leq<scimatrix,cimatrix_slice,cinterval>(A,B);
4621 }
4622 
4624 inline bool operator<=(const srmatrix& A, const cimatrix_slice& B) {
4625  return spf_mm_leq<srmatrix,cimatrix_slice,cinterval>(A,B);
4626 }
4627 
4629 inline bool operator<=(const scmatrix& A, const cimatrix_slice& B) {
4630  return spf_mm_leq<scmatrix,cimatrix_slice,cinterval>(A,B);
4631 }
4632 
4634 inline bool operator<=(const simatrix& A, const cimatrix_slice& B) {
4635  return spf_mm_leq<simatrix,cimatrix_slice,cinterval>(A,B);
4636 }
4637 
4639 inline bool operator>(const scimatrix& A, const srmatrix& B) {
4640  return spsp_mm_greater<scimatrix,srmatrix,cinterval>(A,B);
4641 }
4642 
4644 inline bool operator>(const scimatrix& A, const scmatrix& B) {
4645  return spsp_mm_greater<scimatrix,scmatrix,cinterval>(A,B);
4646 }
4647 
4649 inline bool operator>(const scimatrix& A, const simatrix& B) {
4650  return spsp_mm_greater<scimatrix,simatrix,cinterval>(A,B);
4651 }
4652 
4654 inline bool operator>(const scimatrix& A, const scimatrix& B) {
4655  return spsp_mm_greater<scimatrix,scimatrix,cinterval>(A,B);
4656 }
4657 
4659 inline bool operator>(const simatrix& A, const scimatrix& B) {
4660  return spsp_mm_greater<simatrix,scimatrix,cinterval>(A,B);
4661 }
4662 
4664 inline bool operator>(const scimatrix& A, const rmatrix& B) {
4665  return spf_mm_greater<scimatrix,rmatrix,cinterval>(A,B);
4666 }
4667 
4669 inline bool operator>(const scimatrix& A, const imatrix& B) {
4670  return spf_mm_greater<scimatrix,imatrix,cinterval>(A,B);
4671 }
4672 
4674 inline bool operator>(const scimatrix& A, const cmatrix& B) {
4675  return spf_mm_greater<scimatrix,cmatrix,cinterval>(A,B);
4676 }
4677 
4679 inline bool operator>(const scimatrix& A, const cimatrix& B) {
4680  return spf_mm_greater<scimatrix,cimatrix,cinterval>(A,B);
4681 }
4682 
4684 inline bool operator>(const simatrix& A, const cimatrix& B) {
4685  return spf_mm_greater<simatrix,cimatrix,cinterval>(A,B);
4686 }
4687 
4689 inline bool operator>(const cimatrix& A, const srmatrix& B) {
4690  return fsp_mm_greater<cimatrix,srmatrix,cinterval>(A,B);
4691 }
4692 
4694 inline bool operator>(const cimatrix& A, const simatrix& B) {
4695  return fsp_mm_greater<cimatrix,simatrix,cinterval>(A,B);
4696 }
4697 
4699 inline bool operator>(const cimatrix& A, const scmatrix& B) {
4700  return fsp_mm_greater<cimatrix,scmatrix,cinterval>(A,B);
4701 }
4702 
4704 inline bool operator>(const cimatrix& A, const scimatrix& B) {
4705  return fsp_mm_greater<cimatrix,scimatrix,cinterval>(A,B);
4706 }
4707 
4709 inline bool operator>(const imatrix& A, const scimatrix& B) {
4710  return fsp_mm_greater<imatrix,scimatrix,cinterval>(A,B);
4711 }
4712 
4714 inline bool operator>(const cimatrix_slice& A, const srmatrix& B) {
4715  return fsp_mm_greater<cimatrix_slice,srmatrix,cinterval>(A,B);
4716 }
4717 
4719 inline bool operator>(const cimatrix_slice& A, const scmatrix& B) {
4720  return fsp_mm_greater<cimatrix_slice,scmatrix,cinterval>(A,B);
4721 }
4722 
4724 inline bool operator>(const cimatrix_slice& A, const simatrix& B) {
4725  return fsp_mm_greater<cimatrix_slice,simatrix,cinterval>(A,B);
4726 }
4727 
4729 inline bool operator>(const cimatrix_slice& A, const scimatrix& B) {
4730  return fsp_mm_greater<cimatrix_slice,scimatrix,cinterval>(A,B);
4731 }
4732 
4734 inline bool operator>(const imatrix_slice& A, const scimatrix& B) {
4735  return fsp_mm_greater<imatrix_slice,scimatrix,cinterval>(A,B);
4736 }
4737 
4739 inline bool operator>(const scimatrix& A, const rmatrix_slice& B) {
4740  return spf_mm_greater<scimatrix,rmatrix_slice,cinterval>(A,B);
4741 }
4742 
4744 inline bool operator>(const scimatrix& A, const imatrix_slice& B) {
4745  return spf_mm_greater<scimatrix,imatrix_slice,cinterval>(A,B);
4746 }
4747 
4749 inline bool operator>(const scimatrix& A, const cmatrix_slice& B) {
4750  return spf_mm_greater<scimatrix,cmatrix_slice,cinterval>(A,B);
4751 }
4752 
4754 inline bool operator>(const scimatrix& A, const cimatrix_slice& B) {
4755  return spf_mm_greater<scimatrix,cimatrix_slice,cinterval>(A,B);
4756 }
4757 
4759 inline bool operator>(const simatrix& A, const cimatrix_slice& B) {
4760  return spf_mm_greater<simatrix,cimatrix_slice,cinterval>(A,B);
4761 }
4762 
4764 inline bool operator>=(const scimatrix& A, const srmatrix& B) {
4765  return spsp_mm_geq<scimatrix,srmatrix,cinterval>(A,B);
4766 }
4767 
4769 inline bool operator>=(const scimatrix& A, const scmatrix& B) {
4770  return spsp_mm_geq<scimatrix,scmatrix,cinterval>(A,B);
4771 }
4772 
4774 inline bool operator>=(const scimatrix& A, const simatrix& B) {
4775  return spsp_mm_geq<scimatrix,simatrix,cinterval>(A,B);
4776 }
4777 
4779 inline bool operator>=(const scimatrix& A, const scimatrix& B) {
4780  return spsp_mm_geq<scimatrix,scimatrix,cinterval>(A,B);
4781 }
4782 
4784 inline bool operator>=(const simatrix& A, const scimatrix& B) {
4785  return spsp_mm_geq<simatrix,scimatrix,cinterval>(A,B);
4786 }
4787 
4789 inline bool operator>=(const scimatrix& A, const rmatrix& B) {
4790  return spf_mm_geq<scimatrix,rmatrix,cinterval>(A,B);
4791 }
4792 
4794 inline bool operator>=(const scimatrix& A, const imatrix& B) {
4795  return spf_mm_geq<scimatrix,imatrix,cinterval>(A,B);
4796 }
4797 
4799 inline bool operator>=(const scimatrix& A, const cmatrix& B) {
4800  return spf_mm_geq<scimatrix,cmatrix,cinterval>(A,B);
4801 }
4802 
4804 inline bool operator>=(const scimatrix& A, const cimatrix& B) {
4805  return spf_mm_geq<scimatrix,cimatrix,cinterval>(A,B);
4806 }
4807 
4809 inline bool operator>=(const simatrix& A, const cimatrix& B) {
4810  return spf_mm_geq<simatrix,cimatrix,cinterval>(A,B);
4811 }
4812 
4814 inline bool operator>=(const cimatrix& A, const srmatrix& B) {
4815  return fsp_mm_geq<cimatrix,srmatrix,cinterval>(A,B);
4816 }
4817 
4819 inline bool operator>=(const cimatrix& A, const simatrix& B) {
4820  return fsp_mm_geq<cimatrix,simatrix,cinterval>(A,B);
4821 }
4822 
4824 inline bool operator>=(const cimatrix& A, const scmatrix& B) {
4825  return fsp_mm_geq<cimatrix,scmatrix,cinterval>(A,B);
4826 }
4827 
4829 inline bool operator>=(const cimatrix& A, const scimatrix& B) {
4830  return fsp_mm_geq<cimatrix,scimatrix,cinterval>(A,B);
4831 }
4832 
4834 inline bool operator>=(const imatrix& A, const scimatrix& B) {
4835  return fsp_mm_geq<imatrix,scimatrix,cinterval>(A,B);
4836 }
4837 
4839 inline bool operator>=(const cimatrix_slice& A, const srmatrix& B) {
4840  return fsp_mm_geq<cimatrix_slice,srmatrix,cinterval>(A,B);
4841 }
4842 
4844 inline bool operator>=(const cimatrix_slice& A, const scmatrix& B) {
4845  return fsp_mm_geq<cimatrix_slice,scmatrix,cinterval>(A,B);
4846 }
4847 
4849 inline bool operator>=(const cimatrix_slice& A, const simatrix& B) {
4850  return fsp_mm_geq<cimatrix_slice,simatrix,cinterval>(A,B);
4851 }
4852 
4854 inline bool operator>=(const cimatrix_slice& A, const scimatrix& B) {
4855  return fsp_mm_geq<cimatrix_slice,scimatrix,cinterval>(A,B);
4856 }
4857 
4859 inline bool operator>=(const imatrix_slice& A, const scimatrix& B) {
4860  return fsp_mm_geq<imatrix_slice,scimatrix,cinterval>(A,B);
4861 }
4862 
4864 inline bool operator>=(const scimatrix& A, const rmatrix_slice& B) {
4865  return spf_mm_geq<scimatrix,rmatrix_slice,cinterval>(A,B);
4866 }
4867 
4869 inline bool operator>=(const scimatrix& A, const imatrix_slice& B) {
4870  return spf_mm_geq<scimatrix,imatrix_slice,cinterval>(A,B);
4871 }
4872 
4874 inline bool operator>=(const scimatrix& A, const cmatrix_slice& B) {
4875  return spf_mm_geq<scimatrix,cmatrix_slice,cinterval>(A,B);
4876 }
4877 
4879 inline bool operator>=(const scimatrix& A, const cimatrix_slice& B) {
4880  return spf_mm_geq<scimatrix,cimatrix_slice,cinterval>(A,B);
4881 }
4882 
4884 inline bool operator>=(const simatrix& A, const cimatrix_slice& B) {
4885  return spf_mm_geq<simatrix,cimatrix_slice,cinterval>(A,B);
4886 }
4887 
4889 inline bool operator!(const scimatrix& A) {
4890  return sp_m_not(A);
4891 }
4892 
4894 
4899 inline std::ostream& operator<<(std::ostream& os, const scimatrix& A) {
4900  return sp_m_output<scimatrix,cinterval>(os,A);
4901 }
4902 
4904 
4909 inline 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 
5639 inline int RowLen(const scimatrix_slice& S) {
5640  return RowLen(S.A);
5641 }
5642 
5644 inline int ColLen(const scimatrix_slice& S) {
5645  return ColLen(S.A);
5646 }
5647 
5648 inline 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 
5656 inline 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 
5685 inline int Lb(const scimatrix_slice& S, const int i) {
5686  return Lb(S.A, i);
5687 }
5688 
5690 inline int Ub(const scimatrix_slice& S, const int i) {
5691  return Ub(S.A, i);
5692 }
5693 
5695 inline simatrix Re(const scimatrix_slice& S) {
5696  return Re(S.A);
5697 }
5698 
5700 inline simatrix Im(const scimatrix_slice& S) {
5701  return Im(S.A);
5702 }
5703 
5705 inline scimatrix conj(const scimatrix_slice& S) {
5706  return conj(S.A);
5707 }
5708 
5710 inline simatrix abs(const scimatrix_slice& S) {
5711  return abs(S.A);
5712 }
5713 
5715 inline scmatrix mid(const scimatrix_slice& S) {
5716  return mid(S.A);
5717 }
5718 
5720 inline scmatrix diam(const scimatrix_slice& S) {
5721  return diam(S.A);
5722 }
5723 
5725 inline scmatrix Inf(const scimatrix_slice& S) {
5726  return Inf(S.A);
5727 }
5728 
5730 inline scmatrix Sup(const scimatrix_slice& S) {
5731  return Sup(S.A);
5732 }
5733 
5735 inline srmatrix InfRe(const scimatrix_slice& S) {
5736  return InfRe(S.A);
5737 }
5738 
5740 inline srmatrix InfIm(const scimatrix_slice& S) {
5741  return InfIm(S.A);
5742 }
5743 
5745 inline srmatrix SupRe(const scimatrix_slice& S) {
5746  return SupRe(S.A);
5747 }
5748 
5750 inline 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 
5795 inline scimatrix operator-(const scimatrix_slice& M) {
5796  return sp_m_negative<scimatrix,scimatrix>(M.A);
5797 }
5798 
5800 inline scimatrix operator+(const scimatrix_slice& M) {
5801  return M.A;
5802 }
5803 
5805 
5811 inline scimatrix operator*(const scimatrix_slice& M1, const srmatrix_slice& M2) {
5812  return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5813 }
5814 
5816 
5822 inline scimatrix operator*(const scimatrix_slice& M1, const simatrix_slice& M2) {
5823  return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5824 }
5825 
5827 
5833 inline scimatrix operator*(const scimatrix_slice& M1, const scmatrix_slice& M2) {
5834  return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5835 }
5836 
5838 
5844 inline scimatrix operator*(const scimatrix_slice& M1, const scimatrix_slice& M2) {
5845  return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5846 }
5847 
5849 
5855 inline scimatrix operator*(const srmatrix_slice& M1, const scimatrix_slice& M2) {
5856  return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5857 }
5858 
5860 
5866 inline scimatrix operator*(const scmatrix_slice& M1, const scimatrix_slice& M2) {
5867  return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5868 }
5869 
5871 
5877 inline scimatrix operator*(const simatrix_slice& M1, const scimatrix_slice& M2) {
5878  return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5879 }
5880 
5882 
5888 inline 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 
5899 inline 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 
5910 inline 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 
5921 inline 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 
5932 inline 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 
5943 inline 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 
5954 inline 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 
5965 inline 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 
5976 inline 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 
5987 inline 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 
5998 inline 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 
6009 inline 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 
6020 inline 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 
6031 inline 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 
6042 inline 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 
6053 inline 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 
6064 inline 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 
6075 inline 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 
6086 inline 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 
6097 inline 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 
6108 inline 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 
6119 inline 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 
6130 inline 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 
6141 inline 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 
6152 inline 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 
6163 inline 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 
6174 inline 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 
6185 inline 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 
6196 inline 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 
6207 inline 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 
6218 inline 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 
6229 inline 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 
6240 inline 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 
6251 inline 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 
6262 inline 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 
6273 inline 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 
6284 inline 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 
6295 inline 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 
6306 inline 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 
6317 inline 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 
6328 inline 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 
6339 inline 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 
6350 inline 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 
6361 inline 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 
6372 inline 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 
6383 inline 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 
6394 inline 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 
6405 inline 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 
6416 inline 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 
6427 inline 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 
6438 inline 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 
6449 inline 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 
6460 inline 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 
6471 inline 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 
6482 inline 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 
6493 inline 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 
6504 inline 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 
6515 inline 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 
6526 inline 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 
6537 inline 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 
6548 inline 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 
6559 inline 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 
6570 inline 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 
6581 inline 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 
6592 inline 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 
6680 inline scivector operator*(const simatrix_slice& M, const scvector_slice& v) {
6681  return spsl_mv_mult<simatrix,scvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6682 }
6683 
6685 
6691 inline scivector operator*(const scmatrix_slice& M, const sivector_slice& v) {
6692  return spsl_mv_mult<scmatrix,sivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6693 }
6694 
6696 
6702 inline 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 
6713 inline 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 
6724 inline 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 
6735 inline 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 
6746 inline 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 
6757 inline 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 
6768 inline 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 
6779 inline 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 
6790 inline 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 
6801 inline civector operator*(const scimatrix_slice& M, const rvector_slice& v) {
6802  return spf_mv_mult<scimatrix,rvector_slice,civector,sparse_cidot>(M.A,v);
6803 }
6804 
6806 
6812 inline civector operator*(const scimatrix_slice& M, const ivector_slice& v) {
6813  return spf_mv_mult<scimatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
6814 }
6815 
6817 
6823 inline civector operator*(const scimatrix_slice& M, const cvector_slice& v) {
6824  return spf_mv_mult<scimatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
6825 }
6826 
6828 
6834 inline civector operator*(const scimatrix_slice& M, const civector_slice& v) {
6835  return spf_mv_mult<scimatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6836 }
6837 
6839 
6845 inline civector operator*(const srmatrix_slice& M, const civector_slice& v) {
6846  return spf_mv_mult<srmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6847 }
6848 
6850 
6856 inline civector operator*(const scmatrix_slice& M, const civector_slice& v) {
6857  return spf_mv_mult<scmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6858 }
6859 
6861 
6867 inline civector operator*(const simatrix_slice& M, const civector_slice& v) {
6868  return spf_mv_mult<simatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6869 }
6870 
6872 
6878 inline civector operator*(const simatrix_slice& M, const cvector_slice& v) {
6879  return spf_mv_mult<simatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
6880 }
6881 
6883 
6889 inline civector operator*(const scmatrix_slice& M, const ivector_slice& v) {
6890  return spf_mv_mult<scmatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
6891 }
6892 
6894 inline scimatrix operator/(const scimatrix_slice& M, const real& r) {
6895  return sp_ms_div<scimatrix,real,scimatrix>(M.A,r);
6896 }
6897 
6899 inline scimatrix operator/(const scimatrix_slice& M, const complex& r) {
6900  return sp_ms_div<scimatrix,complex,scimatrix>(M.A,r);
6901 }
6902 
6904 inline scimatrix operator/(const scimatrix_slice& M, const interval& r) {
6905  return sp_ms_div<scimatrix,interval,scimatrix>(M.A,r);
6906 }
6907 
6909 inline scimatrix operator/(const scimatrix_slice& M, const cinterval& r) {
6910  return sp_ms_div<scimatrix,cinterval,scimatrix>(M.A,r);
6911 }
6912 
6914 inline scimatrix operator/(const srmatrix_slice& M, const cinterval& r) {
6915  return sp_ms_div<srmatrix,cinterval,scimatrix>(M.A,r);
6916 }
6917 
6919 inline scimatrix operator/(const simatrix_slice& M, const cinterval& r) {
6920  return sp_ms_div<simatrix,cinterval,scimatrix>(M.A,r);
6921 }
6922 
6924 inline scimatrix operator/(const scmatrix_slice& M, const cinterval& r) {
6925  return sp_ms_div<scmatrix,cinterval,scimatrix>(M.A,r);
6926 }
6927 
6929 inline scimatrix operator/(const simatrix_slice& M, const complex& r) {
6930  return sp_ms_div<simatrix,complex,scimatrix>(M.A,r);
6931 }
6932 
6934 inline scimatrix operator/(const scmatrix_slice& M, const interval& r) {
6935  return sp_ms_div<scmatrix,interval,scimatrix>(M.A,r);
6936 }
6937 
6939 inline scimatrix operator*(const scimatrix_slice& M, const real& r) {
6940  return sp_ms_mult<scimatrix,real,scimatrix>(M.A,r);
6941 }
6942 
6944 inline scimatrix operator*(const scimatrix_slice& M, const complex& r) {
6945  return sp_ms_mult<scimatrix,complex,scimatrix>(M.A,r);
6946 }
6947 
6949 inline scimatrix operator*(const scimatrix_slice& M, const interval& r) {
6950  return sp_ms_mult<scimatrix,interval,scimatrix>(M.A,r);
6951 }
6952 
6954 inline scimatrix operator*(const scimatrix_slice& M, const cinterval& r) {
6955  return sp_ms_mult<scimatrix,cinterval,scimatrix>(M.A,r);
6956 }
6957 
6959 inline scimatrix operator*(const srmatrix_slice& M, const cinterval& r) {
6960  return sp_ms_mult<srmatrix,cinterval,scimatrix>(M.A,r);
6961 }
6962 
6964 inline scimatrix operator*(const simatrix_slice& M, const cinterval& r) {
6965  return sp_ms_mult<simatrix,cinterval,scimatrix>(M.A,r);
6966 }
6967 
6969 inline scimatrix operator*(const scmatrix_slice& M, const cinterval& r) {
6970  return sp_ms_mult<scmatrix,cinterval,scimatrix>(M.A,r);
6971 }
6972 
6974 inline scimatrix operator*(const simatrix_slice& M, const complex& r) {
6975  return sp_ms_mult<simatrix,complex,scimatrix>(M.A,r);
6976 }
6977 
6979 inline scimatrix operator*(const scmatrix_slice& M, const interval& r) {
6980  return sp_ms_mult<scmatrix,interval,scimatrix>(M.A,r);
6981 }
6982 
6984 inline scimatrix operator*(const real& r, const scimatrix_slice& M) {
6985  return sp_sm_mult<real,scimatrix,scimatrix>(r,M.A);
6986 }
6987 
6989 inline scimatrix operator*(const complex& r, const scimatrix_slice& M) {
6990  return sp_sm_mult<complex,scimatrix,scimatrix>(r,M.A);
6991 }
6992 
6994 inline scimatrix operator*(const interval& r, const scimatrix_slice& M) {
6995  return sp_sm_mult<interval,scimatrix,scimatrix>(r,M.A);
6996 }
6997 
6999 inline scimatrix operator*(const cinterval& r, const scimatrix_slice& M) {
7000  return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,M.A);
7001 }
7002 
7004 inline scimatrix operator*(const cinterval& r, const srmatrix_slice& M) {
7005  return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,M.A);
7006 }
7007 
7009 inline scimatrix operator*(const cinterval& r, const simatrix_slice& M) {
7010  return sp_sm_mult<cinterval,simatrix,scimatrix>(r,M.A);
7011 }
7012 
7014 inline scimatrix operator*(const cinterval& r, const scmatrix_slice& M) {
7015  return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,M.A);
7016 }
7017 
7019 inline scimatrix operator*(const complex& r, const simatrix_slice& M) {
7020  return sp_sm_mult<complex,simatrix,scimatrix>(r,M.A);
7021 }
7022 
7024 inline scimatrix operator*(const interval& r, const scmatrix_slice& M) {
7025  return sp_sm_mult<interval,scmatrix,scimatrix>(r,M.A);
7026 }
7027 
7029 inline 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 
7034 inline 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 
7039 inline 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 
7044 inline 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 
7049 inline 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 
7054 inline 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 
7059 inline 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 
7064 inline 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 
7069 inline 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 
7074 inline scimatrix operator+(const scimatrix_slice& M1, const srmatrix& M2) {
7075  return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7076 }
7077 
7079 inline scimatrix operator+(const scimatrix_slice& M1, const scmatrix& M2) {
7080  return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7081 }
7082 
7084 inline scimatrix operator+(const scimatrix_slice& M1, const simatrix& M2) {
7085  return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7086 }
7087 
7089 inline scimatrix operator+(const scimatrix_slice& M1, const scimatrix& M2) {
7090  return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7091 }
7092 
7094 inline scimatrix operator+(const srmatrix_slice& M1, const scimatrix& M2) {
7095  return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7096 }
7097 
7099 inline scimatrix operator+(const simatrix_slice& M1, const scimatrix& M2) {
7100  return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7101 }
7102 
7104 inline scimatrix operator+(const scmatrix_slice& M1, const scimatrix& M2) {
7105  return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7106 }
7107 
7109 inline scimatrix operator+(const simatrix_slice& M1, const scmatrix& M2) {
7110  return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7111 }
7112 
7114 inline scimatrix operator+(const scmatrix_slice& M1, const simatrix& M2) {
7115  return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7116 }
7117 
7119 inline scimatrix operator+(const scimatrix& M1, const srmatrix_slice& M2) {
7120  return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7121 }
7122 
7124 inline scimatrix operator+(const scimatrix& M1, const scmatrix_slice& M2) {
7125  return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7126 }
7127 
7129 inline scimatrix operator+(const scimatrix& M1, const simatrix_slice& M2) {
7130  return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7131 }
7132 
7134 inline scimatrix operator+(const scimatrix& M1, const scimatrix_slice& M2) {
7135  return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7136 }
7137 
7139 inline scimatrix operator+(const srmatrix& M1, const scimatrix_slice& M2) {
7140  return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7141 }
7142 
7144 inline scimatrix operator+(const simatrix& M1, const scimatrix_slice& M2) {
7145  return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7146 }
7147 
7149 inline scimatrix operator+(const scmatrix& M1, const scimatrix_slice& M2) {
7150  return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7151 }
7152 
7154 inline scimatrix operator+(const simatrix& M1, const scmatrix_slice& M2) {
7155  return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7156 }
7157 
7159 inline scimatrix operator+(const scmatrix& M1, const simatrix_slice& M2) {
7160  return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7161 }
7162 
7164 inline cimatrix operator+(const scimatrix_slice& M1, const rmatrix& M2) {
7165  return spf_mm_add<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7166 }
7167 
7169 inline cimatrix operator+(const scimatrix_slice& M1, const imatrix& M2) {
7170  return spf_mm_add<scimatrix,imatrix,cimatrix>(M1.A,M2);
7171 }
7172 
7174 inline cimatrix operator+(const scimatrix_slice& M1, const cmatrix& M2) {
7175  return spf_mm_add<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7176 }
7177 
7179 inline cimatrix operator+(const scimatrix_slice& M1, const cimatrix& M2) {
7180  return spf_mm_add<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7181 }
7182 
7184 inline cimatrix operator+(const srmatrix_slice& M1, const cimatrix& M2) {
7185  return spf_mm_add<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7186 }
7187 
7189 inline cimatrix operator+(const simatrix_slice& M1, const cimatrix& M2) {
7190  return spf_mm_add<simatrix,cimatrix,cimatrix>(M1.A,M2);
7191 }
7192 
7194 inline cimatrix operator+(const scmatrix_slice& M1, const cimatrix& M2) {
7195  return spf_mm_add<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7196 }
7197 
7199 inline cimatrix operator+(const simatrix_slice& M1, const cmatrix& M2) {
7200  return spf_mm_add<simatrix,cmatrix,cimatrix>(M1.A,M2);
7201 }
7202 
7204 inline cimatrix operator+(const scmatrix_slice& M1, const imatrix& M2) {
7205  return spf_mm_add<scmatrix,imatrix,cimatrix>(M1.A,M2);
7206 }
7207 
7209 inline cimatrix operator+(const cimatrix& M1, const srmatrix_slice& M2) {
7210  return fsp_mm_add<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7211 }
7212 
7214 inline cimatrix operator+(const cimatrix& M1, const simatrix_slice& M2) {
7215  return fsp_mm_add<cimatrix,simatrix,cimatrix>(M1,M2.A);
7216 }
7217 
7219 inline cimatrix operator+(const cimatrix& M1, const scmatrix_slice& M2) {
7220  return fsp_mm_add<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7221 }
7222 
7224 inline cimatrix operator+(const cimatrix& M1, const scimatrix_slice& M2) {
7225  return fsp_mm_add<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7226 }
7227 
7229 inline cimatrix operator+(const rmatrix& M1, const scimatrix_slice& M2) {
7230  return fsp_mm_add<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7231 }
7232 
7234 inline cimatrix operator+(const imatrix& M1, const scimatrix_slice& M2) {
7235  return fsp_mm_add<imatrix,scimatrix,cimatrix>(M1,M2.A);
7236 }
7237 
7239 inline cimatrix operator+(const cmatrix& M1, const scimatrix_slice& M2) {
7240  return fsp_mm_add<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7241 }
7242 
7244 inline cimatrix operator+(const imatrix& M1, const scmatrix_slice& M2) {
7245  return fsp_mm_add<imatrix,scmatrix,cimatrix>(M1,M2.A);
7246 }
7247 
7249 inline cimatrix operator+(const cmatrix& M1, const simatrix_slice& M2) {
7250  return fsp_mm_add<cmatrix,simatrix,cimatrix>(M1,M2.A);
7251 }
7252 
7254 inline cimatrix operator+(const scimatrix_slice& M1, const rmatrix_slice& M2) {
7255  return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7256 }
7257 
7259 inline cimatrix operator+(const scimatrix_slice& M1, const cmatrix_slice& M2) {
7260  return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7261 }
7262 
7264 inline cimatrix operator+(const scimatrix_slice& M1, const imatrix_slice& M2) {
7265  return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7266 }
7267 
7269 inline cimatrix operator+(const scimatrix_slice& M1, const cimatrix_slice& M2) {
7270  return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7271 }
7272 
7274 inline cimatrix operator+(const srmatrix_slice& M1, const cimatrix_slice& M2) {
7275  return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7276 }
7277 
7279 inline cimatrix operator+(const simatrix_slice& M1, const cimatrix_slice& M2) {
7280  return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7281 }
7282 
7284 inline cimatrix operator+(const scmatrix_slice& M1, const cimatrix_slice& M2) {
7285  return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7286 }
7287 
7289 inline cimatrix operator+(const simatrix_slice& M1, const cmatrix_slice& M2) {
7290  return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7291 }
7292 
7294 inline cimatrix operator+(const scmatrix_slice& M1, const imatrix_slice& M2) {
7295  return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7296 }
7297 
7299 inline cimatrix operator+(const cimatrix_slice& M1, const srmatrix_slice& M2) {
7300  return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7301 }
7302 
7304 inline cimatrix operator+(const cimatrix_slice& M1, const simatrix_slice& M2) {
7305  return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7306 }
7307 
7309 inline cimatrix operator+(const cimatrix_slice& M1, const scmatrix_slice& M2) {
7310  return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7311 }
7312 
7314 inline cimatrix operator+(const cimatrix_slice& M1, const scimatrix_slice& M2) {
7315  return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7316 }
7317 
7319 inline cimatrix operator+(const rmatrix_slice& M1, const scimatrix_slice& M2) {
7320  return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7321 }
7322 
7324 inline cimatrix operator+(const imatrix_slice& M1, const scimatrix_slice& M2) {
7325  return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7326 }
7327 
7329 inline cimatrix operator+(const cmatrix_slice& M1, const scimatrix_slice& M2) {
7330  return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7331 }
7332 
7334 inline cimatrix operator+(const imatrix_slice& M1, const scmatrix_slice& M2) {
7335  return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7336 }
7337 
7339 inline cimatrix operator+(const cmatrix_slice& M1, const simatrix_slice& M2) {
7340  return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7341 }
7342 
7344 inline 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 
7349 inline 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 
7354 inline 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 
7359 inline 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 
7364 inline 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 
7369 inline 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 
7374 inline 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 
7379 inline 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 
7384 inline 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 
7389 inline scimatrix operator-(const scimatrix_slice& M1, const srmatrix& M2) {
7390  return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7391 }
7392 
7394 inline scimatrix operator-(const scimatrix_slice& M1, const scmatrix& M2) {
7395  return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7396 }
7397 
7399 inline scimatrix operator-(const scimatrix_slice& M1, const simatrix& M2) {
7400  return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7401 }
7402 
7404 inline scimatrix operator-(const scimatrix_slice& M1, const scimatrix& M2) {
7405  return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7406 }
7407 
7409 inline scimatrix operator-(const srmatrix_slice& M1, const scimatrix& M2) {
7410  return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7411 }
7412 
7414 inline scimatrix operator-(const simatrix_slice& M1, const scimatrix& M2) {
7415  return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7416 }
7417 
7419 inline scimatrix operator-(const scmatrix_slice& M1, const scimatrix& M2) {
7420  return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7421 }
7422 
7424 inline scimatrix operator-(const simatrix_slice& M1, const scmatrix& M2) {
7425  return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7426 }
7427 
7429 inline scimatrix operator-(const scmatrix_slice& M1, const simatrix& M2) {
7430  return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7431 }
7432 
7434 inline scimatrix operator-(const scimatrix& M1, const srmatrix_slice& M2) {
7435  return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7436 }
7437 
7439 inline scimatrix operator-(const scimatrix& M1, const scmatrix_slice& M2) {
7440  return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7441 }
7442 
7444 inline scimatrix operator-(const scimatrix& M1, const simatrix_slice& M2) {
7445  return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7446 }
7447 
7449 inline scimatrix operator-(const scimatrix& M1, const scimatrix_slice& M2) {
7450  return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7451 }
7452 
7454 inline scimatrix operator-(const srmatrix& M1, const scimatrix_slice& M2) {
7455  return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7456 }
7457 
7459 inline scimatrix operator-(const simatrix& M1, const scimatrix_slice& M2) {
7460  return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7461 }
7462 
7464 inline scimatrix operator-(const scmatrix& M1, const scimatrix_slice& M2) {
7465  return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7466 }
7467 
7469 inline scimatrix operator-(const simatrix& M1, const scmatrix_slice& M2) {
7470  return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7471 }
7472 
7474 inline scimatrix operator-(const scmatrix& M1, const simatrix_slice& M2) {
7475  return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7476 }
7477 
7479 inline cimatrix operator-(const scimatrix_slice& M1, const rmatrix& M2) {
7480  return spf_mm_sub<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7481 }
7482 
7484 inline cimatrix operator-(const scimatrix_slice& M1, const imatrix& M2) {
7485  return spf_mm_sub<scimatrix,imatrix,cimatrix>(M1.A,M2);
7486 }
7487 
7489 inline cimatrix operator-(const scimatrix_slice& M1, const cmatrix& M2) {
7490  return spf_mm_sub<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7491 }
7492 
7494 inline cimatrix operator-(const scimatrix_slice& M1, const cimatrix& M2) {
7495  return spf_mm_sub<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7496 }
7497 
7499 inline cimatrix operator-(const srmatrix_slice& M1, const cimatrix& M2) {
7500  return spf_mm_sub<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7501 }
7502 
7504 inline cimatrix operator-(const simatrix_slice& M1, const cimatrix& M2) {
7505  return spf_mm_sub<simatrix,cimatrix,cimatrix>(M1.A,M2);
7506 }
7507 
7509 inline cimatrix operator-(const scmatrix_slice& M1, const cimatrix& M2) {
7510  return spf_mm_sub<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7511 }
7512 
7514 inline cimatrix operator-(const simatrix_slice& M1, const cmatrix& M2) {
7515  return spf_mm_sub<simatrix,cmatrix,cimatrix>(M1.A,M2);
7516 }
7517 
7519 inline cimatrix operator-(const scmatrix_slice& M1, const imatrix& M2) {
7520  return spf_mm_sub<scmatrix,imatrix,cimatrix>(M1.A,M2);
7521 }
7522 
7524 inline cimatrix operator-(const cimatrix& M1, const srmatrix_slice& M2) {
7525  return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7526 }
7527 
7529 inline cimatrix operator-(const cimatrix& M1, const simatrix_slice& M2) {
7530  return fsp_mm_sub<cimatrix,simatrix,cimatrix>(M1,M2.A);
7531 }
7532 
7534 inline cimatrix operator-(const cimatrix& M1, const scmatrix_slice& M2) {
7535  return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7536 }
7537 
7539 inline cimatrix operator-(const cimatrix& M1, const scimatrix_slice& M2) {
7540  return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7541 }
7542 
7544 inline cimatrix operator-(const rmatrix& M1, const scimatrix_slice& M2) {
7545  return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7546 }
7547 
7549 inline cimatrix operator-(const imatrix& M1, const scimatrix_slice& M2) {
7550  return fsp_mm_sub<imatrix,scimatrix,cimatrix>(M1,M2.A);
7551 }
7552 
7554 inline cimatrix operator-(const cmatrix& M1, const scimatrix_slice& M2) {
7555  return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7556 }
7557 
7559 inline cimatrix operator-(const imatrix& M1, const scmatrix_slice& M2) {
7560  return fsp_mm_sub<imatrix,scmatrix,cimatrix>(M1,M2.A);
7561 }
7562 
7564 inline cimatrix operator-(const cmatrix& M1, const simatrix_slice& M2) {
7565  return fsp_mm_sub<cmatrix,simatrix,cimatrix>(M1,M2.A);
7566 }
7567 
7569 inline cimatrix operator-(const scimatrix_slice& M1, const rmatrix_slice& M2) {
7570  return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7571 }
7572 
7574 inline cimatrix operator-(const scimatrix_slice& M1, const cmatrix_slice& M2) {
7575  return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7576 }
7577 
7579 inline cimatrix operator-(const scimatrix_slice& M1, const imatrix_slice& M2) {
7580  return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7581 }
7582 
7584 inline cimatrix operator-(const scimatrix_slice& M1, const cimatrix_slice& M2) {
7585  return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7586 }
7587 
7589 inline cimatrix operator-(const srmatrix_slice& M1, const cimatrix_slice& M2) {
7590  return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7591 }
7592 
7594 inline cimatrix operator-(const simatrix_slice& M1, const cimatrix_slice& M2) {
7595  return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7596 }
7597 
7599 inline cimatrix operator-(const scmatrix_slice& M1, const cimatrix_slice& M2) {
7600  return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7601 }
7602 
7604 inline cimatrix operator-(const simatrix_slice& M1, const cmatrix_slice& M2) {
7605  return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7606 }
7607 
7609 inline cimatrix operator-(const scmatrix_slice& M1, const imatrix_slice& M2) {
7610  return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7611 }
7612 
7614 inline cimatrix operator-(const cimatrix_slice& M1, const srmatrix_slice& M2) {
7615  return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7616 }
7617 
7619 inline cimatrix operator-(const cimatrix_slice& M1, const simatrix_slice& M2) {
7620  return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7621 }
7622 
7624 inline cimatrix operator-(const cimatrix_slice& M1, const scmatrix_slice& M2) {
7625  return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7626 }
7627 
7629 inline cimatrix operator-(const cimatrix_slice& M1, const scimatrix_slice& M2) {
7630  return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7631 }
7632 
7634 inline cimatrix operator-(const rmatrix_slice& M1, const scimatrix_slice& M2) {
7635  return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7636 }
7637 
7639 inline cimatrix operator-(const imatrix_slice& M1, const scimatrix_slice& M2) {
7640  return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7641 }
7642 
7644 inline cimatrix operator-(const cmatrix_slice& M1, const scimatrix_slice& M2) {
7645  return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7646 }
7647 
7649 inline cimatrix operator-(const imatrix_slice& M1, const scmatrix_slice& M2) {
7650  return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7651 }
7652 
7654 inline cimatrix operator-(const cmatrix_slice& M1, const simatrix_slice& M2) {
7655  return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7656 }
7657 
7659 inline 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 
7664 inline 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 
7669 inline 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 
7674 inline 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 
7679 inline 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 
7684 inline 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 
7689 inline 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 
7694 inline 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 
7699 inline 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 
7704 inline scimatrix operator|(const scimatrix_slice& M1, const srmatrix& M2) {
7705  return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7706 }
7707 
7709 inline scimatrix operator|(const scimatrix_slice& M1, const scmatrix& M2) {
7710  return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7711 }
7712 
7714 inline scimatrix operator|(const scimatrix_slice& M1, const simatrix& M2) {
7715  return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7716 }
7717 
7719 inline scimatrix operator|(const scimatrix_slice& M1, const scimatrix& M2) {
7720  return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7721 }
7722 
7724 inline scimatrix operator|(const srmatrix_slice& M1, const scimatrix& M2) {
7725  return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7726 }
7727 
7729 inline scimatrix operator|(const simatrix_slice& M1, const scimatrix& M2) {
7730  return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7731 }
7732 
7734 inline scimatrix operator|(const scmatrix_slice& M1, const scimatrix& M2) {
7735  return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7736 }
7737 
7739 inline scimatrix operator|(const simatrix_slice& M1, const scmatrix& M2) {
7740  return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7741 }
7742 
7744 inline scimatrix operator|(const scmatrix_slice& M1, const simatrix& M2) {
7745  return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7746 }
7747 
7749 inline scimatrix operator|(const scimatrix& M1, const srmatrix_slice& M2) {
7750  return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7751 }
7752 
7754 inline scimatrix operator|(const scimatrix& M1, const scmatrix_slice& M2) {
7755  return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7756 }
7757 
7759 inline scimatrix operator|(const scimatrix& M1, const simatrix_slice& M2) {
7760  return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7761 }
7762 
7764 inline scimatrix operator|(const scimatrix& M1, const scimatrix_slice& M2) {
7765  return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7766 }
7767 
7769 inline scimatrix operator|(const srmatrix& M1, const scimatrix_slice& M2) {
7770  return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7771 }
7772 
7774 inline scimatrix operator|(const simatrix& M1, const scimatrix_slice& M2) {
7775  return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7776 }
7777 
7779 inline scimatrix operator|(const scmatrix& M1, const scimatrix_slice& M2) {
7780  return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7781 }
7782 
7784 inline scimatrix operator|(const simatrix& M1, const scmatrix_slice& M2) {
7785  return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7786 }
7787 
7789 inline scimatrix operator|(const scmatrix& M1, const simatrix_slice& M2) {
7790  return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7791 }
7792 
7794 inline cimatrix operator|(const scimatrix_slice& M1, const rmatrix& M2) {
7795  return spf_mm_hull<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7796 }
7797 
7799 inline cimatrix operator|(const scimatrix_slice& M1, const imatrix& M2) {
7800  return spf_mm_hull<scimatrix,imatrix,cimatrix>(M1.A,M2);
7801 }
7802 
7804 inline cimatrix operator|(const scimatrix_slice& M1, const cmatrix& M2) {
7805  return spf_mm_hull<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7806 }
7807 
7809 inline cimatrix operator|(const scimatrix_slice& M1, const cimatrix& M2) {
7810  return spf_mm_hull<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7811 }
7812 
7814 inline cimatrix operator|(const srmatrix_slice& M1, const cimatrix& M2) {
7815  return spf_mm_hull<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7816 }
7817 
7819 inline cimatrix operator|(const simatrix_slice& M1, const cimatrix& M2) {
7820  return spf_mm_hull<simatrix,cimatrix,cimatrix>(M1.A,M2);
7821 }
7822 
7824 inline cimatrix operator|(const scmatrix_slice& M1, const cimatrix& M2) {
7825  return spf_mm_hull<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7826 }
7827 
7829 inline cimatrix operator|(const simatrix_slice& M1, const cmatrix& M2) {
7830  return spf_mm_hull<simatrix,cmatrix,cimatrix>(M1.A,M2);
7831 }
7832 
7834 inline cimatrix operator|(const scmatrix_slice& M1, const imatrix& M2) {
7835  return spf_mm_hull<scmatrix,imatrix,cimatrix>(M1.A,M2);
7836 }
7837 
7839 inline cimatrix operator|(const cimatrix& M1, const srmatrix_slice& M2) {
7840  return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7841 }
7842 
7844 inline cimatrix operator|(const cimatrix& M1, const simatrix_slice& M2) {
7845  return fsp_mm_hull<cimatrix,simatrix,cimatrix>(M1,M2.A);
7846 }
7847 
7849 inline cimatrix operator|(const cimatrix& M1, const scmatrix_slice& M2) {
7850  return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7851 }
7852 
7854 inline cimatrix operator|(const cimatrix& M1, const scimatrix_slice& M2) {
7855  return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7856 }
7857 
7859 inline cimatrix operator|(const rmatrix& M1, const scimatrix_slice& M2) {
7860  return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7861 }
7862 
7864 inline cimatrix operator|(const imatrix& M1, const scimatrix_slice& M2) {
7865  return fsp_mm_hull<imatrix,scimatrix,cimatrix>(M1,M2.A);
7866 }
7867 
7869 inline cimatrix operator|(const cmatrix& M1, const scimatrix_slice& M2) {
7870  return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7871 }
7872 
7874 inline cimatrix operator|(const imatrix& M1, const scmatrix_slice& M2) {
7875  return fsp_mm_hull<imatrix,scmatrix,cimatrix>(M1,M2.A);
7876 }
7877 
7879 inline cimatrix operator|(const cmatrix& M1, const simatrix_slice& M2) {
7880  return fsp_mm_hull<cmatrix,simatrix,cimatrix>(M1,M2.A);
7881 }
7882 
7884 inline cimatrix operator|(const scimatrix_slice& M1, const rmatrix_slice& M2) {
7885  return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7886 }
7887 
7889 inline cimatrix operator|(const scimatrix_slice& M1, const cmatrix_slice& M2) {
7890  return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7891 }
7892 
7894 inline cimatrix operator|(const scimatrix_slice& M1, const imatrix_slice& M2) {
7895  return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7896 }
7897 
7899 inline cimatrix operator|(const scimatrix_slice& M1, const cimatrix_slice& M2) {
7900  return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7901 }
7902 
7904 inline cimatrix operator|(const srmatrix_slice& M1, const cimatrix_slice& M2) {
7905  return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7906 }
7907 
7909 inline cimatrix operator|(const simatrix_slice& M1, const cimatrix_slice& M2) {
7910  return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7911 }
7912 
7914 inline cimatrix operator|(const scmatrix_slice& M1, const cimatrix_slice& M2) {
7915  return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7916 }
7917 
7919 inline cimatrix operator|(const simatrix_slice& M1, const cmatrix_slice& M2) {
7920  return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7921 }
7922 
7924 inline cimatrix operator|(const scmatrix_slice& M1, const imatrix_slice& M2) {
7925  return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7926 }
7927 
7929 inline cimatrix operator|(const cimatrix_slice& M1, const srmatrix_slice& M2) {
7930  return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7931 }
7932 
7934 inline cimatrix operator|(const cimatrix_slice& M1, const simatrix_slice& M2) {
7935  return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7936 }
7937 
7939 inline cimatrix operator|(const cimatrix_slice& M1, const scmatrix_slice& M2) {
7940  return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7941 }
7942 
7944 inline cimatrix operator|(const cimatrix_slice& M1, const scimatrix_slice& M2) {
7945  return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7946 }
7947 
7949 inline cimatrix operator|(const rmatrix_slice& M1, const scimatrix_slice& M2) {
7950  return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7951 }
7952 
7954 inline cimatrix operator|(const imatrix_slice& M1, const scimatrix_slice& M2) {
7955  return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7956 }
7957 
7959 inline cimatrix operator|(const cmatrix_slice& M1, const scimatrix_slice& M2) {
7960  return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7961 }
7962 
7964 inline cimatrix operator|(const imatrix_slice& M1, const scmatrix_slice& M2) {
7965  return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7966 }
7967 
7969 inline cimatrix operator|(const cmatrix_slice& M1, const simatrix_slice& M2) {
7970  return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7971 }
7972 
7974 inline 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 
7979 inline 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 
7984 inline 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 
7989 inline scimatrix operator|(const scmatrix_slice& M1, const srmatrix& M2) {
7990  return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7991 }
7992 
7994 inline scimatrix operator|(const srmatrix_slice& M1, const scmatrix& M2) {
7995  return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7996 }
7997 
7999 inline scimatrix operator|(const scmatrix_slice& M1, const scmatrix& M2) {
8000  return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
8001 }
8002 
8004 inline scimatrix operator|(const scmatrix& M1, const srmatrix_slice& M2) {
8005  return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
8006 }
8007 
8009 inline scimatrix operator|(const srmatrix& M1, const scmatrix_slice& M2) {
8010  return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
8011 }
8012 
8014 inline scimatrix operator|(const scmatrix& M1, const scmatrix_slice& M2) {
8015  return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
8016 }
8017 
8019 inline cimatrix operator|(const scmatrix_slice& M1, const rmatrix& M2) {
8020  return spf_mm_hull<scmatrix,rmatrix,cimatrix>(M1.A,M2);
8021 }
8022 
8024 inline cimatrix operator|(const srmatrix_slice& M1, const cmatrix& M2) {
8025  return spf_mm_hull<srmatrix,cmatrix,cimatrix>(M1.A,M2);
8026 }
8027 
8029 inline cimatrix operator|(const scmatrix_slice& M1, const cmatrix& M2) {
8030  return spf_mm_hull<scmatrix,cmatrix,cimatrix>(M1.A,M2);
8031 }
8032 
8034 inline cimatrix operator|(const cmatrix& M1, const srmatrix_slice& M2) {
8035  return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(M1,M2.A);
8036 }
8037 
8039 inline cimatrix operator|(const rmatrix& M1, const scmatrix_slice& M2) {
8040  return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(M1,M2.A);
8041 }
8042 
8044 inline cimatrix operator|(const cmatrix& M1, const scmatrix_slice& M2) {
8045  return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(M1,M2.A);
8046 }
8047 
8049 inline cimatrix operator|(const scmatrix_slice& M1, const rmatrix_slice& M2) {
8050  return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(M1.A,M2);
8051 }
8052 
8054 inline cimatrix operator|(const srmatrix_slice& M1, const cmatrix_slice& M2) {
8055  return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
8056 }
8057 
8059 inline cimatrix operator|(const scmatrix_slice& M1, const cmatrix_slice& M2) {
8060  return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
8061 }
8062 
8064 inline cimatrix operator|(const cmatrix_slice& M1, const srmatrix_slice& M2) {
8065  return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(M1,M2.A);
8066 }
8067 
8069 inline cimatrix operator|(const rmatrix_slice& M1, const scmatrix_slice& M2) {
8070  return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
8071 }
8072 
8074 inline cimatrix operator|(const cmatrix_slice& M1, const scmatrix_slice& M2) {
8075  return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
8076 }
8077 
8079 inline 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 
8084 inline 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 
8089 inline 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 
8094 inline scimatrix operator&(const scimatrix_slice& M1, const simatrix& M2) {
8095  return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
8096 }
8097 
8099 inline scimatrix operator&(const scimatrix_slice& M1, const scimatrix& M2) {
8100  return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
8101 }
8102 
8104 inline scimatrix operator&(const simatrix_slice& M1, const scimatrix& M2) {
8105  return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
8106 }
8107 
8109 inline scimatrix operator&(const scimatrix& M1, const simatrix_slice& M2) {
8110  return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
8111 }
8112 
8114 inline scimatrix operator&(const scimatrix& M1, const scimatrix_slice& M2) {
8115  return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
8116 }
8117 
8119 inline scimatrix operator&(const simatrix& M1, const scimatrix_slice& M2) {
8120  return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
8121 }
8122 
8124 inline cimatrix operator&(const scimatrix_slice& M1, const imatrix& M2) {
8125  return spf_mm_intersect<scimatrix,imatrix,cimatrix>(M1.A,M2);
8126 }
8127 
8129 inline cimatrix operator&(const scimatrix_slice& M1, const cimatrix& M2) {
8130  return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(M1.A,M2);
8131 }
8132 
8134 inline cimatrix operator&(const simatrix_slice& M1, const cimatrix& M2) {
8135  return spf_mm_intersect<simatrix,cimatrix,cimatrix>(M1.A,M2);
8136 }
8137 
8139 inline cimatrix operator&(const cimatrix& M1, const simatrix_slice& M2) {
8140  return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(M1,M2.A);
8141 }
8142 
8144 inline cimatrix operator&(const cimatrix& M1, const scimatrix_slice& M2) {
8145  return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(M1,M2.A);
8146 }
8147 
8149 inline cimatrix operator&(const imatrix& M1, const scimatrix_slice& M2) {
8150  return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(M1,M2.A);
8151 }
8152 
8154 inline cimatrix operator&(const scimatrix_slice& M1, const imatrix_slice& M2) {
8155  return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
8156 }
8157 
8159 inline cimatrix operator&(const scimatrix_slice& M1, const cimatrix_slice& M2) {
8160  return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
8161 }
8162 
8164 inline cimatrix operator&(const simatrix_slice& M1, const cimatrix_slice& M2) {
8165  return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
8166 }
8167 
8169 inline cimatrix operator&(const cimatrix_slice& M1, const simatrix_slice& M2) {
8170  return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
8171 }
8172 
8174 inline cimatrix operator&(const cimatrix_slice& M1, const scimatrix_slice& M2) {
8175  return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
8176 }
8177 
8179 inline 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 
8404 inline bool operator==(const scimatrix_slice& M1, const srmatrix_slice& M2) {
8405  return spsp_mm_comp(M1.A,M2.A);
8406 }
8407 
8409 inline bool operator==(const scimatrix_slice& M1, const scmatrix_slice& M2) {
8410  return spsp_mm_comp(M1.A,M2.A);
8411 }
8412 
8414 inline bool operator==(const scimatrix_slice& M1, const simatrix_slice& M2) {
8415  return spsp_mm_comp(M1.A,M2.A);
8416 }
8417 
8419 inline bool operator==(const scimatrix_slice& M1, const scimatrix_slice& M2) {
8420  return spsp_mm_comp(M1.A,M2.A);
8421 }
8422 
8424 inline bool operator==(const srmatrix_slice& M1, const scimatrix_slice& M2) {
8425  return spsp_mm_comp(M1.A,M2.A);
8426 }
8427 
8429 inline bool operator==(const scmatrix_slice& M1, const scimatrix_slice& M2) {
8430  return spsp_mm_comp(M1.A,M2.A);
8431 }
8432 
8434 inline bool operator==(const simatrix_slice& M1, const scimatrix_slice& M2) {
8435  return spsp_mm_comp(M1.A,M2.A);
8436 }
8437 
8439 inline bool operator==(const scimatrix_slice& M1, const srmatrix& M2) {
8440  return spsp_mm_comp(M1.A,M2);
8441 }
8442 
8444 inline bool operator==(const scimatrix_slice& M1, const scmatrix& M2) {
8445  return spsp_mm_comp(M1.A,M2);
8446 }
8447 
8449 inline bool operator==(const scimatrix_slice& M1, const simatrix& M2) {
8450  return spsp_mm_comp(M1.A,M2);
8451 }
8452 
8454 inline bool operator==(const scimatrix_slice& M1, const scimatrix& M2) {
8455  return spsp_mm_comp(M1.A,M2);
8456 }
8457 
8459 inline bool operator==(const srmatrix_slice& M1, const scimatrix& M2) {
8460  return spsp_mm_comp(M1.A,M2);
8461 }
8462 
8464 inline bool operator==(const scmatrix_slice& M1, const scimatrix& M2) {
8465  return spsp_mm_comp(M1.A,M2);
8466 }
8467 
8469 inline bool operator==(const simatrix_slice& M1, const scimatrix& M2) {
8470  return spsp_mm_comp(M1.A,M2);
8471 }
8472 
8474 inline bool operator==(const scimatrix& M1, const srmatrix_slice& M2) {
8475  return spsp_mm_comp(M1,M2.A);
8476 }
8477 
8479 inline bool operator==(const scimatrix& M1, const scmatrix_slice& M2) {
8480  return spsp_mm_comp(M1,M2.A);
8481 }
8482 
8484 inline bool operator==(const scimatrix& M1, const simatrix_slice& M2) {
8485  return spsp_mm_comp(M1,M2.A);
8486 }
8487 
8489 inline bool operator==(const scimatrix& M1, const scimatrix_slice& M2) {
8490  return spsp_mm_comp(M1,M2.A);
8491 }
8492 
8494 inline bool operator==(const srmatrix& M1, const scimatrix_slice& M2) {
8495  return spsp_mm_comp(M1,M2.A);
8496 }
8497 
8499 inline bool operator==(const scmatrix& M1, const scimatrix_slice& M2) {
8500  return spsp_mm_comp(M1,M2.A);
8501 }
8502 
8504 inline bool operator==(const simatrix& M1, const scimatrix_slice& M2) {
8505  return spsp_mm_comp(M1,M2.A);
8506 }
8507 
8509 inline bool operator==(const scimatrix_slice& M1, const rmatrix& M2) {
8510  return spf_mm_comp(M1.A,M2);
8511 }
8512 
8514 inline bool operator==(const scimatrix_slice& M1, const cmatrix& M2) {
8515  return spf_mm_comp(M1.A,M2);
8516 }
8517 
8519 inline bool operator==(const scimatrix_slice& M1, const imatrix& M2) {
8520  return spf_mm_comp(M1.A,M2);
8521 }
8522 
8524 inline bool operator==(const scimatrix_slice& M1, const cimatrix& M2) {
8525  return spf_mm_comp(M1.A,M2);
8526 }
8527 
8529 inline bool operator==(const srmatrix_slice& M1, const cimatrix& M2) {
8530  return spf_mm_comp(M1.A,M2);
8531 }
8532 
8534 inline bool operator==(const scmatrix_slice& M1, const cimatrix& M2) {
8535  return spf_mm_comp(M1.A,M2);
8536 }
8537 
8539 inline bool operator==(const simatrix_slice& M1, const cimatrix& M2) {
8540  return spf_mm_comp(M1.A,M2);
8541 }
8542 
8544 inline bool operator==(const cimatrix& M1, const srmatrix_slice& M2) {
8545  return fsp_mm_comp(M1,M2.A);
8546 }
8547 
8549 inline bool operator==(const cimatrix& M1, const simatrix_slice& M2) {
8550  return fsp_mm_comp(M1,M2.A);
8551 }
8552 
8554 inline bool operator==(const cimatrix& M1, const scmatrix_slice& M2) {
8555  return fsp_mm_comp(M1,M2.A);
8556 }
8557 
8559 inline bool operator==(const cimatrix& M1, const scimatrix_slice& M2) {
8560  return fsp_mm_comp(M1,M2.A);
8561 }
8562 
8564 inline bool operator==(const rmatrix& M1, const scimatrix_slice& M2) {
8565  return fsp_mm_comp(M1,M2.A);
8566 }
8567 
8569 inline bool operator==(const imatrix& M1, const scimatrix_slice& M2) {
8570  return fsp_mm_comp(M1,M2.A);
8571 }
8572 
8574 inline bool operator==(const cmatrix& M1, const scimatrix_slice& M2) {
8575  return fsp_mm_comp(M1,M2.A);
8576 }
8577 
8579 inline bool operator==(const cimatrix_slice& M1, const srmatrix_slice& M2) {
8580  return fsp_mm_comp(M1,M2.A);
8581 }
8582 
8584 inline bool operator==(const cimatrix_slice& M1, const simatrix_slice& M2) {
8585  return fsp_mm_comp(M1,M2.A);
8586 }
8587 
8589 inline bool operator==(const cimatrix_slice& M1, const scmatrix_slice& M2) {
8590  return fsp_mm_comp(M1,M2.A);
8591 }
8592 
8594 inline bool operator==(const cimatrix_slice& M1, const scimatrix_slice& M2) {
8595  return fsp_mm_comp(M1,M2.A);
8596 }
8597 
8599 inline bool operator==(const rmatrix_slice& M1, const scimatrix_slice& M2) {
8600  return fsp_mm_comp(M1,M2.A);
8601 }
8602 
8604 inline bool operator==(const imatrix_slice& M1, const scimatrix_slice& M2) {
8605  return fsp_mm_comp(M1,M2.A);
8606 }
8607 
8609 inline bool operator==(const cmatrix_slice& M1, const scimatrix_slice& M2) {
8610  return fsp_mm_comp(M1,M2.A);
8611 }
8612 
8614 inline bool operator==(const scimatrix_slice& M1, const rmatrix_slice& M2) {
8615  return spf_mm_comp(M1.A,M2);
8616 }
8617 
8619 inline bool operator==(const scimatrix_slice& M1, const cmatrix_slice& M2) {
8620  return spf_mm_comp(M1.A,M2);
8621 }
8622 
8624 inline bool operator==(const scimatrix_slice& M1, const imatrix_slice& M2) {
8625  return spf_mm_comp(M1.A,M2);
8626 }
8627 
8629 inline bool operator==(const scimatrix_slice& M1, const cimatrix_slice& M2) {
8630  return spf_mm_comp(M1.A,M2);
8631 }
8632 
8634 inline bool operator==(const srmatrix_slice& M1, const cimatrix_slice& M2) {
8635  return spf_mm_comp(M1.A,M2);
8636 }
8637 
8639 inline bool operator==(const simatrix_slice& M1, const cimatrix_slice& M2) {
8640  return spf_mm_comp(M1.A,M2);
8641 }
8642 
8644 inline bool operator==(const scmatrix_slice& M1, const cimatrix_slice& M2) {
8645  return spf_mm_comp(M1.A,M2);
8646 }
8647 
8649 inline bool operator!=(const scimatrix_slice& M1, const srmatrix_slice& M2) {
8650  return !spsp_mm_comp(M1.A,M2.A);
8651 }
8652 
8654 inline bool operator!=(const scimatrix_slice& M1, const scmatrix_slice& M2) {
8655  return !spsp_mm_comp(M1.A,M2.A);
8656 }
8657 
8659 inline bool operator!=(const scimatrix_slice& M1, const simatrix_slice& M2) {
8660  return !spsp_mm_comp(M1.A,M2.A);
8661 }
8662 
8664 inline bool operator!=(const scimatrix_slice& M1, const scimatrix_slice& M2) {
8665  return !spsp_mm_comp(M1.A,M2.A);
8666 }
8667 
8669 inline bool operator!=(const srmatrix_slice& M1, const scimatrix_slice& M2) {
8670  return !spsp_mm_comp(M1.A,M2.A);
8671 }
8672 
8674 inline bool operator!=(const scmatrix_slice& M1, const scimatrix_slice& M2) {
8675  return !spsp_mm_comp(M1.A,M2.A);
8676 }
8677 
8679 inline bool operator!=(const simatrix_slice& M1, const scimatrix_slice& M2) {
8680  return !spsp_mm_comp(M1.A,M2.A);
8681 }
8682 
8684 inline bool operator!=(const scimatrix_slice& M1, const srmatrix& M2) {
8685  return !spsp_mm_comp(M1.A,M2);
8686 }
8687 
8689 inline bool operator!=(const scimatrix_slice& M1, const scmatrix& M2) {
8690  return !spsp_mm_comp(M1.A,M2);
8691 }
8692 
8694 inline bool operator!=(const scimatrix_slice& M1, const simatrix& M2) {
8695  return !spsp_mm_comp(M1.A,M2);
8696 }
8697 
8699 inline bool operator!=(const scimatrix_slice& M1, const scimatrix& M2) {
8700  return !spsp_mm_comp(M1.A,M2);
8701 }
8702 
8704 inline bool operator!=(const srmatrix_slice& M1, const scimatrix& M2) {
8705  return !spsp_mm_comp(M1.A,M2);
8706 }
8707 
8709 inline bool operator!=(const scmatrix_slice& M1, const scimatrix& M2) {
8710  return !spsp_mm_comp(M1.A,M2);
8711 }
8712 
8714 inline bool operator!=(const simatrix_slice& M1, const scimatrix& M2) {
8715  return !spsp_mm_comp(M1.A,M2);
8716 }
8717 
8719 inline bool operator!=(const scimatrix& M1, const srmatrix_slice& M2) {
8720  return !spsp_mm_comp(M1,M2.A);
8721 }
8722 
8724 inline bool operator!=(const scimatrix& M1, const scmatrix_slice& M2) {
8725  return !spsp_mm_comp(M1,M2.A);
8726 }
8727 
8729 inline bool operator!=(const scimatrix& M1, const simatrix_slice& M2) {
8730  return !spsp_mm_comp(M1,M2.A);
8731 }
8732 
8734 inline bool operator!=(const scimatrix& M1, const scimatrix_slice& M2) {
8735  return !spsp_mm_comp(M1,M2.A);
8736 }
8737 
8739 inline bool operator!=(const srmatrix& M1, const scimatrix_slice& M2) {
8740  return !spsp_mm_comp(M1,M2.A);
8741 }
8742 
8744 inline bool operator!=(const scmatrix& M1, const scimatrix_slice& M2) {
8745  return !spsp_mm_comp(M1,M2.A);
8746 }
8747 
8749 inline bool operator!=(const simatrix& M1, const scimatrix_slice& M2) {
8750  return !spsp_mm_comp(M1,M2.A);
8751 }
8752 
8754 inline bool operator!=(const scimatrix_slice& M1, const rmatrix& M2) {
8755  return !spf_mm_comp(M1.A,M2);
8756 }
8757 
8759 inline bool operator!=(const scimatrix_slice& M1, const cmatrix& M2) {
8760  return !spf_mm_comp(M1.A,M2);
8761 }
8762 
8764 inline bool operator!=(const scimatrix_slice& M1, const imatrix& M2) {
8765  return !spf_mm_comp(M1.A,M2);
8766 }
8767 
8769 inline bool operator!=(const scimatrix_slice& M1, const cimatrix& M2) {
8770  return !spf_mm_comp(M1.A,M2);
8771 }
8772 
8774 inline bool operator!=(const srmatrix_slice& M1, const cimatrix& M2) {
8775  return !spf_mm_comp(M1.A,M2);
8776 }
8777 
8779 inline bool operator!=(const scmatrix_slice& M1, const cimatrix& M2) {
8780  return !spf_mm_comp(M1.A,M2);
8781 }
8782 
8784 inline bool operator!=(const simatrix_slice& M1, const cimatrix& M2) {
8785  return !spf_mm_comp(M1.A,M2);
8786 }
8787 
8789 inline bool operator!=(const cimatrix& M1, const srmatrix_slice& M2) {
8790  return !fsp_mm_comp(M1,M2.A);
8791 }
8792 
8794 inline bool operator!=(const cimatrix& M1, const simatrix_slice& M2) {
8795  return !fsp_mm_comp(M1,M2.A);
8796 }
8797 
8799 inline bool operator!=(const cimatrix& M1, const scmatrix_slice& M2) {
8800  return !fsp_mm_comp(M1,M2.A);
8801 }
8802 
8804 inline bool operator!=(const cimatrix& M1, const scimatrix_slice& M2) {
8805  return !fsp_mm_comp(M1,M2.A);
8806 }
8807 
8809 inline bool operator!=(const rmatrix& M1, const scimatrix_slice& M2) {
8810  return !fsp_mm_comp(M1,M2.A);
8811 }
8812 
8814 inline bool operator!=(const imatrix& M1, const scimatrix_slice& M2) {
8815  return !fsp_mm_comp(M1,M2.A);
8816 }
8817 
8819 inline bool operator!=(const cmatrix& M1, const scimatrix_slice& M2) {
8820  return !fsp_mm_comp(M1,M2.A);
8821 }
8822 
8824 inline bool operator!=(const cimatrix_slice& M1, const srmatrix_slice& M2) {
8825  return !fsp_mm_comp(M1,M2.A);
8826 }
8827 
8829 inline bool operator!=(const cimatrix_slice& M1, const simatrix_slice& M2) {
8830  return !fsp_mm_comp(M1,M2.A);
8831 }
8832 
8834 inline bool operator!=(const cimatrix_slice& M1, const scmatrix_slice& M2) {
8835  return !fsp_mm_comp(M1,M2.A);
8836 }
8837 
8839 inline bool operator!=(const cimatrix_slice& M1, const scimatrix_slice& M2) {
8840  return !fsp_mm_comp(M1,M2.A);
8841 }
8842 
8844 inline bool operator!=(const rmatrix_slice& M1, const scimatrix_slice& M2) {
8845  return !fsp_mm_comp(M1,M2.A);
8846 }
8847 
8849 inline bool operator!=(const imatrix_slice& M1, const scimatrix_slice& M2) {
8850  return !fsp_mm_comp(M1,M2.A);
8851 }
8852 
8854 inline bool operator!=(const cmatrix_slice& M1, const scimatrix_slice& M2) {
8855  return !fsp_mm_comp(M1,M2.A);
8856 }
8857 
8859 inline bool operator!=(const scimatrix_slice& M1, const rmatrix_slice& M2) {
8860  return !spf_mm_comp(M1.A,M2);
8861 }
8862 
8864 inline bool operator!=(const scimatrix_slice& M1, const cmatrix_slice& M2) {
8865  return !spf_mm_comp(M1.A,M2);
8866 }
8867 
8869 inline bool operator!=(const scimatrix_slice& M1, const imatrix_slice& M2) {
8870  return !spf_mm_comp(M1.A,M2);
8871 }
8872 
8874 inline bool operator!=(const scimatrix_slice& M1, const cimatrix_slice& M2) {
8875  return !spf_mm_comp(M1.A,M2);
8876 }
8877 
8879 inline bool operator!=(const srmatrix_slice& M1, const cimatrix_slice& M2) {
8880  return !spf_mm_comp(M1.A,M2);
8881 }
8882 
8884 inline bool operator!=(const simatrix_slice& M1, const cimatrix_slice& M2) {
8885  return !spf_mm_comp(M1.A,M2);
8886 }
8887 
8889 inline bool operator!=(const scmatrix_slice& M1, const cimatrix_slice& M2) {
8890  return !spf_mm_comp(M1.A,M2);
8891 }
8892 
8894 inline bool operator<(const scimatrix_slice& M1, const simatrix_slice& M2) {
8895  return spsp_mm_less<scimatrix,simatrix,cinterval>(M1.A,M2.A);
8896 }
8897 
8899 inline bool operator<(const scimatrix_slice& M1, const scimatrix_slice& M2) {
8900  return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
8901 }
8902 
8904 inline bool operator<(const srmatrix_slice& M1, const scimatrix_slice& M2) {
8905  return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1.A,M2.A);
8906 }
8907 
8909 inline bool operator<(const scmatrix_slice& M1, const scimatrix_slice& M2) {
8910  return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1.A,M2.A);
8911 }
8912 
8914 inline bool operator<(const simatrix_slice& M1, const scimatrix_slice& M2) {
8915  return spsp_mm_less<simatrix,scimatrix,cinterval>(M1.A,M2.A);
8916 }
8917 
8919 inline bool operator<(const scimatrix_slice& M1, const simatrix& M2) {
8920  return spsp_mm_less<scimatrix,simatrix,cinterval>(M1.A,M2);
8921 }
8922 
8924 inline bool operator<(const scimatrix_slice& M1, const scimatrix& M2) {
8925  return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1.A,M2);
8926 }
8927 
8929 inline bool operator<(const srmatrix_slice& M1, const scimatrix& M2) {
8930  return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1.A,M2);
8931 }
8932 
8934 inline bool operator<(const scmatrix_slice& M1, const scimatrix& M2) {
8935  return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1.A,M2);
8936 }
8937 
8939 inline bool operator<(const simatrix_slice& M1, const scimatrix& M2) {
8940  return spsp_mm_less<simatrix,scimatrix,cinterval>(M1.A,M2);
8941 }
8942 
8944 inline bool operator<(const scimatrix& M1, const simatrix_slice& M2) {
8945  return spsp_mm_less<scimatrix,simatrix,cinterval>(M1,M2.A);
8946 }
8947 
8949 inline bool operator<(const scimatrix& M1, const scimatrix_slice& M2) {
8950  return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1,M2.A);
8951 }
8952 
8954 inline bool operator<(const srmatrix& M1, const scimatrix_slice& M2) {
8955  return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1,M2.A);
8956 }
8957 
8959 inline bool operator<(const scmatrix& M1, const scimatrix_slice& M2) {
8960  return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1,M2.A);
8961 }
8962 
8964 inline bool operator<(const simatrix& M1, const scimatrix_slice& M2) {
8965  return spsp_mm_less<simatrix,scimatrix,cinterval>(M1,M2.A);
8966 }
8967 
8969 inline bool operator<(const scimatrix_slice& M1, const imatrix& M2) {
8970  return spf_mm_less<scimatrix,imatrix,cinterval>(M1.A,M2);
8971 }
8972 
8974 inline bool operator<(const scimatrix_slice& M1, const cimatrix& M2) {
8975  return spf_mm_less<scimatrix,cimatrix,cinterval>(M1.A,M2);
8976 }
8977 
8979 inline bool operator<(const srmatrix_slice& M1, const cimatrix& M2) {
8980  return spf_mm_less<srmatrix,cimatrix,cinterval>(M1.A,M2);
8981 }
8982 
8984 inline bool operator<(const scmatrix_slice& M1, const cimatrix& M2) {
8985  return spf_mm_less<scmatrix,cimatrix,cinterval>(M1.A,M2);
8986 }
8987 
8989 inline bool operator<(const simatrix_slice& M1, const cimatrix& M2) {
8990  return spf_mm_less<simatrix,cimatrix,cinterval>(M1.A,M2);
8991 }
8992 
8994 inline bool operator<(const cimatrix& M1, const simatrix_slice& M2) {
8995  return fsp_mm_less<cimatrix,simatrix,cinterval>(M1,M2.A);
8996 }
8997 
8999 inline bool operator<(const cimatrix& M1, const scimatrix_slice& M2) {
9000  return fsp_mm_less<cimatrix,scimatrix,cinterval>(M1,M2.A);
9001 }
9002 
9004 inline bool operator<(const rmatrix& M1, const scimatrix_slice& M2) {
9005  return fsp_mm_less<rmatrix,scimatrix,cinterval>(M1,M2.A);
9006 }
9007 
9009 inline bool operator<(const imatrix& M1, const scimatrix_slice& M2) {
9010  return fsp_mm_less<imatrix,scimatrix,cinterval>(M1,M2.A);
9011 }
9012 
9014 inline bool operator<(const cmatrix& M1, const scimatrix_slice& M2) {
9015  return fsp_mm_less<cmatrix,scimatrix,cinterval>(M1,M2.A);
9016 }
9017 
9019 inline bool operator<(const cimatrix_slice& M1, const simatrix_slice& M2) {
9020  return fsp_mm_less<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9021 }
9022 
9024 inline bool operator<(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9025  return fsp_mm_less<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9026 }
9027 
9029 inline bool operator<(const rmatrix_slice& M1, const scimatrix_slice& M2) {
9030  return fsp_mm_less<rmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9031 }
9032 
9034 inline bool operator<(const imatrix_slice& M1, const scimatrix_slice& M2) {
9035  return fsp_mm_less<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9036 }
9037 
9039 inline bool operator<(const cmatrix_slice& M1, const scimatrix_slice& M2) {
9040  return fsp_mm_less<cmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9041 }
9042 
9044 inline bool operator<(const scimatrix_slice& M1, const imatrix_slice& M2) {
9045  return spf_mm_less<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9046 }
9047 
9049 inline bool operator<(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9050  return spf_mm_less<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9051 }
9052 
9054 inline bool operator<(const srmatrix_slice& M1, const cimatrix_slice& M2) {
9055  return spf_mm_less<srmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9056 }
9057 
9059 inline bool operator<(const simatrix_slice& M1, const cimatrix_slice& M2) {
9060  return spf_mm_less<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9061 }
9062 
9064 inline bool operator<(const scmatrix_slice& M1, const cimatrix_slice& M2) {
9065  return spf_mm_less<scmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9066 }
9067 
9069 inline bool operator<=(const scimatrix_slice& M1, const simatrix_slice& M2) {
9070  return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9071 }
9072 
9074 inline bool operator<=(const scimatrix_slice& M1, const scimatrix_slice& M2) {
9075  return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9076 }
9077 
9079 inline bool operator<=(const srmatrix_slice& M1, const scimatrix_slice& M2) {
9080  return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1.A,M2.A);
9081 }
9082 
9084 inline bool operator<=(const scmatrix_slice& M1, const scimatrix_slice& M2) {
9085  return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1.A,M2.A);
9086 }
9087 
9089 inline bool operator<=(const simatrix_slice& M1, const scimatrix_slice& M2) {
9090  return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9091 }
9092 
9094 inline bool operator<=(const scimatrix_slice& M1, const simatrix& M2) {
9095  return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1.A,M2);
9096 }
9097 
9099 inline bool operator<=(const scimatrix_slice& M1, const scimatrix& M2) {
9100  return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1.A,M2);
9101 }
9102 
9104 inline bool operator<=(const srmatrix_slice& M1, const scimatrix& M2) {
9105  return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1.A,M2);
9106 }
9107 
9109 inline bool operator<=(const scmatrix_slice& M1, const scimatrix& M2) {
9110  return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1.A,M2);
9111 }
9112 
9114 inline bool operator<=(const simatrix_slice& M1, const scimatrix& M2) {
9115  return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1.A,M2);
9116 }
9117 
9119 inline bool operator<=(const scimatrix& M1, const simatrix_slice& M2) {
9120  return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1,M2.A);
9121 }
9122 
9124 inline bool operator<=(const scimatrix& M1, const scimatrix_slice& M2) {
9125  return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1,M2.A);
9126 }
9127 
9129 inline bool operator<=(const srmatrix& M1, const scimatrix_slice& M2) {
9130  return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1,M2.A);
9131 }
9132 
9134 inline bool operator<=(const scmatrix& M1, const scimatrix_slice& M2) {
9135  return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1,M2.A);
9136 }
9137 
9139 inline bool operator<=(const simatrix& M1, const scimatrix_slice& M2) {
9140  return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1,M2.A);
9141 }
9142 
9144 inline bool operator<=(const scimatrix_slice& M1, const imatrix& M2) {
9145  return spf_mm_leq<scimatrix,imatrix,cinterval>(M1.A,M2);
9146 }
9147 
9149 inline bool operator<=(const scimatrix_slice& M1, const cimatrix& M2) {
9150  return spf_mm_leq<scimatrix,cimatrix,cinterval>(M1.A,M2);
9151 }
9152 
9154 inline bool operator<=(const srmatrix_slice& M1, const cimatrix& M2) {
9155  return spf_mm_leq<srmatrix,cimatrix,cinterval>(M1.A,M2);
9156 }
9157 
9159 inline bool operator<=(const scmatrix_slice& M1, const cimatrix& M2) {
9160  return spf_mm_leq<scmatrix,cimatrix,cinterval>(M1.A,M2);
9161 }
9162 
9164 inline bool operator<=(const simatrix_slice& M1, const cimatrix& M2) {
9165  return spf_mm_leq<simatrix,cimatrix,cinterval>(M1.A,M2);
9166 }
9167 
9169 inline bool operator<=(const cimatrix& M1, const simatrix_slice& M2) {
9170  return fsp_mm_leq<cimatrix,simatrix,cinterval>(M1,M2.A);
9171 }
9172 
9174 inline bool operator<=(const cimatrix& M1, const scimatrix_slice& M2) {
9175  return fsp_mm_leq<cimatrix,scimatrix,cinterval>(M1,M2.A);
9176 }
9177 
9179 inline bool operator<=(const rmatrix& M1, const scimatrix_slice& M2) {
9180  return fsp_mm_leq<rmatrix,scimatrix,cinterval>(M1,M2.A);
9181 }
9182 
9184 inline bool operator<=(const imatrix& M1, const scimatrix_slice& M2) {
9185  return fsp_mm_leq<imatrix,scimatrix,cinterval>(M1,M2.A);
9186 }
9187 
9189 inline bool operator<=(const cmatrix& M1, const scimatrix_slice& M2) {
9190  return fsp_mm_leq<cmatrix,scimatrix,cinterval>(M1,M2.A);
9191 }
9192 
9194 inline bool operator<=(const cimatrix_slice& M1, const simatrix_slice& M2) {
9195  return fsp_mm_leq<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9196 }
9197 
9199 inline bool operator<=(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9200  return fsp_mm_leq<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9201 }
9202 
9204 inline bool operator<=(const rmatrix_slice& M1, const scimatrix_slice& M2) {
9205  return fsp_mm_leq<rmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9206 }
9207 
9209 inline bool operator<=(const imatrix_slice& M1, const scimatrix_slice& M2) {
9210  return fsp_mm_leq<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9211 }
9212 
9214 inline bool operator<=(const cmatrix_slice& M1, const scimatrix_slice& M2) {
9215  return fsp_mm_leq<cmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9216 }
9217 
9219 inline bool operator<=(const scimatrix_slice& M1, const imatrix_slice& M2) {
9220  return spf_mm_leq<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9221 }
9222 
9224 inline bool operator<=(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9225  return spf_mm_leq<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9226 }
9227 
9229 inline bool operator<=(const srmatrix_slice& M1, const cimatrix_slice& M2) {
9230  return spf_mm_leq<srmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9231 }
9232 
9234 inline bool operator<=(const simatrix_slice& M1, const cimatrix_slice& M2) {
9235  return spf_mm_leq<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9236 }
9237 
9239 inline bool operator<=(const scmatrix_slice& M1, const cimatrix_slice& M2) {
9240  return spf_mm_leq<scmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9241 }
9242 
9244 inline bool operator>(const scimatrix_slice& M1, const srmatrix_slice& M2) {
9245  return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1.A,M2.A);
9246 }
9247 
9249 inline bool operator>(const scimatrix_slice& M1, const scmatrix_slice& M2) {
9250  return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1.A,M2.A);
9251 }
9252 
9254 inline bool operator>(const scimatrix_slice& M1, const simatrix_slice& M2) {
9255  return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9256 }
9257 
9259 inline bool operator>(const scimatrix_slice& M1, const scimatrix_slice& M2) {
9260  return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9261 }
9262 
9264 inline bool operator>(const simatrix_slice& M1, const scimatrix_slice& M2) {
9265  return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9266 }
9267 
9269 inline bool operator>(const scimatrix_slice& M1, const srmatrix& M2) {
9270  return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1.A,M2);
9271 }
9272 
9274 inline bool operator>(const scimatrix_slice& M1, const scmatrix& M2) {
9275  return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1.A,M2);
9276 }
9277 
9279 inline bool operator>(const scimatrix_slice& M1, const simatrix& M2) {
9280  return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1.A,M2);
9281 }
9282 
9284 inline bool operator>(const scimatrix_slice& M1, const scimatrix& M2) {
9285  return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1.A,M2);
9286 }
9287 
9289 inline bool operator>(const simatrix_slice& M1, const scimatrix& M2) {
9290  return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1.A,M2);
9291 }
9292 
9294 inline bool operator>(const scimatrix& M1, const srmatrix_slice& M2) {
9295  return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1,M2.A);
9296 }
9297 
9299 inline bool operator>(const scimatrix& M1, const scmatrix_slice& M2) {
9300  return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1,M2.A);
9301 }
9302 
9304 inline bool operator>(const scimatrix& M1, const simatrix_slice& M2) {
9305  return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1,M2.A);
9306 }
9307 
9309 inline bool operator>(const scimatrix& M1, const scimatrix_slice& M2) {
9310  return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1,M2.A);
9311 }
9312 
9314 inline bool operator>(const simatrix& M1, const scimatrix_slice& M2) {
9315  return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1,M2.A);
9316 }
9317 
9319 inline bool operator>(const scimatrix_slice& M1, const rmatrix& M2) {
9320  return spf_mm_greater<scimatrix,rmatrix,cinterval>(M1.A,M2);
9321 }
9322 
9324 inline bool operator>(const scimatrix_slice& M1, const cmatrix& M2) {
9325  return spf_mm_greater<scimatrix,cmatrix,cinterval>(M1.A,M2);
9326 }
9327 
9329 inline bool operator>(const scimatrix_slice& M1, const imatrix& M2) {
9330  return spf_mm_greater<scimatrix,imatrix,cinterval>(M1.A,M2);
9331 }
9332 
9334 inline bool operator>(const scimatrix_slice& M1, const cimatrix& M2) {
9335  return spf_mm_greater<scimatrix,cimatrix,cinterval>(M1.A,M2);
9336 }
9337 
9339 inline bool operator>(const simatrix_slice& M1, const cimatrix& M2) {
9340  return spf_mm_greater<simatrix,cimatrix,cinterval>(M1.A,M2);
9341 }
9342 
9344 inline bool operator>(const cimatrix& M1, const srmatrix_slice& M2) {
9345  return fsp_mm_greater<cimatrix,srmatrix,cinterval>(M1,M2.A);
9346 }
9347 
9349 inline bool operator>(const cimatrix& M1, const simatrix_slice& M2) {
9350  return fsp_mm_greater<cimatrix,simatrix,cinterval>(M1,M2.A);
9351 }
9352 
9354 inline bool operator>(const cimatrix& M1, const scmatrix_slice& M2) {
9355  return fsp_mm_greater<cimatrix,scmatrix,cinterval>(M1,M2.A);
9356 }
9357 
9359 inline bool operator>(const cimatrix& M1, const scimatrix_slice& M2) {
9360  return fsp_mm_greater<cimatrix,scimatrix,cinterval>(M1,M2.A);
9361 }
9362 
9364 inline bool operator>(const imatrix& M1, const scimatrix_slice& M2) {
9365  return fsp_mm_greater<imatrix,scimatrix,cinterval>(M1,M2.A);
9366 }
9367 
9369 inline bool operator>(const cimatrix_slice& M1, const srmatrix_slice& M2) {
9370  return fsp_mm_greater<cimatrix_slice,srmatrix,cinterval>(M1,M2.A);
9371 }
9372 
9374 inline bool operator>(const cimatrix_slice& M1, const simatrix_slice& M2) {
9375  return fsp_mm_greater<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9376 }
9377 
9379 inline bool operator>(const cimatrix_slice& M1, const scmatrix_slice& M2) {
9380  return fsp_mm_greater<cimatrix_slice,scmatrix,cinterval>(M1,M2.A);
9381 }
9382 
9384 inline bool operator>(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9385  return fsp_mm_greater<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9386 }
9387 
9389 inline bool operator>(const imatrix_slice& M1, const scimatrix_slice& M2) {
9390  return fsp_mm_greater<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9391 }
9392 
9394 inline bool operator>(const scimatrix_slice& M1, const rmatrix_slice& M2) {
9395  return spf_mm_greater<scimatrix,rmatrix_slice,cinterval>(M1.A,M2);
9396 }
9397 
9399 inline bool operator>(const scimatrix_slice& M1, const cmatrix_slice& M2) {
9400  return spf_mm_greater<scimatrix,cmatrix_slice,cinterval>(M1.A,M2);
9401 }
9402 
9404 inline bool operator>(const scimatrix_slice& M1, const imatrix_slice& M2) {
9405  return spf_mm_greater<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9406 }
9407 
9409 inline bool operator>(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9410  return spf_mm_greater<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9411 }
9412 
9414 inline bool operator>(const simatrix_slice& M1, const cimatrix_slice& M2) {
9415  return spf_mm_greater<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9416 }
9417 
9419 inline bool operator>=(const scimatrix_slice& M1, const srmatrix_slice& M2) {
9420  return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1.A,M2.A);
9421 }
9422 
9424 inline bool operator>=(const scimatrix_slice& M1, const scmatrix_slice& M2) {
9425  return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1.A,M2.A);
9426 }
9427 
9429 inline bool operator>=(const scimatrix_slice& M1, const simatrix_slice& M2) {
9430  return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9431 }
9432 
9434 inline bool operator>=(const scimatrix_slice& M1, const scimatrix_slice& M2) {
9435  return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9436 }
9437 
9439 inline bool operator>=(const simatrix_slice& M1, const scimatrix_slice& M2) {
9440  return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9441 }
9442 
9444 inline bool operator>=(const scimatrix_slice& M1, const srmatrix& M2) {
9445  return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1.A,M2);
9446 }
9447 
9449 inline bool operator>=(const scimatrix_slice& M1, const scmatrix& M2) {
9450  return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1.A,M2);
9451 }
9452 
9454 inline bool operator>=(const scimatrix_slice& M1, const simatrix& M2) {
9455  return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1.A,M2);
9456 }
9457 
9459 inline bool operator>=(const scimatrix_slice& M1, const scimatrix& M2) {
9460  return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1.A,M2);
9461 }
9462 
9464 inline bool operator>=(const simatrix_slice& M1, const scimatrix& M2) {
9465  return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1.A,M2);
9466 }
9467 
9469 inline bool operator>=(const scimatrix& M1, const srmatrix_slice& M2) {
9470  return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1,M2.A);
9471 }
9472 
9474 inline bool operator>=(const scimatrix& M1, const scmatrix_slice& M2) {
9475  return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1,M2.A);
9476 }
9477 
9479 inline bool operator>=(const scimatrix& M1, const simatrix_slice& M2) {
9480  return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1,M2.A);
9481 }
9482 
9484 inline bool operator>=(const scimatrix& M1, const scimatrix_slice& M2) {
9485  return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1,M2.A);
9486 }
9487 
9489 inline bool operator>=(const simatrix& M1, const scimatrix_slice& M2) {
9490  return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1,M2.A);
9491 }
9492 
9494 inline bool operator>=(const scimatrix_slice& M1, const rmatrix& M2) {
9495  return spf_mm_geq<scimatrix,rmatrix,cinterval>(M1.A,M2);
9496 }
9497 
9499 inline bool operator>=(const scimatrix_slice& M1, const cmatrix& M2) {
9500  return spf_mm_geq<scimatrix,cmatrix,cinterval>(M1.A,M2);
9501 }
9502 
9504 inline bool operator>=(const scimatrix_slice& M1, const imatrix& M2) {
9505  return spf_mm_geq<scimatrix,imatrix,cinterval>(M1.A,M2);
9506 }
9507 
9509 inline bool operator>=(const scimatrix_slice& M1, const cimatrix& M2) {
9510  return spf_mm_geq<scimatrix,cimatrix,cinterval>(M1.A,M2);
9511 }
9512 
9514 inline bool operator>=(const simatrix_slice& M1, const cimatrix& M2) {
9515  return spf_mm_geq<simatrix,cimatrix,cinterval>(M1.A,M2);
9516 }
9517 
9519 inline bool operator>=(const cimatrix& M1, const srmatrix_slice& M2) {
9520  return fsp_mm_geq<cimatrix,srmatrix,cinterval>(M1,M2.A);
9521 }
9522 
9524 inline bool operator>=(const cimatrix& M1, const simatrix_slice& M2) {
9525  return fsp_mm_geq<cimatrix,simatrix,cinterval>(M1,M2.A);
9526 }
9527 
9529 inline bool operator>=(const cimatrix& M1, const scmatrix_slice& M2) {
9530  return fsp_mm_geq<cimatrix,scmatrix,cinterval>(M1,M2.A);
9531 }
9532 
9534 inline bool operator>=(const cimatrix& M1, const scimatrix_slice& M2) {
9535  return fsp_mm_geq<cimatrix,scimatrix,cinterval>(M1,M2.A);
9536 }
9537 
9539 inline bool operator>=(const imatrix& M1, const scimatrix_slice& M2) {
9540  return fsp_mm_geq<imatrix,scimatrix,cinterval>(M1,M2.A);
9541 }
9542 
9544 inline bool operator>=(const cimatrix_slice& M1, const srmatrix_slice& M2) {
9545  return fsp_mm_geq<cimatrix_slice,srmatrix,cinterval>(M1,M2.A);
9546 }
9547 
9549 inline bool operator>=(const cimatrix_slice& M1, const simatrix_slice& M2) {
9550  return fsp_mm_geq<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9551 }
9552 
9554 inline bool operator>=(const cimatrix_slice& M1, const scmatrix_slice& M2) {
9555  return fsp_mm_geq<cimatrix_slice,scmatrix,cinterval>(M1,M2.A);
9556 }
9557 
9559 inline bool operator>=(const cimatrix_slice& M1, const scimatrix_slice& M2) {
9560  return fsp_mm_geq<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9561 }
9562 
9564 inline bool operator>=(const imatrix_slice& M1, const scimatrix_slice& M2) {
9565  return fsp_mm_geq<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9566 }
9567 
9569 inline bool operator>=(const scimatrix_slice& M1, const rmatrix_slice& M2) {
9570  return spf_mm_geq<scimatrix,rmatrix_slice,cinterval>(M1.A,M2);
9571 }
9572 
9574 inline bool operator>=(const scimatrix_slice& M1, const cmatrix_slice& M2) {
9575  return spf_mm_geq<scimatrix,cmatrix_slice,cinterval>(M1.A,M2);
9576 }
9577 
9579 inline bool operator>=(const scimatrix_slice& M1, const imatrix_slice& M2) {
9580  return spf_mm_geq<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9581 }
9582 
9584 inline bool operator>=(const scimatrix_slice& M1, const cimatrix_slice& M2) {
9585  return spf_mm_geq<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9586 }
9587 
9589 inline bool operator>=(const simatrix_slice& M1, const cimatrix_slice& M2) {
9590  return spf_mm_geq<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9591 }
9592 
9594 inline bool operator!(const scimatrix_slice& M) {
9595  return sp_m_not(M.A);
9596 }
9597 
9599 
9604 inline std::ostream& operator<<(std::ostream& os, const scimatrix_slice& M) {
9605  return sp_m_output<scimatrix,cinterval>(os, M.A);
9606 }
9607 
9609 
9614 inline 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 
9805  scimatrix_subv& operator*=(const real&);
9813  scimatrix_subv& operator/=(const real&);
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 
9950 inline 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 
9958 inline 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 
9966 inline int VecLen(const scimatrix_subv& S) {
9967  return Ub(S)-Lb(S)+1;
9968 }
9969 
9971 inline sivector Re(const scimatrix_subv& S) {
9972  return Re(scivector(S));
9973 }
9974 
9976 inline sivector Im(const scimatrix_subv& S) {
9977  return Im(scivector(S));
9978 }
9979 
9981 inline scivector conj(const scimatrix_subv& S) {
9982  return conj(scivector(S));
9983 }
9984 
9986 inline sivector abs(const scimatrix_subv& S) {
9987  return abs(scivector(S));
9988 }
9989 
9991 inline scvector mid(const scimatrix_subv& S) {
9992  return mid(scivector(S));
9993 }
9994 
9996 inline scvector diam(const scimatrix_subv& S) {
9997  return diam(scivector(S));
9998 }
9999 
10001 inline scvector Inf(const scimatrix_subv& S) {
10002  return Inf(scivector(S));
10003 }
10004 
10006 inline scvector Sup(const scimatrix_subv& S) {
10007  return Sup(scivector(S));
10008 }
10009 
10011 inline srvector InfRe(const scimatrix_subv& S) {
10012  return InfRe(scivector(S));
10013 }
10014 
10016 inline srvector InfIm(const scimatrix_subv& S) {
10017  return InfIm(scivector(S));
10018 }
10019 
10021 inline srvector SupRe(const scimatrix_subv& S) {
10022  return SupRe(scivector(S));
10023 }
10024 
10026 inline srvector SupIm(const scimatrix_subv& S) {
10027  return SupIm(scivector(S));
10028 }
10029 
10031 inline std::ostream& operator<<(std::ostream& os, const scimatrix_subv& v) {
10032  os << scivector(v);
10033  return os;
10034 }
10035 
10037 inline 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 
10046 inline 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 
10062 inline 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 
10070 inline 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 
10086 inline 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 
10094 inline 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 
10102 inline 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 
10227 inline scivector operator-(const scimatrix_subv& v) {
10228  scivector s(v);
10229  return -s;
10230 }
10231 
10233 inline scivector operator/(const scimatrix_subv& v1, const real& v2) {
10234  return scivector(v1) / v2;
10235 }
10236 
10238 inline scivector operator/(const scimatrix_subv& v1, const complex& v2) {
10239  return scivector(v1) / v2;
10240 }
10241 
10243 inline scivector operator/(const scimatrix_subv& v1, const interval& v2) {
10244  return scivector(v1) / v2;
10245 }
10246 
10248 inline scivector operator/(const scimatrix_subv& v1, const cinterval& v2) {
10249  return scivector(v1) / v2;
10250 }
10251 
10253 inline scivector operator/(const srmatrix_subv& v1, const cinterval& v2) {
10254  return srvector(v1) / v2;
10255 }
10256 
10258 inline scivector operator/(const scmatrix_subv& v1, const cinterval& v2) {
10259  return scvector(v1) / v2;
10260 }
10261 
10263 inline scivector operator/(const simatrix_subv& v1, const cinterval& v2) {
10264  return sivector(v1) / v2;
10265 }
10266 
10268 inline scivector operator/(const simatrix_subv& v1, const complex& v2) {
10269  return sivector(v1) / v2;
10270 }
10271 
10273 inline scivector operator/(const scmatrix_subv& v1, const interval& v2) {
10274  return scvector(v1) / v2;
10275 }
10276 
10278 inline scivector operator*(const scimatrix_subv& v1, const real& v2) {
10279  return scivector(v1) * v2;
10280 }
10281 
10283 inline scivector operator*(const scimatrix_subv& v1, const complex& v2) {
10284  return scivector(v1) * v2;
10285 }
10286 
10288 inline scivector operator*(const scimatrix_subv& v1, const interval& v2) {
10289  return scivector(v1) * v2;
10290 }
10291 
10293 inline scivector operator*(const scimatrix_subv& v1, const cinterval& v2) {
10294  return scivector(v1) * v2;
10295 }
10296 
10298 inline scivector operator*(const srmatrix_subv& v1, const cinterval& v2) {
10299  return srvector(v1) * v2;
10300 }
10301 
10303 inline scivector operator*(const scmatrix_subv& v1, const cinterval& v2) {
10304  return scvector(v1) * v2;
10305 }
10306 
10308 inline scivector operator*(const simatrix_subv& v1, const cinterval& v2) {
10309  return sivector(v1) * v2;
10310 }
10311 
10313 inline scivector operator*(const simatrix_subv& v1, const complex& v2) {
10314  return sivector(v1) * v2;
10315 }
10316 
10318 inline scivector operator*(const scmatrix_subv& v1, const interval& v2) {
10319  return scvector(v1) * v2;
10320 }
10321 
10323 inline scivector operator*(const real& v1, const scimatrix_subv& v2) {
10324  return v1 * scivector(v2);
10325 }
10326 
10328 inline scivector operator*(const complex& v1, const scimatrix_subv& v2) {
10329  return v1 * scivector(v2);
10330 }
10331 
10333 inline scivector operator*(const interval& v1, const scimatrix_subv& v2) {
10334  return v1 * scivector(v2);
10335 }
10336 
10338 inline scivector operator*(const cinterval& v1, const scimatrix_subv& v2) {
10339  return v1 * scivector(v2);
10340 }
10341 
10343 inline scivector operator*(const cinterval& v1, const srmatrix_subv& v2) {
10344  return v1 * srvector(v2);
10345 }
10346 
10348 inline scivector operator*(const cinterval& v1, const scmatrix_subv& v2) {
10349  return v1 * scvector(v2);
10350 }
10351 
10353 inline scivector operator*(const cinterval& v1, const simatrix_subv& v2) {
10354  return v1 * sivector(v2);
10355 }
10356 
10358 inline scivector operator*(const complex& v1, const simatrix_subv& v2) {
10359  return v1 * sivector(v2);
10360 }
10361 
10363 inline scivector operator*(const interval& v1, const scmatrix_subv& v2) {
10364  return v1 * scvector(v2);
10365 }
10366 
10368 
10374 inline cinterval operator*(const scimatrix_subv& v1, const srvector& v2) {
10375  return scivector(v1) * v2;
10376 }
10377 
10379 
10385 inline cinterval operator*(const scimatrix_subv& v1, const scvector& v2) {
10386  return scivector(v1) * v2;
10387 }
10388 
10390 
10396 inline cinterval operator*(const scimatrix_subv& v1, const sivector& v2) {
10397  return scivector(v1) * v2;
10398 }
10399 
10401 
10407 inline cinterval operator*(const scimatrix_subv& v1, const scivector& v2) {
10408  return scivector(v1) * v2;
10409 }
10410 
10412 
10418 inline cinterval operator*(const srmatrix_subv& v1, const scivector& v2) {
10419  return srvector(v1) * v2;
10420 }
10421 
10423 
10429 inline cinterval operator*(const scmatrix_subv& v1, const scivector& v2) {
10430  return scvector(v1) * v2;
10431 }
10432 
10434 
10440 inline cinterval operator*(const simatrix_subv& v1, const scivector& v2) {
10441  return sivector(v1) * v2;
10442 }
10443 
10445 
10451 inline cinterval operator*(const scmatrix_subv& v1, const sivector& v2) {
10452  return scvector(v1) * v2;
10453 }
10454 
10456 
10462 inline cinterval operator*(const simatrix_subv& v1, const scvector& v2) {
10463  return sivector(v1) * v2;
10464 }
10465 
10467 
10473 inline cinterval operator*(const scimatrix_subv& v1, const srvector_slice& v2) {
10474  return scivector(v1) * v2;
10475 }
10476 
10478 
10484 inline cinterval operator*(const scimatrix_subv& v1, const scvector_slice& v2) {
10485  return scivector(v1) * v2;
10486 }
10487 
10489 
10495 inline cinterval operator*(const scimatrix_subv& v1, const sivector_slice& v2) {
10496  return scivector(v1) * v2;
10497 }
10498 
10500 
10506 inline cinterval operator*(const scimatrix_subv& v1, const scivector_slice& v2) {
10507  return scivector(v1) * v2;
10508 }
10509 
10511 
10517 inline cinterval operator*(const srmatrix_subv& v1, const scivector_slice& v2) {
10518  return srvector(v1) * v2;
10519 }
10520 
10522 
10528 inline cinterval operator*(const scmatrix_subv& v1, const scivector_slice& v2) {
10529  return scvector(v1) * v2;
10530 }
10531 
10533 
10539 inline cinterval operator*(const simatrix_subv& v1, const scivector_slice& v2) {
10540  return sivector(v1) * v2;
10541 }
10542 
10544 
10550 inline cinterval operator*(const scmatrix_subv& v1, const sivector_slice& v2) {
10551  return scvector(v1) * v2;
10552 }
10553 
10555 
10561 inline cinterval operator*(const simatrix_subv& v1, const scvector_slice& v2) {
10562  return sivector(v1) * v2;
10563 }
10564 
10566 
10572 inline cinterval operator*(const scimatrix_subv& v1, const rvector& v2) {
10573  return scivector(v1) * v2;
10574 }
10575 
10577 
10583 inline cinterval operator*(const scimatrix_subv& v1, const ivector& v2) {
10584  return scivector(v1) * v2;
10585 }
10586 
10588 
10594 inline cinterval operator*(const scimatrix_subv& v1, const cvector& v2) {
10595  return scivector(v1) * v2;
10596 }
10597 
10599 
10605 inline cinterval operator*(const scimatrix_subv& v1, const civector& v2) {
10606  return scivector(v1) * v2;
10607 }
10608 
10610 
10616 inline cinterval operator*(const srmatrix_subv& v1, const civector& v2) {
10617  return srvector(v1) * v2;
10618 }
10619 
10621 
10627 inline cinterval operator*(const simatrix_subv& v1, const civector& v2) {
10628  return sivector(v1) * v2;
10629 }
10630 
10632 
10638 inline cinterval operator*(const scmatrix_subv& v1, const civector& v2) {
10639  return scvector(v1) * v2;
10640 }
10641 
10643 
10649 inline cinterval operator*(const scmatrix_subv& v1, const ivector& v2) {
10650  return scvector(v1) * v2;
10651 }
10652 
10654 
10660 inline cinterval operator*(const simatrix_subv& v1, const cvector& v2) {
10661  return sivector(v1) * v2;
10662 }
10663 
10665 
10671 inline cinterval operator*(const scimatrix_subv& v1, const rvector_slice& v2) {
10672  return scivector(v1) * v2;
10673 }
10674 
10676 
10682 inline cinterval operator*(const scimatrix_subv& v1, const ivector_slice& v2) {
10683  return scivector(v1) * v2;
10684 }
10685 
10687 
10693 inline cinterval operator*(const scimatrix_subv& v1, const cvector_slice& v2) {
10694  return scivector(v1) * v2;
10695 }
10696 
10698 
10704 inline cinterval operator*(const scimatrix_subv& v1, const civector_slice& v2) {
10705  return scivector(v1) * v2;
10706 }
10707 
10709 
10715 inline cinterval operator*(const srmatrix_subv& v1, const civector_slice& v2) {
10716  return srvector(v1) * v2;
10717 }
10718 
10720 
10726 inline cinterval operator*(const scmatrix_subv& v1, const civector_slice& v2) {
10727  return scvector(v1) * v2;
10728 }
10729 
10731 
10737 inline cinterval operator*(const simatrix_subv& v1, const civector_slice& v2) {
10738  return sivector(v1) * v2;
10739 }
10740 
10742 
10748 inline cinterval operator*(const scmatrix_subv& v1, const ivector_slice& v2) {
10749  return scvector(v1) * v2;
10750 }
10751 
10753 
10759 inline cinterval operator*(const simatrix_subv& v1, const cvector_slice& v2) {
10760  return sivector(v1) * v2;
10761 }
10762 
10764 
10770 inline cinterval operator*(const scivector& v1, const srmatrix_subv& v2) {
10771  return v1 * srvector(v2);
10772 }
10773 
10775 
10781 inline cinterval operator*(const scivector& v1, const scmatrix_subv& v2) {
10782  return v1 * scvector(v2);
10783 }
10784 
10786 
10792 inline cinterval operator*(const scivector& v1, const simatrix_subv& v2) {
10793  return v1 * sivector(v2);
10794 }
10795 
10797 
10803 inline cinterval operator*(const scivector& v1, const scimatrix_subv& v2) {
10804  return v1 * scivector(v2);
10805 }
10806 
10808 
10814 inline cinterval operator*(const srvector& v1, const scimatrix_subv& v2) {
10815  return v1 * scivector(v2);
10816 }
10817 
10819 
10825 inline cinterval operator*(const scvector& v1, const scimatrix_subv& v2) {
10826  return v1 * scivector(v2);
10827 }
10828 
10830 
10836 inline cinterval operator*(const sivector& v1, const scimatrix_subv& v2) {
10837  return v1 * scivector(v2);
10838 }
10839 
10841 
10847 inline cinterval operator*(const scvector& v1, const simatrix_subv& v2) {
10848  return v1 * sivector(v2);
10849 }
10850 
10852 
10858 inline cinterval operator*(const sivector& v1, const scmatrix_subv& v2) {
10859  return v1 * scvector(v2);
10860 }
10861 
10863 
10869 inline cinterval operator*(const scivector_slice& v1, const srmatrix_subv& v2) {
10870  return v1 * srvector(v2);
10871 }
10872 
10874 
10880 inline cinterval operator*(const scivector_slice& v1, const scmatrix_subv& v2) {
10881  return v1 * scvector(v2);
10882 }
10883 
10885 
10891 inline cinterval operator*(const scivector_slice& v1, const simatrix_subv& v2) {
10892  return v1 * sivector(v2);
10893 }
10894 
10896 
10902 inline cinterval operator*(const scivector_slice& v1, const scimatrix_subv& v2) {
10903  return v1 * scivector(v2);
10904 }
10905 
10907 
10913 inline cinterval operator*(const srvector_slice& v1, const scimatrix_subv& v2) {
10914  return v1 * scivector(v2);
10915 }
10916 
10918 
10924 inline cinterval operator*(const sivector_slice& v1, const scimatrix_subv& v2) {
10925  return v1 * scivector(v2);
10926 }
10927 
10929 
10935 inline cinterval operator*(const scvector_slice& v1, const scimatrix_subv& v2) {
10936  return v1 * scivector(v2);
10937 }
10938 
10940 
10946 inline cinterval operator*(const scvector_slice& v1, const simatrix_subv& v2) {
10947  return v1 * sivector(v2);
10948 }
10949 
10951 
10957 inline cinterval operator*(const sivector_slice& v1, const scmatrix_subv& v2) {
10958  return v1 * scvector(v2);
10959 }
10960 
10962 
10968 inline cinterval operator*(const civector& v1, const srmatrix_subv& v2) {
10969  return v1 * srvector(v2);
10970 }
10971 
10973 
10979 inline cinterval operator*(const civector& v1, const scmatrix_subv& v2) {
10980  return v1 * scvector(v2);
10981 }
10982 
10984 
10990 inline cinterval operator*(const civector& v1, const simatrix_subv& v2) {
10991  return v1 * sivector(v2);
10992 }
10993 
10995 
11001 inline cinterval operator*(const civector& v1, const scimatrix_subv& v2) {
11002  return v1 * scivector(v2);
11003 }
11004 
11006 
11012 inline cinterval operator*(const rvector& v1, const scimatrix_subv& v2) {
11013  return v1 * scivector(v2);
11014 }
11015 
11017 
11023 inline cinterval operator*(const cvector& v1, const scimatrix_subv& v2) {
11024  return v1 * scivector(v2);
11025 }
11026 
11028 
11034 inline cinterval operator*(const ivector& v1, const scimatrix_subv& v2) {
11035  return v1 * scivector(v2);
11036 }
11037 
11039 
11045 inline cinterval operator*(const ivector& v1, const scmatrix_subv& v2) {
11046  return v1 * scvector(v2);
11047 }
11048 
11050 
11056 inline cinterval operator*(const cvector& v1, const simatrix_subv& v2) {
11057  return v1 * sivector(v2);
11058 }
11059 
11061 
11067 inline cinterval operator*(const civector_slice& v1, const srmatrix_subv& v2) {
11068  return v1 * srvector(v2);
11069 }
11070 
11072 
11078 inline cinterval operator*(const civector_slice& v1, const scmatrix_subv& v2) {
11079  return v1 * scvector(v2);
11080 }
11081 
11083 
11089 inline cinterval operator*(const civector_slice& v1, const simatrix_subv& v2) {
11090  return v1 * sivector(v2);
11091 }
11092 
11094 
11100 inline cinterval operator*(const civector_slice& v1, const scimatrix_subv& v2) {
11101  return v1 * scivector(v2);
11102 }
11103 
11105 
11111 inline cinterval operator*(const rvector_slice& v1, const scimatrix_subv& v2) {
11112  return v1 * scivector(v2);
11113 }
11114 
11116 
11122 inline cinterval operator*(const cvector_slice& v1, const scimatrix_subv& v2) {
11123  return v1 * scivector(v2);
11124 }
11125 
11127 
11133 inline cinterval operator*(const ivector_slice& v1, const scimatrix_subv& v2) {
11134  return v1 * scivector(v2);
11135 }
11136 
11138 
11144 inline cinterval operator*(const ivector_slice& v1, const scmatrix_subv& v2) {
11145  return v1 * scvector(v2);
11146 }
11147 
11149 
11155 inline cinterval operator*(const cvector_slice& v1, const simatrix_subv& v2) {
11156  return v1 * sivector(v2);
11157 }
11158 
11160 inline scivector operator+(const scimatrix_subv& v1, const srvector& v2) {
11161  return scivector(v1) + v2;
11162 }
11163 
11165 inline scivector operator+(const scimatrix_subv& v1, const scvector& v2) {
11166  return scivector(v1) + v2;
11167 }
11168 
11170 inline scivector operator+(const scimatrix_subv& v1, const sivector& v2) {
11171  return scivector(v1) + v2;
11172 }
11173 
11175 inline scivector operator+(const scimatrix_subv& v1, const scivector& v2) {
11176  return scivector(v1) + v2;
11177 }
11178 
11180 inline scivector operator+(const srmatrix_subv& v1, const scivector& v2) {
11181  return srvector(v1) + v2;
11182 }
11183 
11185 inline scivector operator+(const scmatrix_subv& v1, const scivector& v2) {
11186  return scvector(v1) + v2;
11187 }
11188 
11190 inline scivector operator+(const simatrix_subv& v1, const scivector& v2) {
11191  return sivector(v1) + v2;
11192 }
11193 
11195 inline scivector operator+(const scmatrix_subv& v1, const sivector& v2) {
11196  return scvector(v1) + v2;
11197 }
11198 
11200 inline scivector operator+(const simatrix_subv& v1, const scvector& v2) {
11201  return sivector(v1) + v2;
11202 }
11203 
11205 inline scivector operator+(const scimatrix_subv& v1, const srvector_slice& v2) {
11206  return scivector(v1) + v2;
11207 }
11208 
11210 inline scivector operator+(const scimatrix_subv& v1, const scvector_slice& v2) {
11211  return scivector(v1) + v2;
11212 }
11213 
11215 inline scivector operator+(const scimatrix_subv& v1, const sivector_slice& v2) {
11216  return scivector(v1) + v2;
11217 }
11218 
11220 inline scivector operator+(const scimatrix_subv& v1, const scivector_slice& v2) {
11221  return scivector(v1) + v2;
11222 }
11223 
11225 inline scivector operator+(const srmatrix_subv& v1, const scivector_slice& v2) {
11226  return srvector(v1) + v2;
11227 }
11228 
11230 inline scivector operator+(const scmatrix_subv& v1, const scivector_slice& v2) {
11231  return scvector(v1) + v2;
11232 }
11233 
11235 inline scivector operator+(const simatrix_subv& v1, const scivector_slice& v2) {
11236  return sivector(v1) + v2;
11237 }
11238 
11240 inline scivector operator+(const simatrix_subv& v1, const scvector_slice& v2) {
11241  return sivector(v1) + v2;
11242 }
11243 
11245 inline scivector operator+(const scmatrix_subv& v1, const sivector_slice& v2) {
11246  return scvector(v1) + v2;
11247 }
11248 
11250 inline civector operator+(const scimatrix_subv& v1, const rvector& v2) {
11251  return scivector(v1) + v2;
11252 }
11253 
11255 inline civector operator+(const scimatrix_subv& v1, const cvector& v2) {
11256  return scivector(v1) + v2;
11257 }
11258 
11260 inline civector operator+(const scimatrix_subv& v1, const ivector& v2) {
11261  return scivector(v1) + v2;
11262 }
11263 
11265 inline civector operator+(const scimatrix_subv& v1, const civector& v2) {
11266  return scivector(v1) + v2;
11267 }
11268 
11270 inline civector operator+(const srmatrix_subv& v1, const civector& v2) {
11271  return srvector(v1) + v2;
11272 }
11273 
11275 inline civector operator+(const simatrix_subv& v1, const civector& v2) {
11276  return sivector(v1) + v2;
11277 }
11278 
11280 inline civector operator+(const scmatrix_subv& v1, const civector& v2) {
11281  return scvector(v1) + v2;
11282 }
11283 
11285 inline civector operator+(const scmatrix_subv& v1, const ivector& v2) {
11286  return scvector(v1) + v2;
11287 }
11288 
11290 inline civector operator+(const simatrix_subv& v1, const cvector& v2) {
11291  return sivector(v1) + v2;
11292 }
11293 
11295 inline civector operator+(const scimatrix_subv& v1, const rvector_slice& v2) {
11296  return scivector(v1) + v2;
11297 }
11298 
11300 inline civector operator+(const scimatrix_subv& v1, const cvector_slice& v2) {
11301  return scivector(v1) + v2;
11302 }
11303 
11305 inline civector operator+(const scimatrix_subv& v1, const ivector_slice& v2) {
11306  return scivector(v1) + v2;
11307 }
11308 
11310 inline civector operator+(const scimatrix_subv& v1, const civector_slice& v2) {
11311  return scivector(v1) + v2;
11312 }
11313 
11315 inline civector operator+(const srmatrix_subv& v1, const civector_slice& v2) {
11316  return srvector(v1) + v2;
11317 }
11318 
11320 inline civector operator+(const scmatrix_subv& v1, const civector_slice& v2) {
11321  return scvector(v1) + v2;
11322 }
11323 
11325 inline civector operator+(const simatrix_subv& v1, const civector_slice& v2) {
11326  return sivector(v1) + v2;
11327 }
11328 
11330 inline civector operator+(const simatrix_subv& v1, const cvector_slice& v2) {
11331  return sivector(v1) + v2;
11332 }
11333 
11335 inline civector operator+(const scmatrix_subv& v1, const ivector_slice& v2) {
11336  return scvector(v1) + v2;
11337 }
11338 
11340 inline scivector operator+(const scivector& v1, const srmatrix_subv& v2) {
11341  return v1 + srvector(v2);
11342 }
11343 
11345 inline scivector operator+(const scivector& v1, const scmatrix_subv& v2) {
11346  return v1 + scvector(v2);
11347 }
11348 
11350 inline scivector operator+(const scivector& v1, const simatrix_subv& v2) {
11351  return v1 + sivector(v2);
11352 }
11353 
11355 inline scivector operator+(const scivector& v1, const scimatrix_subv& v2) {
11356  return v1 + scivector(v2);
11357 }
11358 
11360 inline scivector operator+(const srvector& v1, const scimatrix_subv& v2) {
11361  return v1 + scivector(v2);
11362 }
11363 
11365 inline scivector operator+(const scvector& v1, const scimatrix_subv& v2) {
11366  return v1 + scivector(v2);
11367 }
11368 
11370 inline scivector operator+(const sivector& v1, const scimatrix_subv& v2) {
11371  return v1 + scivector(v2);
11372 }
11373 
11375 inline scivector operator+(const sivector& v1, const scmatrix_subv& v2) {
11376  return v1 + scvector(v2);
11377 }
11378 
11380 inline scivector operator+(const scvector& v1, const simatrix_subv& v2) {
11381  return v1 + sivector(v2);
11382 }
11383 
11385 inline scivector operator+(const scivector_slice& v1, const srmatrix_subv& v2) {
11386  return v1 + srvector(v2);
11387 }
11388 
11390 inline scivector operator+(const scivector_slice& v1, const scmatrix_subv& v2) {
11391  return v1 + scvector(v2);
11392 }
11393 
11395 inline scivector operator+(const scivector_slice& v1, const simatrix_subv& v2) {
11396  return v1 + sivector(v2);
11397 }
11398 
11400 inline scivector operator+(const scivector_slice& v1, const scimatrix_subv& v2) {
11401  return v1 + scivector(v2);
11402 }
11403 
11405 inline scivector operator+(const srvector_slice& v1, const scimatrix_subv& v2) {
11406  return v1 + scivector(v2);
11407 }
11408 
11410 inline scivector operator+(const scvector_slice& v1, const scimatrix_subv& v2) {
11411  return v1 + scivector(v2);
11412 }
11413 
11415 inline scivector operator+(const sivector_slice& v1, const scimatrix_subv& v2) {
11416  return v1 + scivector(v2);
11417 }
11418 
11420 inline scivector operator+(const sivector_slice& v1, const scmatrix_subv& v2) {
11421  return v1 + scvector(v2);
11422 }
11423 
11425 inline scivector operator+(const scvector_slice& v1, const simatrix_subv& v2) {
11426  return v1 + sivector(v2);
11427 }
11428 
11430 inline civector operator+(const civector& v1, const srmatrix_subv& v2) {
11431  return v1 + srvector(v2);
11432 }
11433 
11435 inline civector operator+(const civector& v1, const scmatrix_subv& v2) {
11436  return v1 + scvector(v2);
11437 }
11438 
11440 inline civector operator+(const civector& v1, const simatrix_subv& v2) {
11441  return v1 + sivector(v2);
11442 }
11443 
11445 inline civector operator+(const civector& v1, const scimatrix_subv& v2) {
11446  return v1 + scivector(v2);
11447 }
11448 
11450 inline civector operator+(const rvector& v1, const scimatrix_subv& v2) {
11451  return v1 + scivector(v2);
11452 }
11453 
11455 inline civector operator+(const cvector& v1, const scimatrix_subv& v2) {
11456  return v1 + scivector(v2);
11457 }
11458 
11460 inline civector operator+(const ivector& v1, const scimatrix_subv& v2) {
11461  return v1 + scivector(v2);
11462 }
11463 
11465 inline civector operator+(const ivector& v1, const scmatrix_subv& v2) {
11466  return v1 + scvector(v2);
11467 }
11468 
11470 inline civector operator+(const cvector& v1, const simatrix_subv& v2) {
11471  return v1 + sivector(v2);
11472 }
11473 
11475 inline civector operator+(const civector_slice& v1, const srmatrix_subv& v2) {
11476  return v1 + srvector(v2);
11477 }
11478 
11480 inline civector operator+(const civector_slice& v1, const scmatrix_subv& v2) {
11481  return v1 + scvector(v2);
11482 }
11483 
11485 inline civector operator+(const civector_slice& v1, const simatrix_subv& v2) {
11486  return v1 + sivector(v2);
11487 }
11488 
11490 inline civector operator+(const civector_slice& v1, const scimatrix_subv& v2) {
11491  return v1 + scivector(v2);
11492 }
11493 
11495 inline civector operator+(const rvector_slice& v1, const scimatrix_subv& v2) {
11496  return v1 + scivector(v2);
11497 }
11498 
11500 inline civector operator+(const cvector_slice& v1, const scimatrix_subv& v2) {
11501  return v1 + scivector(v2);
11502 }
11503 
11505 inline civector operator+(const ivector_slice& v1, const scimatrix_subv& v2) {
11506  return v1 + scivector(v2);
11507 }
11508 
11510 inline civector operator+(const ivector_slice& v1, const scmatrix_subv& v2) {
11511  return v1 + scvector(v2);
11512 }
11513 
11515 inline civector operator+(const cvector_slice& v1, const simatrix_subv& v2) {
11516  return v1 + sivector(v2);
11517 }
11518 
11520 inline scivector operator-(const scimatrix_subv& v1, const srvector& v2) {
11521  return scivector(v1) - v2;
11522 }
11523 
11525 inline scivector operator-(const scimatrix_subv& v1, const scvector& v2) {
11526  return scivector(v1) - v2;
11527 }
11528 
11530 inline scivector operator-(const scimatrix_subv& v1, const sivector& v2) {
11531  return scivector(v1) - v2;
11532 }
11533 
11535 inline scivector operator-(const scimatrix_subv& v1, const scivector& v2) {
11536  return scivector(v1) - v2;
11537 }
11538 
11540 inline scivector operator-(const srmatrix_subv& v1, const scivector& v2) {
11541  return srvector(v1) - v2;
11542 }
11543 
11545 inline scivector operator-(const scmatrix_subv& v1, const scivector& v2) {
11546  return scvector(v1) - v2;
11547 }
11548 
11550 inline scivector operator-(const simatrix_subv& v1, const scivector& v2) {
11551  return sivector(v1) - v2;
11552 }
11553 
11555 inline scivector operator-(const scmatrix_subv& v1, const sivector& v2) {
11556  return scvector(v1) - v2;
11557 }
11558 
11560 inline scivector operator-(const simatrix_subv& v1, const scvector& v2) {
11561  return sivector(v1) - v2;
11562 }
11563 
11565 inline scivector operator-(const scimatrix_subv& v1, const srvector_slice& v2) {
11566  return scivector(v1) - v2;
11567 }
11568 
11570 inline scivector operator-(const scimatrix_subv& v1, const scvector_slice& v2) {
11571  return scivector(v1) - v2;
11572 }
11573 
11575 inline scivector operator-(const scimatrix_subv& v1, const sivector_slice& v2) {
11576  return scivector(v1) - v2;
11577 }
11578 
11580 inline scivector operator-(const scimatrix_subv& v1, const scivector_slice& v2) {
11581  return scivector(v1) - v2;
11582 }
11583 
11585 inline scivector operator-(const srmatrix_subv& v1, const scivector_slice& v2) {
11586  return srvector(v1) - v2;
11587 }
11588 
11590 inline scivector operator-(const scmatrix_subv& v1, const scivector_slice& v2) {
11591  return scvector(v1) - v2;
11592 }
11593 
11595 inline scivector operator-(const simatrix_subv& v1, const scivector_slice& v2) {
11596  return sivector(v1) - v2;
11597 }
11598 
11600 inline scivector operator-(const simatrix_subv& v1, const scvector_slice& v2) {
11601  return sivector(v1) - v2;
11602 }
11603 
11605 inline scivector operator-(const scmatrix_subv& v1, const sivector_slice& v2) {
11606  return scvector(v1) - v2;
11607 }
11608 
11610 inline civector operator-(const scimatrix_subv& v1, const rvector& v2) {
11611  return scivector(v1) - v2;
11612 }
11613 
11615 inline civector operator-(const scimatrix_subv& v1, const cvector& v2) {
11616  return scivector(v1) - v2;
11617 }
11618 
11620 inline civector operator-(const scimatrix_subv& v1, const ivector& v2) {
11621  return scivector(v1) - v2;
11622 }
11623 
11625 inline civector operator-(const scimatrix_subv& v1, const civector& v2) {
11626  return scivector(v1) - v2;
11627 }
11628 
11630 inline civector operator-(const srmatrix_subv& v1, const civector& v2) {
11631  return srvector(v1) - v2;
11632 }
11633 
11635 inline civector operator-(const simatrix_subv& v1, const civector& v2) {
11636  return sivector(v1) - v2;
11637 }
11638 
11640 inline civector operator-(const scmatrix_subv& v1, const civector& v2) {
11641  return scvector(v1) - v2;
11642 }
11643 
11645 inline civector operator-(const scmatrix_subv& v1, const ivector& v2) {
11646  return scvector(v1) - v2;
11647 }
11648 
11650 inline civector operator-(const simatrix_subv& v1, const cvector& v2) {
11651  return sivector(v1) - v2;
11652 }
11653 
11655 inline civector operator-(const scimatrix_subv& v1, const rvector_slice& v2) {
11656  return scivector(v1) - v2;
11657 }
11658 
11660 inline civector operator-(const scimatrix_subv& v1, const cvector_slice& v2) {
11661  return scivector(v1) - v2;
11662 }
11663 
11665 inline civector operator-(const scimatrix_subv& v1, const ivector_slice& v2) {
11666  return scivector(v1) - v2;
11667 }
11668 
11670 inline civector operator-(const scimatrix_subv& v1, const civector_slice& v2) {
11671  return scivector(v1) - v2;
11672 }
11673 
11675 inline civector operator-(const srmatrix_subv& v1, const civector_slice& v2) {
11676  return srvector(v1) - v2;
11677 }
11678 
11680 inline civector operator-(const scmatrix_subv& v1, const civector_slice& v2) {
11681  return scvector(v1) - v2;
11682 }
11683 
11685 inline civector operator-(const simatrix_subv& v1, const civector_slice& v2) {
11686  return sivector(v1) - v2;
11687 }
11688 
11690 inline civector operator-(const simatrix_subv& v1, const cvector_slice& v2) {
11691  return sivector(v1) - v2;
11692 }
11693 
11695 inline civector operator-(const scmatrix_subv& v1, const ivector_slice& v2) {
11696  return scvector(v1) - v2;
11697 }
11698 
11700 inline scivector operator-(const scivector& v1, const srmatrix_subv& v2) {
11701  return v1 - srvector(v2);
11702 }
11703 
11705 inline scivector operator-(const scivector& v1, const scmatrix_subv& v2) {
11706  return v1 - scvector(v2);
11707 }
11708 
11710 inline scivector operator-(const scivector& v1, const simatrix_subv& v2) {
11711  return v1 - sivector(v2);
11712 }
11713 
11715 inline scivector operator-(const scivector& v1, const scimatrix_subv& v2) {
11716  return v1 - scivector(v2);
11717 }
11718 
11720 inline scivector operator-(const srvector& v1, const scimatrix_subv& v2) {
11721  return v1 - scivector(v2);
11722 }
11723 
11725 inline scivector operator-(const scvector& v1, const scimatrix_subv& v2) {
11726  return v1 - scivector(v2);
11727 }
11728 
11730 inline scivector operator-(const sivector& v1, const scimatrix_subv& v2) {
11731  return v1 - scivector(v2);
11732 }
11733 
11735 inline scivector operator-(const sivector& v1, const scmatrix_subv& v2) {
11736  return v1 - scvector(v2);
11737 }
11738 
11740 inline scivector operator-(const scvector& v1, const simatrix_subv& v2) {
11741  return v1 - sivector(v2);
11742 }
11743 
11745 inline scivector operator-(const scivector_slice& v1, const srmatrix_subv& v2) {
11746  return v1 - srvector(v2);
11747 }
11748 
11750 inline scivector operator-(const scivector_slice& v1, const scmatrix_subv& v2) {
11751  return v1 - scvector(v2);
11752 }
11753 
11755 inline scivector operator-(const scivector_slice& v1, const simatrix_subv& v2) {
11756  return v1 - sivector(v2);
11757 }
11758 
11760 inline scivector operator-(const scivector_slice& v1, const scimatrix_subv& v2) {
11761  return v1 - scivector(v2);
11762 }
11763 
11765 inline scivector operator-(const srvector_slice& v1, const scimatrix_subv& v2) {
11766  return v1 - scivector(v2);
11767 }
11768 
11770 inline scivector operator-(const scvector_slice& v1, const scimatrix_subv& v2) {
11771  return v1 - scivector(v2);
11772 }
11773 
11775 inline scivector operator-(const sivector_slice& v1, const scimatrix_subv& v2) {
11776  return v1 - scivector(v2);
11777 }
11778 
11780 inline scivector operator-(const sivector_slice& v1, const scmatrix_subv& v2) {
11781  return v1 - scvector(v2);
11782 }
11783 
11785 inline scivector operator-(const scvector_slice& v1, const simatrix_subv& v2) {
11786  return v1 - sivector(v2);
11787 }
11788 
11790 inline civector operator-(const civector& v1, const srmatrix_subv& v2) {
11791  return v1 - srvector(v2);
11792 }
11793 
11795 inline civector operator-(const civector& v1, const scmatrix_subv& v2) {
11796  return v1 - scvector(v2);
11797 }
11798 
11800 inline civector operator-(const civector& v1, const simatrix_subv& v2) {
11801  return v1 - sivector(v2);
11802 }
11803 
11805 inline civector operator-(const civector& v1, const scimatrix_subv& v2) {
11806  return v1 - scivector(v2);
11807 }
11808 
11810 inline civector operator-(const rvector& v1, const scimatrix_subv& v2) {
11811  return v1 - scivector(v2);
11812 }
11813 
11815 inline civector operator-(const cvector& v1, const scimatrix_subv& v2) {
11816  return v1 - scivector(v2);
11817 }
11818 
11820 inline civector operator-(const ivector& v1, const scimatrix_subv& v2) {
11821  return v1 - scivector(v2);
11822 }
11823 
11825 inline civector operator-(const ivector& v1, const scmatrix_subv& v2) {
11826  return v1 - scvector(v2);
11827 }
11828 
11830 inline civector operator-(const cvector& v1, const simatrix_subv& v2) {
11831  return v1 - sivector(v2);
11832 }
11833 
11835 inline civector operator-(const civector_slice& v1, const srmatrix_subv& v2) {
11836  return v1 - srvector(v2);
11837 }
11838 
11840 inline civector operator-(const civector_slice& v1, const scmatrix_subv& v2) {
11841  return v1 - scvector(v2);
11842 }
11843 
11845 inline civector operator-(const civector_slice& v1, const simatrix_subv& v2) {
11846  return v1 - sivector(v2);
11847 }
11848 
11850 inline civector operator-(const civector_slice& v1, const scimatrix_subv& v2) {
11851  return v1 - scivector(v2);
11852 }
11853 
11855 inline civector operator-(const rvector_slice& v1, const scimatrix_subv& v2) {
11856  return v1 - scivector(v2);
11857 }
11858 
11860 inline civector operator-(const cvector_slice& v1, const scimatrix_subv& v2) {
11861  return v1 - scivector(v2);
11862 }
11863 
11865 inline civector operator-(const ivector_slice& v1, const scimatrix_subv& v2) {
11866  return v1 - scivector(v2);
11867 }
11868 
11870 inline civector operator-(const ivector_slice& v1, const scmatrix_subv& v2) {
11871  return v1 - scvector(v2);
11872 }
11873 
11875 inline civector operator-(const cvector_slice& v1, const simatrix_subv& v2) {
11876  return v1 - sivector(v2);
11877 }
11878 
11880 inline scivector operator|(const scimatrix_subv& v1, const srvector& v2) {
11881  return scivector(v1) | v2;
11882 }
11883 
11885 inline scivector operator|(const scimatrix_subv& v1, const scvector& v2) {
11886  return scivector(v1) | v2;
11887 }
11888 
11890 inline scivector operator|(const scimatrix_subv& v1, const sivector& v2) {
11891  return scivector(v1) | v2;
11892 }
11893 
11895 inline scivector operator|(const scimatrix_subv& v1, const scivector& v2) {
11896  return scivector(v1) | v2;
11897 }
11898 
11900 inline scivector operator|(const srmatrix_subv& v1, const scivector& v2) {
11901  return srvector(v1) | v2;
11902 }
11903 
11905 inline scivector operator|(const scmatrix_subv& v1, const scivector& v2) {
11906  return scvector(v1) | v2;
11907 }
11908 
11910 inline scivector operator|(const simatrix_subv& v1, const scivector& v2) {
11911  return sivector(v1) | v2;
11912 }
11913 
11915 inline scivector operator|(const scmatrix_subv& v1, const sivector& v2) {
11916  return scvector(v1) | v2;
11917 }
11918 
11920 inline scivector operator|(const simatrix_subv& v1, const scvector& v2) {
11921  return sivector(v1) | v2;
11922 }
11923 
11925 inline scivector operator|(const scimatrix_subv& v1, const srvector_slice& v2) {
11926  return scivector(v1) | v2;
11927 }
11928 
11930 inline scivector operator|(const scimatrix_subv& v1, const scvector_slice& v2) {
11931  return scivector(v1) | v2;
11932 }
11933 
11935 inline scivector operator|(const scimatrix_subv& v1, const sivector_slice& v2) {
11936  return scivector(v1) | v2;
11937 }
11938 
11940 inline scivector operator|(const scimatrix_subv& v1, const scivector_slice& v2) {
11941  return scivector(v1) | v2;
11942 }
11943 
11945 inline scivector operator|(const srmatrix_subv& v1, const scivector_slice& v2) {
11946  return srvector(v1) | v2;
11947 }
11948 
11950 inline scivector operator|(const scmatrix_subv& v1, const scivector_slice& v2) {
11951  return scvector(v1) | v2;
11952 }
11953 
11955 inline scivector operator|(const simatrix_subv& v1, const scivector_slice& v2) {
11956  return sivector(v1) | v2;
11957 }
11958 
11960 inline scivector operator|(const simatrix_subv& v1, const scvector_slice& v2) {
11961  return sivector(v1) | v2;
11962 }
11963 
11965 inline scivector operator|(const scmatrix_subv& v1, const sivector_slice& v2) {
11966  return scvector(v1) | v2;
11967 }
11968 
11970 inline civector operator|(const scimatrix_subv& v1, const rvector& v2) {
11971  return scivector(v1) | v2;
11972 }
11973 
11975 inline civector operator|(const scimatrix_subv& v1, const cvector& v2) {
11976  return scivector(v1) | v2;
11977 }
11978 
11980 inline civector operator|(const scimatrix_subv& v1, const ivector& v2) {
11981  return scivector(v1) | v2;
11982 }
11983 
11985 inline civector operator|(const scimatrix_subv& v1, const civector& v2) {
11986  return scivector(v1) | v2;
11987 }
11988 
11990 inline civector operator|(const srmatrix_subv& v1, const civector& v2) {
11991  return srvector(v1) | v2;
11992 }
11993 
11995 inline civector operator|(const simatrix_subv& v1, const civector& v2) {
11996  return sivector(v1) | v2;
11997 }
11998 
12000 inline civector operator|(const scmatrix_subv& v1, const civector& v2) {
12001  return scvector(v1) | v2;
12002 }
12003 
12005 inline civector operator|(const scmatrix_subv& v1, const ivector& v2) {
12006  return scvector(v1) | v2;
12007 }
12008 
12010 inline civector operator|(const simatrix_subv& v1, const cvector& v2) {
12011  return sivector(v1) | v2;
12012 }
12013 
12015 inline civector operator|(const scimatrix_subv& v1, const rvector_slice& v2) {
12016  return scivector(v1) | v2;
12017 }
12018 
12020 inline civector operator|(const scimatrix_subv& v1, const cvector_slice& v2) {
12021  return scivector(v1) | v2;
12022 }
12023 
12025 inline civector operator|(const scimatrix_subv& v1, const ivector_slice& v2) {
12026  return scivector(v1) | v2;
12027 }
12028 
12030 inline civector operator|(const scimatrix_subv& v1, const civector_slice& v2) {
12031  return scivector(v1) | v2;
12032 }
12033 
12035 inline civector operator|(const srmatrix_subv& v1, const civector_slice& v2) {
12036  return srvector(v1) | v2;
12037 }
12038 
12040 inline civector operator|(const scmatrix_subv& v1, const civector_slice& v2) {
12041  return scvector(v1) | v2;
12042 }
12043 
12045 inline civector operator|(const simatrix_subv& v1, const civector_slice& v2) {
12046  return sivector(v1) | v2;
12047 }
12048 
12050 inline civector operator|(const simatrix_subv& v1, const cvector_slice& v2) {
12051  return sivector(v1) | v2;
12052 }
12053 
12055 inline civector operator|(const scmatrix_subv& v1, const ivector_slice& v2) {
12056  return scvector(v1) | v2;
12057 }
12058 
12060 inline scivector operator|(const scivector& v1, const srmatrix_subv& v2) {
12061  return v1 | srvector(v2);
12062 }
12063 
12065 inline scivector operator|(const scivector& v1, const scmatrix_subv& v2) {
12066  return v1 | scvector(v2);
12067 }
12068 
12070 inline scivector operator|(const scivector& v1, const simatrix_subv& v2) {
12071  return v1 | sivector(v2);
12072 }
12073 
12075 inline scivector operator|(const scivector& v1, const scimatrix_subv& v2) {
12076  return v1 | scivector(v2);
12077 }
12078 
12080 inline scivector operator|(const srvector& v1, const scimatrix_subv& v2) {
12081  return v1 | scivector(v2);
12082 }
12083 
12085 inline scivector operator|(const scvector& v1, const scimatrix_subv& v2) {
12086  return v1 | scivector(v2);
12087 }
12088 
12090 inline scivector operator|(const sivector& v1, const scimatrix_subv& v2) {
12091  return v1 | scivector(v2);
12092 }
12093 
12095 inline scivector operator|(const sivector& v1, const scmatrix_subv& v2) {
12096  return v1 | scvector(v2);
12097 }
12098 
12100 inline scivector operator|(const scvector& v1, const simatrix_subv& v2) {
12101  return v1 | sivector(v2);
12102 }
12103 
12105 inline scivector operator|(const scivector_slice& v1, const srmatrix_subv& v2) {
12106  return v1 | srvector(v2);
12107 }
12108 
12110 inline scivector operator|(const scivector_slice& v1, const scmatrix_subv& v2) {
12111  return v1 | scvector(v2);
12112 }
12113 
12115 inline scivector operator|(const scivector_slice& v1, const simatrix_subv& v2) {
12116  return v1 | sivector(v2);
12117 }
12118 
12120 inline scivector operator|(const scivector_slice& v1, const scimatrix_subv& v2) {
12121  return v1 | scivector(v2);
12122 }
12123 
12125 inline scivector operator|(const srvector_slice& v1, const scimatrix_subv& v2) {
12126  return v1 | scivector(v2);
12127 }
12128 
12130 inline scivector operator|(const scvector_slice& v1, const scimatrix_subv& v2) {
12131  return v1 | scivector(v2);
12132 }
12133 
12135 inline scivector operator|(const sivector_slice& v1, const scimatrix_subv& v2) {
12136  return v1 | scivector(v2);
12137 }
12138 
12140 inline scivector operator|(const sivector_slice& v1, const scmatrix_subv& v2) {
12141  return v1 | scvector(v2);
12142 }
12143 
12145 inline scivector operator|(const scvector_slice& v1, const simatrix_subv& v2) {
12146  return v1 | sivector(v2);
12147 }
12148 
12150 inline civector operator|(const civector& v1, const srmatrix_subv& v2) {
12151  return v1 | srvector(v2);
12152 }
12153 
12155 inline civector operator|(const civector& v1, const scmatrix_subv& v2) {
12156  return v1 | scvector(v2);
12157 }
12158 
12160 inline civector operator|(const civector& v1, const simatrix_subv& v2) {
12161  return v1 | sivector(v2);
12162 }
12163 
12165 inline civector operator|(const civector& v1, const scimatrix_subv& v2) {
12166  return v1 | scivector(v2);
12167 }
12168 
12170 inline civector operator|(const rvector& v1, const scimatrix_subv& v2) {
12171  return v1 | scivector(v2);
12172 }
12173 
12175 inline civector operator|(const cvector& v1, const scimatrix_subv& v2) {
12176  return v1 | scivector(v2);
12177 }
12178 
12180 inline civector operator|(const ivector& v1, const scimatrix_subv& v2) {
12181  return v1 | scivector(v2);
12182 }
12183 
12185 inline civector operator|(const ivector& v1, const scmatrix_subv& v2) {
12186  return v1 | scvector(v2);
12187 }
12188 
12190 inline civector operator|(const cvector& v1, const simatrix_subv& v2) {
12191  return v1 | sivector(v2);
12192 }
12193 
12195 inline civector operator|(const civector_slice& v1, const srmatrix_subv& v2) {
12196  return v1 | srvector(v2);
12197 }
12198 
12200 inline civector operator|(const civector_slice& v1, const scmatrix_subv& v2) {
12201  return v1 | scvector(v2);
12202 }
12203 
12205 inline civector operator|(const civector_slice& v1, const simatrix_subv& v2) {
12206  return v1 | sivector(v2);
12207 }
12208 
12210 inline civector operator|(const civector_slice& v1, const scimatrix_subv& v2) {
12211  return v1 | scivector(v2);
12212 }
12213 
12215 inline civector operator|(const rvector_slice& v1, const scimatrix_subv& v2) {
12216  return v1 | scivector(v2);
12217 }
12218 
12220 inline civector operator|(const cvector_slice& v1, const scimatrix_subv& v2) {
12221  return v1 | scivector(v2);
12222 }
12223 
12225 inline civector operator|(const ivector_slice& v1, const scimatrix_subv& v2) {
12226  return v1 | scivector(v2);
12227 }
12228 
12230 inline civector operator|(const ivector_slice& v1, const scmatrix_subv& v2) {
12231  return v1 | scvector(v2);
12232 }
12233 
12235 inline civector operator|(const cvector_slice& v1, const simatrix_subv& v2) {
12236  return v1 | sivector(v2);
12237 }
12238 
12240 inline scivector operator|(const scmatrix_subv& v1, const srvector& v2) {
12241  return scvector(v1) | v2;
12242 }
12243 
12245 inline scivector operator|(const srmatrix_subv& v1, const scvector& v2) {
12246  return srvector(v1) | v2;
12247 }
12248 
12250 inline scivector operator|(const scmatrix_subv& v1, const scvector& v2) {
12251  return scvector(v1) | v2;
12252 }
12253 
12255 inline scivector operator|(const scmatrix_subv& v1, const srvector_slice& v2) {
12256  return scvector(v1) | v2;
12257 }
12258 
12260 inline scivector operator|(const srmatrix_subv& v1, const scvector_slice& v2) {
12261  return srvector(v1) | v2;
12262 }
12263 
12265 inline scivector operator|(const scmatrix_subv& v1, const scvector_slice& v2) {
12266  return scvector(v1) | v2;
12267 }
12268 
12270 inline civector operator|(const scmatrix_subv& v1, const rvector& v2) {
12271  return scvector(v1) | v2;
12272 }
12273 
12275 inline civector operator|(const srmatrix_subv& v1, const cvector& v2) {
12276  return srvector(v1) | v2;
12277 }
12278 
12280 inline civector operator|(const scmatrix_subv& v1, const cvector& v2) {
12281  return scvector(v1) | v2;
12282 }
12283 
12285 inline civector operator|(const scmatrix_subv& v1, const rvector_slice& v2) {
12286  return scvector(v1) | v2;
12287 }
12288 
12290 inline civector operator|(const srmatrix_subv& v1, const cvector_slice& v2) {
12291  return srvector(v1) | v2;
12292 }
12293 
12295 inline civector operator|(const scmatrix_subv& v1, const cvector_slice& v2) {
12296  return scvector(v1) | v2;
12297 }
12298 
12300 inline scivector operator|(const scvector& v1, const srmatrix_subv& v2) {
12301  return v1 | srvector(v2);
12302 }
12303 
12305 inline scivector operator|(const srvector& v1, const scmatrix_subv& v2) {
12306  return v1 | scvector(v2);
12307 }
12308 
12310 inline scivector operator|(const scvector& v1, const scmatrix_subv& v2) {
12311  return v1 | scvector(v2);
12312 }
12313 
12315 inline scivector operator|(const scvector_slice& v1, const srmatrix_subv& v2) {
12316  return v1 | srvector(v2);
12317 }
12318 
12320 inline scivector operator|(const srvector_slice& v1, const scmatrix_subv& v2) {
12321  return v1 | scvector(v2);
12322 }
12323 
12325 inline scivector operator|(const scvector_slice& v1, const scmatrix_subv& v2) {
12326  return v1 | scvector(v2);
12327 }
12328 
12330 inline civector operator|(const cvector& v1, const srmatrix_subv& v2) {
12331  return v1 | srvector(v2);
12332 }
12333 
12335 inline civector operator|(const rvector& v1, const scmatrix_subv& v2) {
12336  return v1 | scvector(v2);
12337 }
12338 
12340 inline civector operator|(const cvector& v1, const scmatrix_subv& v2) {
12341  return v1 | scvector(v2);
12342 }
12343 
12345 inline civector operator|(const cvector_slice& v1, const srmatrix_subv& v2) {
12346  return v1 | srvector(v2);
12347 }
12348 
12350 inline civector operator|(const rvector_slice& v1, const scmatrix_subv& v2) {
12351  return v1 | scvector(v2);
12352 }
12353 
12355 inline 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 
12910 inline bool operator==(const scimatrix_subv& v1, const srvector& v2) {
12911  return scivector(v1) == v2;
12912 }
12913 
12915 inline bool operator==(const scimatrix_subv& v1, const scvector& v2) {
12916  return scivector(v1) == v2;
12917 }
12918 
12920 inline bool operator==(const scimatrix_subv& v1, const sivector& v2) {
12921  return scivector(v1) == v2;
12922 }
12923 
12925 inline bool operator==(const scimatrix_subv& v1, const scivector& v2) {
12926  return scivector(v1) == v2;
12927 }
12928 
12930 inline bool operator==(const srmatrix_subv& v1, const scivector& v2) {
12931  return srvector(v1) == v2;
12932 }
12933 
12935 inline bool operator==(const scmatrix_subv& v1, const scivector& v2) {
12936  return scvector(v1) == v2;
12937 }
12938 
12940 inline bool operator==(const simatrix_subv& v1, const scivector& v2) {
12941  return sivector(v1) == v2;
12942 }
12943 
12945 inline bool operator==(const scimatrix_subv& v1, const srvector_slice& v2) {
12946  return scivector(v1) == v2;
12947 }
12948 
12950 inline bool operator==(const scimatrix_subv& v1, const sivector_slice& v2) {
12951  return scivector(v1) == v2;
12952 }
12953 
12955 inline bool operator==(const scimatrix_subv& v1, const scvector_slice& v2) {
12956  return scivector(v1) == v2;
12957 }
12958 
12960 inline bool operator==(const scimatrix_subv& v1, const scivector_slice& v2) {
12961  return scivector(v1) == v2;
12962 }
12963 
12965 inline bool operator==(const srmatrix_subv& v1, const scivector_slice& v2) {
12966  return srvector(v1) == v2;
12967 }
12968 
12970 inline bool operator==(const scmatrix_subv& v1, const scivector_slice& v2) {
12971  return scvector(v1) == v2;
12972 }
12973 
12975 inline bool operator==(const simatrix_subv& v1, const scivector_slice& v2) {
12976  return sivector(v1) == v2;
12977 }
12978 
12980 inline bool operator==(const scimatrix_subv& v1, const rvector& v2) {
12981  return scivector(v1) == v2;
12982 }
12983 
12985 inline bool operator==(const scimatrix_subv& v1, const cvector& v2) {
12986  return scivector(v1) == v2;
12987 }
12988 
12990 inline bool operator==(const scimatrix_subv& v1, const ivector& v2) {
12991  return scivector(v1) == v2;
12992 }
12993 
12995 inline bool operator==(const scimatrix_subv& v1, const civector& v2) {
12996  return scivector(v1) == v2;
12997 }
12998 
13000 inline bool operator==(const srmatrix_subv& v1, const civector& v2) {
13001  return srvector(v1) == v2;
13002 }
13003 
13005 inline bool operator==(const simatrix_subv& v1, const civector& v2) {
13006  return sivector(v1) == v2;
13007 }
13008 
13010 inline bool operator==(const scmatrix_subv& v1, const civector& v2) {
13011  return scivector(v1) == v2;
13012 }
13013 
13015 inline bool operator==(const scimatrix_subv& v1, const rvector_slice& v2) {
13016  return scivector(v1) == v2;
13017 }
13018 
13020 inline bool operator==(const scimatrix_subv& v1, const cvector_slice& v2) {
13021  return scivector(v1) == v2;
13022 }
13023 
13025 inline bool operator==(const scimatrix_subv& v1, const ivector_slice& v2) {
13026  return scivector(v1) == v2;
13027 }
13028 
13030 inline bool operator==(const scimatrix_subv& v1, const civector_slice& v2) {
13031  return scivector(v1) == v2;
13032 }
13033 
13035 inline bool operator==(const srmatrix_subv& v1, const civector_slice& v2) {
13036  return srvector(v1) == v2;
13037 }
13038 
13040 inline bool operator==(const scmatrix_subv& v1, const civector_slice& v2) {
13041  return scivector(v1) == v2;
13042 }
13043 
13045 inline bool operator==(const simatrix_subv& v1, const civector_slice& v2) {
13046  return scivector(v1) == v2;
13047 }
13048 
13050 inline bool operator==(const scivector& v1, const srmatrix_subv& v2) {
13051  return v1 == srvector(v2);
13052 }
13053 
13055 inline bool operator==(const scivector& v1, const scmatrix_subv& v2) {
13056  return v1 == scvector(v2);
13057 }
13058 
13060 inline bool operator==(const scivector& v1, const simatrix_subv& v2) {
13061  return v1 == sivector(v2);
13062 }
13063 
13065 inline bool operator==(const scivector& v1, const scimatrix_subv& v2) {
13066  return v1 == scivector(v2);
13067 }
13068 
13070 inline bool operator==(const srvector& v1, const scimatrix_subv& v2) {
13071  return v1 == scivector(v2);
13072 }
13073 
13075 inline bool operator==(const scvector& v1, const scimatrix_subv& v2) {
13076  return v1 == scivector(v2);
13077 }
13078 
13080 inline bool operator==(const sivector& v1, const scimatrix_subv& v2) {
13081  return v1 == scivector(v2);
13082 }
13083 
13085 inline bool operator==(const scivector_slice& v1, const srmatrix_subv& v2) {
13086  return v1 == srvector(v2);
13087 }
13088 
13090 inline bool operator==(const scivector_slice& v1, const simatrix_subv& v2) {
13091  return v1 == sivector(v2);
13092 }
13093 
13095 inline bool operator==(const scivector_slice& v1, const scmatrix_subv& v2) {
13096  return v1 == scvector(v2);
13097 }
13098 
13100 inline bool operator==(const scivector_slice& v1, const scimatrix_subv& v2) {
13101  return v1 == scivector(v2);
13102 }
13103 
13105 inline bool operator==(const srvector_slice& v1, const scimatrix_subv& v2) {
13106  return v1 == scivector(v2);
13107 }
13108 
13110 inline bool operator==(const scvector_slice& v1, const scimatrix_subv& v2) {
13111  return v1 == scivector(v2);
13112 }
13113 
13115 inline bool operator==(const sivector_slice& v1, const scimatrix_subv& v2) {
13116  return v1 == scivector(v2);
13117 }
13118 
13120 inline bool operator==(const civector& v1, const srmatrix_subv& v2) {
13121  return v1 == srvector(v2);
13122 }
13123 
13125 inline bool operator==(const civector& v1, const simatrix_subv& v2) {
13126  return v1 == sivector(v2);
13127 }
13128 
13130 inline bool operator==(const civector& v1, const scmatrix_subv& v2) {
13131  return v1 == scvector(v2);
13132 }
13133 
13135 inline bool operator==(const civector& v1, const scimatrix_subv& v2) {
13136  return v1 == scivector(v2);
13137 }
13138 
13140 inline bool operator==(const rvector& v1, const scimatrix_subv& v2) {
13141  return v1 == scivector(v2);
13142 }
13143 
13145 inline bool operator==(const cvector& v1, const scimatrix_subv& v2) {
13146  return v1 == scivector(v2);
13147 }
13148 
13150 inline bool operator==(const ivector& v1, const scimatrix_subv& v2) {
13151  return v1 == scivector(v2);
13152 }
13153 
13155 inline bool operator==(const civector_slice& v1, const srmatrix_subv& v2) {
13156  return v1 == srvector(v2);
13157 }
13158 
13160 inline bool operator==(const civector_slice& v1, const simatrix_subv& v2) {
13161  return v1 == sivector(v2);
13162 }
13163 
13165 inline bool operator==(const civector_slice& v1, const scmatrix_subv& v2) {
13166  return v1 == scvector(v2);
13167 }
13168 
13170 inline bool operator==(const civector_slice& v1, const scimatrix_subv& v2) {
13171  return v1 == scivector(v2);
13172 }
13173 
13175 inline bool operator==(const rvector_slice& v1, const scimatrix_subv& v2) {
13176  return v1 == scivector(v2);
13177 }
13178 
13180 inline bool operator==(const cvector_slice& v1, const scimatrix_subv& v2) {
13181  return v1 == scivector(v2);
13182 }
13183 
13185 inline bool operator==(const ivector_slice& v1, const scimatrix_subv& v2) {
13186  return v1 == scivector(v2);
13187 }
13188 
13190 inline bool operator!=(const scimatrix_subv& v1, const srvector& v2) {
13191  return scivector(v1) != v2;
13192 }
13193 
13195 inline bool operator!=(const scimatrix_subv& v1, const scvector& v2) {
13196  return scivector(v1) != v2;
13197 }
13198 
13200 inline bool operator!=(const scimatrix_subv& v1, const sivector& v2) {
13201  return scivector(v1) != v2;
13202 }
13203 
13205 inline bool operator!=(const scimatrix_subv& v1, const scivector& v2) {
13206  return scivector(v1) != v2;
13207 }
13208 
13210 inline bool operator!=(const srmatrix_subv& v1, const scivector& v2) {
13211  return srvector(v1) != v2;
13212 }
13213 
13215 inline bool operator!=(const scmatrix_subv& v1, const scivector& v2) {
13216  return scvector(v1) != v2;
13217 }
13218 
13220 inline bool operator!=(const simatrix_subv& v1, const scivector& v2) {
13221  return sivector(v1) != v2;
13222 }
13223 
13225 inline bool operator!=(const scimatrix_subv& v1, const srvector_slice& v2) {
13226  return scivector(v1) != v2;
13227 }
13228 
13230 inline bool operator!=(const scimatrix_subv& v1, const sivector_slice& v2) {
13231  return scivector(v1) != v2;
13232 }
13233 
13235 inline bool operator!=(const scimatrix_subv& v1, const scvector_slice& v2) {
13236  return scivector(v1) != v2;
13237 }
13238 
13240 inline bool operator!=(const scimatrix_subv& v1, const scivector_slice& v2) {
13241  return scivector(v1) != v2;
13242 }
13243 
13245 inline bool operator!=(const srmatrix_subv& v1, const scivector_slice& v2) {
13246  return srvector(v1) != v2;
13247 }
13248 
13250 inline bool operator!=(const scmatrix_subv& v1, const scivector_slice& v2) {
13251  return scvector(v1) != v2;
13252 }
13253 
13255 inline bool operator!=(const simatrix_subv& v1, const scivector_slice& v2) {
13256  return sivector(v1) != v2;
13257 }
13258 
13260 inline bool operator!=(const scimatrix_subv& v1, const rvector& v2) {
13261  return scivector(v1) != v2;
13262 }
13263 
13265 inline bool operator!=(const scimatrix_subv& v1, const cvector& v2) {
13266  return scivector(v1) != v2;
13267 }
13268 
13270 inline bool operator!=(const scimatrix_subv& v1, const ivector& v2) {
13271  return scivector(v1) != v2;
13272 }
13273 
13275 inline bool operator!=(const scimatrix_subv& v1, const civector& v2) {
13276  return scivector(v1) != v2;
13277 }
13278 
13280 inline bool operator!=(const srmatrix_subv& v1, const civector& v2) {
13281  return srvector(v1) != v2;
13282 }
13283 
13285 inline bool operator!=(const simatrix_subv& v1, const civector& v2) {
13286  return sivector(v1) != v2;
13287 }
13288 
13290 inline bool operator!=(const scmatrix_subv& v1, const civector& v2) {
13291  return scivector(v1) != v2;
13292 }
13293 
13295 inline bool operator!=(const scimatrix_subv& v1, const rvector_slice& v2) {
13296  return scivector(v1) != v2;
13297 }
13298 
13300 inline bool operator!=(const scimatrix_subv& v1, const cvector_slice& v2) {
13301  return scivector(v1) != v2;
13302 }
13303 
13305 inline bool operator!=(const scimatrix_subv& v1, const ivector_slice& v2) {
13306  return scivector(v1) != v2;
13307 }
13308 
13310 inline bool operator!=(const scimatrix_subv& v1, const civector_slice& v2) {
13311  return scivector(v1) != v2;
13312 }
13313 
13315 inline bool operator!=(const srmatrix_subv& v1, const civector_slice& v2) {
13316  return srvector(v1) != v2;
13317 }
13318 
13320 inline bool operator!=(const scmatrix_subv& v1, const civector_slice& v2) {
13321  return scivector(v1) != v2;
13322 }
13323 
13325 inline bool operator!=(const simatrix_subv& v1, const civector_slice& v2) {
13326  return scivector(v1) != v2;
13327 }
13328 
13330 inline bool operator!=(const scivector& v1, const srmatrix_subv& v2) {
13331  return v1 != srvector(v2);
13332 }
13333 
13335 inline bool operator!=(const scivector& v1, const scmatrix_subv& v2) {
13336  return v1 != scvector(v2);
13337 }
13338 
13340 inline bool operator!=(const scivector& v1, const simatrix_subv& v2) {
13341  return v1 != sivector(v2);
13342 }
13343 
13345 inline bool operator!=(const scivector& v1, const scimatrix_subv& v2) {
13346  return v1 != scivector(v2);
13347 }
13348 
13350 inline bool operator!=(const srvector& v1, const scimatrix_subv& v2) {
13351  return v1 != scivector(v2);
13352 }
13353 
13355 inline bool operator!=(const scvector& v1, const scimatrix_subv& v2) {
13356  return v1 != scivector(v2);
13357 }
13358 
13360 inline bool operator!=(const sivector& v1, const scimatrix_subv& v2) {
13361  return v1 != scivector(v2);
13362 }
13363 
13365 inline bool operator!=(const scivector_slice& v1, const srmatrix_subv& v2) {
13366  return v1 != srvector(v2);
13367 }
13368 
13370 inline bool operator!=(const scivector_slice& v1, const simatrix_subv& v2) {
13371  return v1 != sivector(v2);
13372 }
13373 
13375 inline bool operator!=(const scivector_slice& v1, const scmatrix_subv& v2) {
13376  return v1 != scvector(v2);
13377 }
13378 
13380 inline bool operator!=(const scivector_slice& v1, const scimatrix_subv& v2) {
13381  return v1 != scivector(v2);
13382 }
13383 
13385 inline bool operator!=(const srvector_slice& v1, const scimatrix_subv& v2) {
13386  return v1 != scivector(v2);
13387 }
13388 
13390 inline bool operator!=(const scvector_slice& v1, const scimatrix_subv& v2) {
13391  return v1 != scivector(v2);
13392 }
13393 
13395 inline bool operator!=(const sivector_slice& v1, const scimatrix_subv& v2) {
13396  return v1 != scivector(v2);
13397 }
13398 
13400 inline bool operator!=(const civector& v1, const srmatrix_subv& v2) {
13401  return v1 != srvector(v2);
13402 }
13403 
13405 inline bool operator!=(const civector& v1, const simatrix_subv& v2) {
13406  return v1 != sivector(v2);
13407 }
13408 
13410 inline bool operator!=(const civector& v1, const scmatrix_subv& v2) {
13411  return v1 != scivector(v2);
13412 }
13413 
13415 inline bool operator!=(const civector& v1, const scimatrix_subv& v2) {
13416  return v1 != scivector(v2);
13417 }
13418 
13420 inline bool operator!=(const rvector& v1, const scimatrix_subv& v2) {
13421  return v1 != scivector(v2);
13422 }
13423 
13425 inline bool operator!=(const cvector& v1, const scimatrix_subv& v2) {
13426  return v1 != scivector(v2);
13427 }
13428 
13430 inline bool operator!=(const ivector& v1, const scimatrix_subv& v2) {
13431  return v1 != scivector(v2);
13432 }
13433 
13435 inline bool operator!=(const civector_slice& v1, const srmatrix_subv& v2) {
13436  return v1 != srvector(v2);
13437 }
13438 
13440 inline bool operator!=(const civector_slice& v1, const simatrix_subv& v2) {
13441  return v1 != sivector(v2);
13442 }
13443 
13445 inline bool operator!=(const civector_slice& v1, const scmatrix_subv& v2) {
13446  return v1 != scvector(v2);
13447 }
13448 
13450 inline bool operator!=(const civector_slice& v1, const scimatrix_subv& v2) {
13451  return v1 != scivector(v2);
13452 }
13453 
13455 inline bool operator!=(const rvector_slice& v1, const scimatrix_subv& v2) {
13456  return v1 != scivector(v2);
13457 }
13458 
13460 inline bool operator!=(const cvector_slice& v1, const scimatrix_subv& v2) {
13461  return v1 != scivector(v2);
13462 }
13463 
13465 inline bool operator!=(const ivector_slice& v1, const scimatrix_subv& v2) {
13466  return v1 != scivector(v2);
13467 }
13468 
13470 inline bool operator<(const scimatrix_subv& v1, const sivector& v2) {
13471  return scivector(v1) < v2;
13472 }
13473 
13475 inline bool operator<(const scimatrix_subv& v1, const scivector& v2) {
13476  return scivector(v1) < v2;
13477 }
13478 
13480 inline bool operator<(const srmatrix_subv& v1, const scivector& v2) {
13481  return srvector(v1) < v2;
13482 }
13483 
13485 inline bool operator<(const scmatrix_subv& v1, const scivector& v2) {
13486  return scvector(v1) < v2;
13487 }
13488 
13490 inline bool operator<(const simatrix_subv& v1, const scivector& v2) {
13491  return sivector(v1) < v2;
13492 }
13493 
13495 inline bool operator<(const scimatrix_subv& v1, const sivector_slice& v2) {
13496  return scivector(v1) < v2;
13497 }
13498 
13500 inline bool operator<(const scimatrix_subv& v1, const scivector_slice& v2) {
13501  return scivector(v1) < v2;
13502 }
13503 
13505 inline bool operator<(const srmatrix_subv& v1, const scivector_slice& v2) {
13506  return srvector(v1) < v2;
13507 }
13508 
13510 inline bool operator<(const scmatrix_subv& v1, const scivector_slice& v2) {
13511  return scvector(v1) < v2;
13512 }
13513 
13515 inline bool operator<(const simatrix_subv& v1, const scivector_slice& v2) {
13516  return sivector(v1) < v2;
13517 }
13518 
13520 inline bool operator<(const scimatrix_subv& v1, const ivector& v2) {
13521  return scivector(v1) < v2;
13522 }
13523 
13525 inline bool operator<(const scimatrix_subv& v1, const civector& v2) {
13526  return scivector(v1) < v2;
13527 }
13528 
13530 inline bool operator<(const srmatrix_subv& v1, const civector& v2) {
13531  return srvector(v1) < v2;
13532 }
13533 
13535 inline bool operator<(const simatrix_subv& v1, const civector& v2) {
13536  return sivector(v1) < v2;
13537 }
13538 
13540 inline bool operator<(const scmatrix_subv& v1, const civector& v2) {
13541  return scivector(v1) < v2;
13542 }
13543 
13545 inline bool operator<(const scimatrix_subv& v1, const ivector_slice& v2) {
13546  return scivector(v1) < v2;
13547 }
13548 
13550 inline bool operator<(const scimatrix_subv& v1, const civector_slice& v2) {
13551  return scivector(v1) < v2;
13552 }
13553 
13555 inline bool operator<(const srmatrix_subv& v1, const civector_slice& v2) {
13556  return srvector(v1) < v2;
13557 }
13558 
13560 inline bool operator<(const scmatrix_subv& v1, const civector_slice& v2) {
13561  return scivector(v1) < v2;
13562 }
13563 
13565 inline bool operator<(const simatrix_subv& v1, const civector_slice& v2) {
13566  return scivector(v1) < v2;
13567 }
13568 
13570 inline bool operator<(const scivector& v1, const simatrix_subv& v2) {
13571  return v1 < sivector(v2);
13572 }
13573 
13575 inline bool operator<(const scivector& v1, const scimatrix_subv& v2) {
13576  return v1 < scivector(v2);
13577 }
13578 
13580 inline bool operator<(const srvector& v1, const scimatrix_subv& v2) {
13581  return v1 < scivector(v2);
13582 }
13583 
13585 inline bool operator<(const scvector& v1, const scimatrix_subv& v2) {
13586  return v1 < scivector(v2);
13587 }
13588 
13590 inline bool operator<(const sivector& v1, const scimatrix_subv& v2) {
13591  return v1 < scivector(v2);
13592 }
13593 
13595 inline bool operator<(const scivector_slice& v1, const simatrix_subv& v2) {
13596  return v1 < sivector(v2);
13597 }
13598 
13600 inline bool operator<(const scivector_slice& v1, const scimatrix_subv& v2) {
13601  return v1 < scivector(v2);
13602 }
13603 
13605 inline bool operator<(const srvector_slice& v1, const scimatrix_subv& v2) {
13606  return v1 < scivector(v2);
13607 }
13608 
13610 inline bool operator<(const scvector_slice& v1, const scimatrix_subv& v2) {
13611  return v1 < scivector(v2);
13612 }
13613 
13615 inline bool operator<(const sivector_slice& v1, const scimatrix_subv& v2) {
13616  return v1 < scivector(v2);
13617 }
13618 
13620 inline bool operator<(const civector& v1, const simatrix_subv& v2) {
13621  return v1 < sivector(v2);
13622 }
13623 
13625 inline bool operator<(const civector& v1, const scimatrix_subv& v2) {
13626  return v1 < scivector(v2);
13627 }
13628 
13630 inline bool operator<(const rvector& v1, const scimatrix_subv& v2) {
13631  return v1 < scivector(v2);
13632 }
13633 
13635 inline bool operator<(const cvector& v1, const scimatrix_subv& v2) {
13636  return v1 < scivector(v2);
13637 }
13638 
13640 inline bool operator<(const ivector& v1, const scimatrix_subv& v2) {
13641  return v1 < scivector(v2);
13642 }
13643 
13645 inline bool operator<(const civector_slice& v1, const simatrix_subv& v2) {
13646  return v1 < sivector(v2);
13647 }
13648 
13650 inline bool operator<(const civector_slice& v1, const scimatrix_subv& v2) {
13651  return v1 < scivector(v2);
13652 }
13653 
13655 inline bool operator<(const rvector_slice& v1, const scimatrix_subv& v2) {
13656  return v1 < scivector(v2);
13657 }
13658 
13660 inline bool operator<(const cvector_slice& v1, const scimatrix_subv& v2) {
13661  return v1 < scivector(v2);
13662 }
13663 
13665 inline bool operator<(const ivector_slice& v1, const scimatrix_subv& v2) {
13666  return v1 < scivector(v2);
13667 }
13668 
13670 inline bool operator<=(const scimatrix_subv& v1, const sivector& v2) {
13671  return scivector(v1) <= v2;
13672 }
13673 
13675 inline bool operator<=(const scimatrix_subv& v1, const scivector& v2) {
13676  return scivector(v1) <= v2;
13677 }
13678 
13680 inline bool operator<=(const srmatrix_subv& v1, const scivector& v2) {
13681  return srvector(v1) <= v2;
13682 }
13683 
13685 inline bool operator<=(const scmatrix_subv& v1, const scivector& v2) {
13686  return scvector(v1) <= v2;
13687 }
13688 
13690 inline bool operator<=(const simatrix_subv& v1, const scivector& v2) {
13691  return sivector(v1) <= v2;
13692 }
13693 
13695 inline bool operator<=(const scimatrix_subv& v1, const sivector_slice& v2) {
13696  return scivector(v1) <= v2;
13697 }
13698 
13700 inline bool operator<=(const scimatrix_subv& v1, const scivector_slice& v2) {
13701  return scivector(v1) <= v2;
13702 }
13703 
13705 inline bool operator<=(const srmatrix_subv& v1, const scivector_slice& v2) {
13706  return srvector(v1) <= v2;
13707 }
13708 
13710 inline bool operator<=(const scmatrix_subv& v1, const scivector_slice& v2) {
13711  return scvector(v1) <= v2;
13712 }
13713 
13715 inline bool operator<=(const simatrix_subv& v1, const scivector_slice& v2) {
13716  return sivector(v1) <= v2;
13717 }
13718 
13720 inline bool operator<=(const scimatrix_subv& v1, const ivector& v2) {
13721  return scivector(v1) <= v2;
13722 }
13723 
13725 inline bool operator<=(const scimatrix_subv& v1, const civector& v2) {
13726  return scivector(v1) <= v2;
13727 }
13728 
13730 inline bool operator<=(const srmatrix_subv& v1, const civector& v2) {
13731  return srvector(v1) <= v2;
13732 }
13733 
13735 inline bool operator<=(const simatrix_subv& v1, const civector& v2) {
13736  return sivector(v1) <= v2;
13737 }
13738 
13740 inline bool operator<=(const scmatrix_subv& v1, const civector& v2) {
13741  return scivector(v1) <= v2;
13742 }
13743 
13745 inline bool operator<=(const scimatrix_subv& v1, const ivector_slice& v2) {
13746  return scivector(v1) <= v2;
13747 }
13748 
13750 inline bool operator<=(const scimatrix_subv& v1, const civector_slice& v2) {
13751  return scivector(v1) <= v2;
13752 }
13753 
13755 inline bool operator<=(const srmatrix_subv& v1, const civector_slice& v2) {
13756  return srvector(v1) <= v2;
13757 }
13758 
13760 inline bool operator<=(const scmatrix_subv& v1, const civector_slice& v2) {
13761  return scivector(v1) <= v2;
13762 }
13763 
13765 inline bool operator<=(const simatrix_subv& v1, const civector_slice& v2) {
13766  return scivector(v1) <= v2;
13767 }
13768 
13770 inline bool operator<=(const scivector& v1, const simatrix_subv& v2) {
13771  return v1 <= sivector(v2);
13772 }
13773 
13775 inline bool operator<=(const scivector& v1, const scimatrix_subv& v2) {
13776  return v1 <= scivector(v2);
13777 }
13778 
13780 inline bool operator<=(const srvector& v1, const scimatrix_subv& v2) {
13781  return v1 <= scivector(v2);
13782 }
13783 
13785 inline bool operator<=(const scvector& v1, const scimatrix_subv& v2) {
13786  return v1 <= scivector(v2);
13787 }
13788 
13790 inline bool operator<=(const sivector& v1, const scimatrix_subv& v2) {
13791  return v1 <= scivector(v2);
13792 }
13793 
13795 inline bool operator<=(const scivector_slice& v1, const simatrix_subv& v2) {
13796  return v1 <= sivector(v2);
13797 }
13798 
13800 inline bool operator<=(const scivector_slice& v1, const scimatrix_subv& v2) {
13801  return v1 <= scivector(v2);
13802 }
13803 
13805 inline bool operator<=(const srvector_slice& v1, const scimatrix_subv& v2) {
13806  return v1 <= scivector(v2);
13807 }
13808 
13810 inline bool operator<=(const scvector_slice& v1, const scimatrix_subv& v2) {
13811  return v1 <= scivector(v2);
13812 }
13813 
13815 inline bool operator<=(const sivector_slice& v1, const scimatrix_subv& v2) {
13816  return v1 <= scivector(v2);
13817 }
13818 
13820 inline bool operator<=(const civector& v1, const simatrix_subv& v2) {
13821  return v1 <= sivector(v2);
13822 }
13823 
13825 inline bool operator<=(const civector& v1, const scimatrix_subv& v2) {
13826  return v1 <= scivector(v2);
13827 }
13828 
13830 inline bool operator<=(const rvector& v1, const scimatrix_subv& v2) {
13831  return v1 <= scivector(v2);
13832 }
13833 
13835 inline bool operator<=(const cvector& v1, const scimatrix_subv& v2) {
13836  return v1 <= scivector(v2);
13837 }
13838 
13840 inline bool operator<=(const ivector& v1, const scimatrix_subv& v2) {
13841  return v1 <= scivector(v2);
13842 }
13843 
13845 inline bool operator<=(const civector_slice& v1, const simatrix_subv& v2) {
13846  return v1 <= sivector(v2);
13847 }
13848 
13850 inline bool operator<=(const civector_slice& v1, const scimatrix_subv& v2) {
13851  return v1 <= scivector(v2);
13852 }
13853 
13855 inline bool operator<=(const rvector_slice& v1, const scimatrix_subv& v2) {
13856  return v1 <= scivector(v2);
13857 }
13858 
13860 inline bool operator<=(const cvector_slice& v1, const scimatrix_subv& v2) {
13861  return v1 <= scivector(v2);
13862 }
13863 
13865 inline bool operator<=(const ivector_slice& v1, const scimatrix_subv& v2) {
13866  return v1 <= scivector(v2);
13867 }
13868 
13870 inline bool operator>(const scimatrix_subv& v1, const srvector& v2) {
13871  return scivector(v1) > v2;
13872 }
13873 
13875 inline bool operator>(const scimatrix_subv& v1, const scvector& v2) {
13876  return scivector(v1) > v2;
13877 }
13878 
13880 inline bool operator>(const scimatrix_subv& v1, const sivector& v2) {
13881  return scivector(v1) > v2;
13882 }
13883 
13885 inline bool operator>(const scimatrix_subv& v1, const scivector& v2) {
13886  return scivector(v1) > v2;
13887 }
13888 
13890 inline bool operator>(const simatrix_subv& v1, const scivector& v2) {
13891  return sivector(v1) > v2;
13892 }
13893 
13895 inline bool operator>(const scimatrix_subv& v1, const srvector_slice& v2) {
13896  return scivector(v1) > v2;
13897 }
13898 
13900 inline bool operator>(const scimatrix_subv& v1, const sivector_slice& v2) {
13901  return scivector(v1) > v2;
13902 }
13903 
13905 inline bool operator>(const scimatrix_subv& v1, const scvector_slice& v2) {
13906  return scivector(v1) > v2;
13907 }
13908 
13910 inline bool operator>(const scimatrix_subv& v1, const scivector_slice& v2) {
13911  return scivector(v1) > v2;
13912 }
13913 
13915 inline bool operator>(const simatrix_subv& v1, const scivector_slice& v2) {
13916  return sivector(v1) > v2;
13917 }
13918 
13920 inline bool operator>(const scimatrix_subv& v1, const rvector& v2) {
13921  return scivector(v1) > v2;
13922 }
13923 
13925 inline bool operator>(const scimatrix_subv& v1, const cvector& v2) {
13926  return scivector(v1) > v2;
13927 }
13928 
13930 inline bool operator>(const scimatrix_subv& v1, const ivector& v2) {
13931  return scivector(v1) > v2;
13932 }
13933 
13935 inline bool operator>(const scimatrix_subv& v1, const civector& v2) {
13936  return scivector(v1) > v2;
13937 }
13938 
13940 inline bool operator>(const simatrix_subv& v1, const civector& v2) {
13941  return sivector(v1) > v2;
13942 }
13943 
13945 inline bool operator>(const scimatrix_subv& v1, const rvector_slice& v2) {
13946  return scivector(v1) > v2;
13947 }
13948 
13950 inline bool operator>(const scimatrix_subv& v1, const cvector_slice& v2) {
13951  return scivector(v1) > v2;
13952 }
13953 
13955 inline bool operator>(const scimatrix_subv& v1, const ivector_slice& v2) {
13956  return scivector(v1) > v2;
13957 }
13958 
13960 inline bool operator>(const scimatrix_subv& v1, const civector_slice& v2) {
13961  return scivector(v1) > v2;
13962 }
13963 
13965 inline bool operator>(const simatrix_subv& v1, const civector_slice& v2) {
13966  return scivector(v1) > v2;
13967 }
13968 
13970 inline bool operator>(const scivector& v1, const srmatrix_subv& v2) {
13971  return v1 > srvector(v2);
13972 }
13973 
13975 inline bool operator>(const scivector& v1, const scmatrix_subv& v2) {
13976  return v1 > scvector(v2);
13977 }
13978 
13980 inline bool operator>(const scivector& v1, const simatrix_subv& v2) {
13981  return v1 > sivector(v2);
13982 }
13983 
13985 inline bool operator>(const scivector& v1, const scimatrix_subv& v2) {
13986  return v1 > scivector(v2);
13987 }
13988 
13990 inline bool operator>(const sivector& v1, const scimatrix_subv& v2) {
13991  return v1 > scivector(v2);
13992 }
13993 
13995 inline bool operator>(const scivector_slice& v1, const srmatrix_subv& v2) {
13996  return v1 > srvector(v2);
13997 }
13998 
14000 inline bool operator>(const scivector_slice& v1, const simatrix_subv& v2) {
14001  return v1 > sivector(v2);
14002 }
14003 
14005 inline bool operator>(const scivector_slice& v1, const scmatrix_subv& v2) {
14006  return v1 > scvector(v2);
14007 }
14008 
14010 inline bool operator>(const scivector_slice& v1, const scimatrix_subv& v2) {
14011  return v1 > scivector(v2);
14012 }
14013 
14015 inline bool operator>(const sivector_slice& v1, const scimatrix_subv& v2) {
14016  return v1 > scivector(v2);
14017 }
14018 
14020 inline bool operator>(const civector& v1, const srmatrix_subv& v2) {
14021  return v1 > srvector(v2);
14022 }
14023 
14025 inline bool operator>(const civector& v1, const simatrix_subv& v2) {
14026  return v1 > sivector(v2);
14027 }
14028 
14030 inline bool operator>(const civector& v1, const scmatrix_subv& v2) {
14031  return v1 > scvector(v2);
14032 }
14033 
14035 inline bool operator>(const civector& v1, const scimatrix_subv& v2) {
14036  return v1 > scivector(v2);
14037 }
14038 
14040 inline bool operator>(const ivector& v1, const scimatrix_subv& v2) {
14041  return v1 > scivector(v2);
14042 }
14043 
14045 inline bool operator>(const civector_slice& v1, const srmatrix_subv& v2) {
14046  return v1 > srvector(v2);
14047 }
14048 
14050 inline bool operator>(const civector_slice& v1, const simatrix_subv& v2) {
14051  return v1 > sivector(v2);
14052 }
14053 
14055 inline bool operator>(const civector_slice& v1, const scmatrix_subv& v2) {
14056  return v1 > scvector(v2);
14057 }
14058 
14060 inline bool operator>(const civector_slice& v1, const scimatrix_subv& v2) {
14061  return v1 > scivector(v2);
14062 }
14063 
14065 inline bool operator>(const ivector_slice& v1, const scimatrix_subv& v2) {
14066  return v1 > scivector(v2);
14067 }
14068 
14070 inline bool operator>=(const scimatrix_subv& v1, const srvector& v2) {
14071  return scivector(v1) >= v2;
14072 }
14073 
14075 inline bool operator>=(const scimatrix_subv& v1, const scvector& v2) {
14076  return scivector(v1) >= v2;
14077 }
14078 
14080 inline bool operator>=(const scimatrix_subv& v1, const sivector& v2) {
14081  return scivector(v1) >= v2;
14082 }
14083 
14085 inline bool operator>=(const scimatrix_subv& v1, const scivector& v2) {
14086  return scivector(v1) >= v2;
14087 }
14088 
14090 inline bool operator>=(const simatrix_subv& v1, const scivector& v2) {
14091  return sivector(v1) >= v2;
14092 }
14093 
14095 inline bool operator>=(const scimatrix_subv& v1, const srvector_slice& v2) {
14096  return scivector(v1) >= v2;
14097 }
14098 
14100 inline bool operator>=(const scimatrix_subv& v1, const sivector_slice& v2) {
14101  return scivector(v1) >= v2;
14102 }
14103 
14105 inline bool operator>=(const scimatrix_subv& v1, const scvector_slice& v2) {
14106  return scivector(v1) >= v2;
14107 }
14108 
14110 inline bool operator>=(const scimatrix_subv& v1, const scivector_slice& v2) {
14111  return scivector(v1) >= v2;
14112 }
14113 
14115 inline bool operator>=(const simatrix_subv& v1, const scivector_slice& v2) {
14116  return sivector(v1) >= v2;
14117 }
14118 
14120 inline bool operator>=(const scimatrix_subv& v1, const rvector& v2) {
14121  return scivector(v1) >= v2;
14122 }
14123 
14125 inline bool operator>=(const scimatrix_subv& v1, const cvector& v2) {
14126  return scivector(v1) >= v2;
14127 }
14128 
14130 inline bool operator>=(const scimatrix_subv& v1, const ivector& v2) {
14131  return scivector(v1) >= v2;
14132 }
14133 
14135 inline bool operator>=(const scimatrix_subv& v1, const civector& v2) {
14136  return scivector(v1) >= v2;
14137 }
14138 
14140 inline bool operator>=(const simatrix_subv& v1, const civector& v2) {
14141  return sivector(v1) >= v2;
14142 }
14143 
14145 inline bool operator>=(const scimatrix_subv& v1, const rvector_slice& v2) {
14146  return scivector(v1) >= v2;
14147 }
14148 
14150 inline bool operator>=(const scimatrix_subv& v1, const cvector_slice& v2) {
14151  return scivector(v1) >= v2;
14152 }
14153 
14155 inline bool operator>=(const scimatrix_subv& v1, const ivector_slice& v2) {
14156  return scivector(v1) >= v2;
14157 }
14158 
14160 inline bool operator>=(const scimatrix_subv& v1, const civector_slice& v2) {
14161  return scivector(v1) >= v2;
14162 }
14163 
14165 inline bool operator>=(const simatrix_subv& v1, const civector_slice& v2) {
14166  return scivector(v1) >= v2;
14167 }
14168 
14170 inline bool operator>=(const scivector& v1, const srmatrix_subv& v2) {
14171  return v1 >= srvector(v2);
14172 }
14173 
14175 inline bool operator>=(const scivector& v1, const scmatrix_subv& v2) {
14176  return v1 >= scvector(v2);
14177 }
14178 
14180 inline bool operator>=(const scivector& v1, const simatrix_subv& v2) {
14181  return v1 >= sivector(v2);
14182 }
14183 
14185 inline bool operator>=(const scivector& v1, const scimatrix_subv& v2) {
14186  return v1 >= scivector(v2);
14187 }
14188 
14190 inline bool operator>=(const sivector& v1, const scimatrix_subv& v2) {
14191  return v1 >= scivector(v2);
14192 }
14193 
14195 inline bool operator>=(const scivector_slice& v1, const srmatrix_subv& v2) {
14196  return v1 >= srvector(v2);
14197 }
14198 
14200 inline bool operator>=(const scivector_slice& v1, const simatrix_subv& v2) {
14201  return v1 >= sivector(v2);
14202 }
14203 
14205 inline bool operator>=(const scivector_slice& v1, const scmatrix_subv& v2) {
14206  return v1 >= scvector(v2);
14207 }
14208 
14210 inline bool operator>=(const scivector_slice& v1, const scimatrix_subv& v2) {
14211  return v1 >= scivector(v2);
14212 }
14213 
14215 inline bool operator>=(const sivector_slice& v1, const scimatrix_subv& v2) {
14216  return v1 >= scivector(v2);
14217 }
14218 
14220 inline bool operator>=(const civector& v1, const srmatrix_subv& v2) {
14221  return v1 >= srvector(v2);
14222 }
14223 
14225 inline bool operator>=(const civector& v1, const simatrix_subv& v2) {
14226  return v1 >= sivector(v2);
14227 }
14228 
14230 inline bool operator>=(const civector& v1, const scmatrix_subv& v2) {
14231  return v1 >= scvector(v2);
14232 }
14233 
14235 inline bool operator>=(const civector& v1, const scimatrix_subv& v2) {
14236  return v1 >= scivector(v2);
14237 }
14238 
14240 inline bool operator>=(const ivector& v1, const scimatrix_subv& v2) {
14241  return v1 >= scivector(v2);
14242 }
14243 
14245 inline bool operator>=(const civector_slice& v1, const srmatrix_subv& v2) {
14246  return v1 >= srvector(v2);
14247 }
14248 
14250 inline bool operator>=(const civector_slice& v1, const simatrix_subv& v2) {
14251  return v1 >= sivector(v2);
14252 }
14253 
14255 inline bool operator>=(const civector_slice& v1, const scmatrix_subv& v2) {
14256  return v1 >= scvector(v2);
14257 }
14258 
14260 inline bool operator>=(const civector_slice& v1, const scimatrix_subv& v2) {
14261  return v1 >= scivector(v2);
14262 }
14263 
14265 inline bool operator>=(const ivector_slice& v1, const scimatrix_subv& v2) {
14266  return v1 >= scivector(v2);
14267 }
14268 
14270 inline bool operator!(const scimatrix_subv& x) {
14271  return sv_v_not(x);
14272 }
14273 
14274 
14276 
14279 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scimatrix_subv& v2) {
14280  accumulate(dot,scivector(v1),scivector(v2));
14281 }
14282 
14283 
14285 
14288 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scmatrix_subv& v2) {
14289  accumulate(dot,scivector(v1),scvector(v2));
14290 }
14291 
14293 
14296 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const simatrix_subv& v2) {
14297  accumulate(dot,scivector(v1),sivector(v2));
14298 }
14299 
14301 
14304 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const srmatrix_subv& v2) {
14305  accumulate(dot,scivector(v1),srvector(v2));
14306 }
14307 
14309 
14312 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const scimatrix_subv& v2) {
14313  accumulate(dot,scvector(v1),scivector(v2));
14314 }
14315 
14317 
14320 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scimatrix_subv& v2) {
14321  accumulate(dot,sivector(v1),scivector(v2));
14322 }
14323 
14325 
14328 inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const scimatrix_subv& v2) {
14329  accumulate(dot,srvector(v1),scivector(v2));
14330 }
14331 
14333 
14336 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const srvector& v2) {
14337  accumulate(dot,scivector(v1),v2);
14338 }
14339 
14341 
14344 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scvector& v2) {
14345  accumulate(dot,scivector(v1),v2);
14346 }
14347 
14349 
14352 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const sivector& v2) {
14353  accumulate(dot,scivector(v1),v2);
14354 }
14355 
14357 
14360 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scivector& v2) {
14361  accumulate(dot,scivector(v1),v2);
14362 }
14363 
14365 
14368 inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const scivector& v2) {
14369  accumulate(dot,srvector(v1),v2);
14370 }
14371 
14373 
14376 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const scivector& v2) {
14377  accumulate(dot,scvector(v1),v2);
14378 }
14379 
14381 
14384 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scivector& v2) {
14385  accumulate(dot,sivector(v1),v2);
14386 }
14387 
14389 
14392 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const sivector& v2) {
14393  accumulate(dot,scvector(v1),v2);
14394 }
14395 
14397 
14400 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scvector& v2) {
14401  accumulate(dot,sivector(v1),v2);
14402 }
14403 
14405 
14408 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const srvector_slice& v2) {
14409  accumulate(dot,scivector(v1),v2);
14410 }
14411 
14413 
14416 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scvector_slice& v2) {
14417  accumulate(dot,scivector(v1),v2);
14418 }
14419 
14421 
14424 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const sivector_slice& v2) {
14425  accumulate(dot,scivector(v1),v2);
14426 }
14427 
14429 
14432 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const scivector_slice& v2) {
14433  accumulate(dot,scivector(v1),v2);
14434 }
14435 
14437 
14440 inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const scivector_slice& v2) {
14441  accumulate(dot,srvector(v1),v2);
14442 }
14443 
14445 
14448 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const scivector_slice& v2) {
14449  accumulate(dot,scvector(v1),v2);
14450 }
14451 
14453 
14456 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scivector_slice& v2) {
14457  accumulate(dot,sivector(v1),v2);
14458 }
14459 
14461 
14464 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const sivector_slice& v2) {
14465  accumulate(dot,scvector(v1),v2);
14466 }
14467 
14469 
14472 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const scvector_slice& v2) {
14473  accumulate(dot,sivector(v1),v2);
14474 }
14475 
14477 
14480 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const rvector& v2) {
14481  accumulate(dot,scivector(v1),v2);
14482 }
14483 
14485 
14488 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const ivector& v2) {
14489  accumulate(dot,scivector(v1),v2);
14490 }
14491 
14493 
14496 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const cvector& v2) {
14497  accumulate(dot,scivector(v1),v2);
14498 }
14499 
14501 
14504 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const civector& v2) {
14505  accumulate(dot,scivector(v1),v2);
14506 }
14507 
14509 
14512 inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const civector& v2) {
14513  accumulate(dot,srvector(v1),v2);
14514 }
14515 
14517 
14520 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const civector& v2) {
14521  accumulate(dot,sivector(v1),v2);
14522 }
14523 
14525 
14528 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const civector& v2) {
14529  accumulate(dot,scvector(v1),v2);
14530 }
14531 
14533 
14536 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const ivector& v2) {
14537  accumulate(dot,scvector(v1),v2);
14538 }
14539 
14541 
14544 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const cvector& v2) {
14545  accumulate(dot,sivector(v1),v2);
14546 }
14547 
14549 
14552 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const rvector_slice& v2) {
14553  accumulate(dot,scivector(v1),v2);
14554 }
14555 
14557 
14560 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const ivector_slice& v2) {
14561  accumulate(dot,scivector(v1),v2);
14562 }
14563 
14565 
14568 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const cvector_slice& v2) {
14569  accumulate(dot,scivector(v1),v2);
14570 }
14571 
14573 
14576 inline void accumulate(cidotprecision& dot,const scimatrix_subv& v1, const civector_slice& v2) {
14577  accumulate(dot,scivector(v1),v2);
14578 }
14579 
14581 
14584 inline void accumulate(cidotprecision& dot,const srmatrix_subv& v1, const civector_slice& v2) {
14585  accumulate(dot,srvector(v1),v2);
14586 }
14587 
14589 
14592 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const civector_slice& v2) {
14593  accumulate(dot,scvector(v1),v2);
14594 }
14595 
14597 
14600 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const civector_slice& v2) {
14601  accumulate(dot,sivector(v1),v2);
14602 }
14603 
14605 
14608 inline void accumulate(cidotprecision& dot,const scmatrix_subv& v1, const ivector_slice& v2) {
14609  accumulate(dot,scvector(v1),v2);
14610 }
14611 
14613 
14616 inline void accumulate(cidotprecision& dot,const simatrix_subv& v1, const cvector_slice& v2) {
14617  accumulate(dot,sivector(v1),v2);
14618 }
14619 
14621 
14624 inline void accumulate(cidotprecision& dot,const scivector& v1, const srmatrix_subv& v2) {
14625  accumulate(dot,v1,srvector(v2));
14626 }
14627 
14629 
14632 inline void accumulate(cidotprecision& dot,const scivector& v1, const scmatrix_subv& v2) {
14633  accumulate(dot,v1,scvector(v2));
14634 }
14635 
14637 
14640 inline void accumulate(cidotprecision& dot,const scivector& v1, const simatrix_subv& v2) {
14641  accumulate(dot,v1,sivector(v2));
14642 }
14643 
14645 
14648 inline void accumulate(cidotprecision& dot,const scivector& v1, const scimatrix_subv& v2) {
14649  accumulate(dot,v1,scivector(v2));
14650 }
14651 
14653 
14656 inline void accumulate(cidotprecision& dot,const srvector& v1, const scimatrix_subv& v2) {
14657  accumulate(dot,v1,scivector(v2));
14658 }
14659 
14661 
14664 inline void accumulate(cidotprecision& dot,const scvector& v1, const scimatrix_subv& v2) {
14665  accumulate(dot,v1,scivector(v2));
14666 }
14667 
14669 
14672 inline void accumulate(cidotprecision& dot,const sivector& v1, const scimatrix_subv& v2) {
14673  accumulate(dot,v1,scivector(v2));
14674 }
14675 
14677 
14680 inline void accumulate(cidotprecision& dot,const scvector& v1, const simatrix_subv& v2) {
14681  accumulate(dot,v1,sivector(v2));
14682 }
14683 
14685 
14688 inline void accumulate(cidotprecision& dot,const sivector& v1, const scmatrix_subv& v2) {
14689  accumulate(dot,v1,scvector(v2));
14690 }
14691 
14693 
14696 inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const srmatrix_subv& v2) {
14697  accumulate(dot,v1,srvector(v2));
14698 }
14699 
14701 
14704 inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const scmatrix_subv& v2) {
14705  accumulate(dot,v1,scvector(v2));
14706 }
14707 
14709 
14712 inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const simatrix_subv& v2) {
14713  accumulate(dot,v1,sivector(v2));
14714 }
14715 
14717 
14720 inline void accumulate(cidotprecision& dot,const scivector_slice& v1, const scimatrix_subv& v2) {
14721  accumulate(dot,v1,scivector(v2));
14722 }
14723 
14725 
14728 inline void accumulate(cidotprecision& dot,const srvector_slice& v1, const scimatrix_subv& v2) {
14729  accumulate(dot,v1,scivector(v2));
14730 }
14731 
14733 
14736 inline void accumulate(cidotprecision& dot,const sivector_slice& v1, const scimatrix_subv& v2) {
14737  accumulate(dot,v1,scivector(v2));
14738 }
14739 
14741 
14744 inline void accumulate(cidotprecision& dot,const scvector_slice& v1, const scimatrix_subv& v2) {
14745  accumulate(dot,v1,scivector(v2));
14746 }
14747 
14749 
14752 inline void accumulate(cidotprecision& dot,const scvector_slice& v1, const simatrix_subv& v2) {
14753  accumulate(dot,v1,sivector(v2));
14754 }
14755 
14757 
14760 inline void accumulate(cidotprecision& dot,const sivector_slice& v1, const scmatrix_subv& v2) {
14761  accumulate(dot,v1,scvector(v2));
14762 }
14763 
14765 
14768 inline void accumulate(cidotprecision& dot,const civector& v1, const srmatrix_subv& v2) {
14769  accumulate(dot,v1,srvector(v2));
14770 }
14771 
14773 
14776 inline void accumulate(cidotprecision& dot,const civector& v1, const scmatrix_subv& v2) {
14777  accumulate(dot,v1,scvector(v2));
14778 }
14779 
14781 
14784 inline void accumulate(cidotprecision& dot,const civector& v1, const simatrix_subv& v2) {
14785  accumulate(dot,v1,sivector(v2));
14786 }
14787 
14789 
14792 inline void accumulate(cidotprecision& dot,const civector& v1, const scimatrix_subv& v2) {
14793  accumulate(dot,v1,scivector(v2));
14794 }
14795 
14797 
14800 inline void accumulate(cidotprecision& dot,const rvector& v1, const scimatrix_subv& v2) {
14801  accumulate(dot,v1,scivector(v2));
14802 }
14803 
14805 
14808 inline void accumulate(cidotprecision& dot,const cvector& v1, const scimatrix_subv& v2) {
14809  accumulate(dot,v1,scivector(v2));
14810 }
14811 
14813 
14816 inline void accumulate(cidotprecision& dot,const ivector& v1, const scimatrix_subv& v2) {
14817  accumulate(dot,v1,scivector(v2));
14818 }
14819 
14821 
14824 inline void accumulate(cidotprecision& dot,const ivector& v1, const scmatrix_subv& v2) {
14825  accumulate(dot,v1,scvector(v2));
14826 }
14827 
14829 
14832 inline void accumulate(cidotprecision& dot,const cvector& v1, const simatrix_subv& v2) {
14833  accumulate(dot,v1,sivector(v2));
14834 }
14835 
14837 
14840 inline void accumulate(cidotprecision& dot,const civector_slice& v1, const srmatrix_subv& v2) {
14841  accumulate(dot,v1,srvector(v2));
14842 }
14843 
14845 
14848 inline void accumulate(cidotprecision& dot,const civector_slice& v1, const scmatrix_subv& v2) {
14849  accumulate(dot,v1,scvector(v2));
14850 }
14851 
14853 
14856 inline void accumulate(cidotprecision& dot,const civector_slice& v1, const simatrix_subv& v2) {
14857  accumulate(dot,v1,sivector(v2));
14858 }
14859 
14861 
14864 inline void accumulate(cidotprecision& dot,const civector_slice& v1, const scimatrix_subv& v2) {
14865  accumulate(dot,v1,scivector(v2));
14866 }
14867 
14869 
14872 inline void accumulate(cidotprecision& dot,const rvector_slice& v1, const scimatrix_subv& v2) {
14873  accumulate(dot,v1,scivector(v2));
14874 }
14875 
14877 
14880 inline void accumulate(cidotprecision& dot,const cvector_slice& v1, const scimatrix_subv& v2) {
14881  accumulate(dot,v1,scivector(v2));
14882 }
14883 
14885 
14888 inline void accumulate(cidotprecision& dot,const ivector_slice& v1, const scimatrix_subv& v2) {
14889  accumulate(dot,v1,scivector(v2));
14890 }
14891 
14893 
14896 inline void accumulate(cidotprecision& dot,const ivector_slice& v1, const scmatrix_subv& v2) {
14897  accumulate(dot,v1,scvector(v2));
14898 }
14899 
14901 
14904 inline 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.
Definition: cimatrix.hpp:1651
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
Definition: scimatrix.hpp:3986
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
Definition: scimatrix.hpp:4002
cimatrix_slice & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1620
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.
cimatrix_slice & operator+=(const cinterval &c) noexcept
Implementation of addition 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.
Definition: scimatrix.hpp:4018
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.
Definition: scimatrix.hpp:3994
cimatrix & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
Definition: scimatrix.hpp:3970
cimatrix & operator+=(const scimatrix &m1)
Implementation of addition and allocation operation.
Definition: scimatrix.hpp:3906
cimatrix & operator-=(const scimatrix &m1)
Implementation of substraction and allocation operation.
Definition: scimatrix.hpp:3934
The Scalar Type cinterval.
Definition: cinterval.hpp:55
The Data Type civector_slice.
Definition: civector.hpp:1015
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.
Definition: intmatrix.hpp:314
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.
Definition: scimatrix.hpp:4918
scimatrix_slice & operator|=(const scimatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5442
friend srmatrix InfRe(const scimatrix_slice &)
Returns the real part of the infimum of the slice S.
Definition: scimatrix.hpp:5735
scimatrix_slice & operator-=(const srmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5328
scimatrix_slice & operator|=(const cimatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5514
cinterval & element(const int i, const int j)
Returns a reference to the element (i,j) of the matrix.
Definition: scimatrix.hpp:5538
scimatrix_slice & operator=(const rmatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5044
scimatrix_slice & operator+=(const cimatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5322
friend std::ostream & operator<<(std::ostream &, const scimatrix_slice &)
Standard output operator for sparse matrix slice.
Definition: scimatrix.hpp:9604
scimatrix_slice & operator*=(const simatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5100
friend int RowLen(const scimatrix_slice &)
Returns the number columns of the matrix slice.
Definition: scimatrix.hpp:5639
scimatrix_slice & operator=(const cimatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5059
scimatrix_slice & operator=(const complex &C)
Assing C to all elements of the slice.
Definition: scimatrix.hpp:4994
scimatrix_slice & operator=(const real &C)
Assing C to all elements of the slice.
Definition: scimatrix.hpp:4984
scimatrix_slice & operator|=(const cmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5502
scimatrix_slice & operator*=(const cimatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5178
scimatrix_slice & operator-=(const cmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5382
scimatrix_slice & operator|=(const simatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5436
friend int ColLen(const scimatrix_slice &)
Returns the number of rows of the matrix slice.
Definition: scimatrix.hpp:5644
scimatrix_slice & operator*=(const scimatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5130
scimatrix_slice & operator=(const imatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5034
scimatrix_slice & operator=(const imatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5054
scimatrix_slice & operator=(const scmatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5009
const cinterval operator()(const int i, const int j) const
Returns a copy of the element (i,j) of the matrix.
Definition: scimatrix.hpp:5524
scimatrix_slice & operator=(const cinterval &C)
Assing C to all elements of the slice.
Definition: scimatrix.hpp:4999
scimatrix_slice & operator|=(const simatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5460
scimatrix_slice & operator*=(const cinterval &r)
Assigns the component wise product of the sparse slice and r to the slice.
Definition: scimatrix.hpp:5202
scimatrix_slice & operator+=(const scimatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5250
scimatrix_slice & operator*=(const imatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5172
scimatrix_slice & operator-=(const rmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5400
scimatrix_slice & operator+=(const rmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5304
scimatrix_slice & operator+=(const scmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5238
scimatrix_slice & operator+=(const srmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5256
scimatrix_slice & operator-=(const imatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5388
scimatrix_slice & operator=(const srmatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5064
scimatrix_slice & operator=(const interval &C)
Assing C to all elements of the slice.
Definition: scimatrix.hpp:4989
friend simatrix Im(const scimatrix_slice &)
Returns the imaginary part of the slice S.
Definition: scimatrix.hpp:5700
scimatrix_subv operator[](const int)
Returns a row of the matrix.
scimatrix_slice & operator-=(const cimatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5418
scimatrix_slice & operator+=(const simatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5244
scimatrix_slice & operator=(const simatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5076
scimatrix_slice & operator|=(const srmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5448
scimatrix_slice & operator*=(const real &r)
Assigns the component wise product of the sparse slice and r to the slice.
Definition: scimatrix.hpp:5184
scimatrix_slice & operator/=(const cinterval &r)
Assigns the component wise division of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5226
scimatrix_slice & operator*=(const scimatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5106
scimatrix_slice & operator*=(const complex &r)
Assigns the component wise product of the sparse slice and r to the slice.
Definition: scimatrix.hpp:5190
scimatrix_slice & operator=(const simatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5014
scimatrix_slice & operator+=(const rmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5280
scimatrix_slice & operator|=(const srmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5424
scimatrix_slice & operator=(const scmatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5070
scimatrix_slice & operator-=(const imatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5412
scimatrix_slice & operator*=(const cmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5166
scimatrix_slice & operator+=(const srmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5232
scimatrix_slice & operator*=(const srmatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5112
scimatrix_slice & operator-=(const srmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5352
scimatrix_slice & operator/=(const interval &r)
Assigns the component wise division of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5220
scimatrix_slice & operator*=(const simatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5124
scimatrix_slice & operator=(const cmatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5049
scimatrix_slice & operator+=(const cmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5310
scimatrix_slice & operator=(const cimatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5039
scimatrix_slice & operator*=(const scmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5094
scimatrix_slice & operator+=(const scimatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5274
scimatrix_slice & operator-=(const scimatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5370
friend scmatrix Sup(const scimatrix_slice &)
Returns the supremum of the slice S.
Definition: scimatrix.hpp:5730
scimatrix_slice & operator=(const srmatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5004
scimatrix_slice & operator-=(const scmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5334
scimatrix_slice & operator*=(const scmatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5118
scimatrix_slice & operator|=(const scimatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5466
scimatrix_slice & operator*=(const rmatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5136
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.
Definition: scimatrix.hpp:5685
scimatrix_slice & operator|=(const scmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5454
scimatrix_slice & operator+=(const imatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5316
scimatrix_slice & operator*=(const cmatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5142
scimatrix_slice & operator*=(const cimatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5154
friend srmatrix InfIm(const scimatrix_slice &)
Returns the imaginary part of the infimum of the slice S.
Definition: scimatrix.hpp:5740
scimatrix_slice & operator=(const scimatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5019
scimatrix_slice & operator-=(const rmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5376
scimatrix_slice & operator-=(const cimatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5394
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.
Definition: scimatrix.hpp:5690
scimatrix_slice & operator|=(const rmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5472
scimatrix_slice & operator=(const scimatrix_slice &C)
Assing C to the slice.
Definition: scimatrix.hpp:5082
scimatrix_slice & operator|=(const scmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5430
scimatrix_slice & operator|=(const imatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5484
scimatrix_slice & operator+=(const scmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5262
scimatrix_slice & operator*=(const srmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5088
scimatrix_slice & operator+=(const simatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5268
scimatrix_slice & operator+=(const imatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5292
scimatrix_slice & operator=(const rmatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5024
friend srmatrix SupIm(const scimatrix_slice &)
Returns the imaginary part of the supremum of the slice S.
Definition: scimatrix.hpp:5750
scimatrix_slice & operator+=(const cmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5286
scimatrix_slice & operator-=(const cmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5406
scimatrix_slice & operator-=(const simatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5364
scimatrix_slice & operator-=(const simatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5340
scimatrix_slice & operator|=(const rmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5496
scimatrix_slice & operator*=(const interval &r)
Assigns the component wise product of the sparse slice and r to the slice.
Definition: scimatrix.hpp:5196
scimatrix_slice & operator/=(const complex &r)
Assigns the component wise division of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5214
friend srmatrix SupRe(const scimatrix_slice &)
Returns the real part of the supremum of the slice S.
Definition: scimatrix.hpp:5745
scimatrix_slice & operator|=(const cimatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5490
scimatrix_slice & operator-=(const scmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5358
scimatrix_slice & operator*=(const rmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5160
scimatrix_slice & operator|=(const imatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5508
scimatrix_slice & operator+=(const cimatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5298
scimatrix_slice & operator/=(const real &r)
Assigns the component wise division of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5208
scimatrix_slice & operator|=(const cmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5478
scimatrix_slice & operator=(const cmatrix &C)
Assing C to the slice.
Definition: scimatrix.hpp:5029
friend simatrix Re(const scimatrix_slice &)
Returns the real part of the slice S.
Definition: scimatrix.hpp:5695
scimatrix_slice & operator-=(const scimatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5346
friend scmatrix Inf(const scimatrix_slice &)
Returns the infimum of the slice S.
Definition: scimatrix.hpp:5725
scimatrix_slice & operator*=(const imatrix &M)
Assigns the product of the sparse slice and M to the slice.
Definition: scimatrix.hpp:5148
Represents a row or column vector of a sparse matrix.
Definition: scimatrix.hpp:9628
scimatrix_subv & operator-=(const srvector &)
Assign the difference of the subvector with a vector to the subvector.
friend srvector InfRe(const scimatrix_subv &)
Returns the real part of the infimum of the subvector.
friend sivector Im(const scimatrix_subv &)
Returns the imaginary part of the subvector.
Definition: scimatrix.hpp:9976
friend sivector Re(const scimatrix_subv &)
Returns the real part of the subvector.
Definition: scimatrix.hpp:9971
friend int Ub(const scimatrix_subv &)
Returns the upper index bound of the subvector.
Definition: scimatrix.hpp:9958
scimatrix_subv & operator+=(const srvector &)
Assign the sum of the subvector with a vector to the subvector.
friend srvector SupIm(const scimatrix_subv &)
Returns the imaginary part of the supremum of the subvector.
scimatrix_subv & operator|=(const srvector &)
Assign the convex hull of the subvector and a vector to the subvector.
friend srvector InfIm(const scimatrix_subv &)
Returns the imaginary part of the infimum 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 civector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9780
scimatrix_subv & operator=(const sivector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9715
scimatrix_subv & operator=(const sivector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9735
scimatrix_subv & operator=(const rvector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9765
scimatrix_subv & operator=(const srmatrix_subv &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9785
cinterval & operator[](const int i)
Returns a reference to the i-th element of the subvector.
Definition: scimatrix.hpp:9648
scimatrix_subv & operator=(const srvector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9705
const cinterval operator[](const int i) const
Returns a copy of the i-th element of the subvector.
Definition: scimatrix.hpp:9668
scimatrix_subv & operator=(const civector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9760
scimatrix_subv & operator=(const scvector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9730
scimatrix_subv & operator=(const scvector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9710
friend srvector SupRe(const scimatrix_subv &)
Returns the real part of the supremum of the subvector.
scimatrix_subv & operator=(const ivector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9775
scimatrix_subv & operator=(const real &v)
Assigns v to all elements of the subvector.
Definition: scimatrix.hpp:9685
scimatrix_subv & operator=(const cvector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9770
friend scvector Inf(const scimatrix_subv &)
Returns the infimum of the subvector.
scimatrix_subv & operator=(const ivector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9755
friend std::istream & operator>>(std::istream &, scimatrix_subv &)
Standard input operator for subvectors.
scimatrix_subv & operator=(const cvector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9750
scimatrix_subv & operator=(const scivector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9720
friend int VecLen(const scimatrix_subv &)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
scimatrix_subv & operator=(const scimatrix_subv &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9800
friend scvector Sup(const scimatrix_subv &)
Returns the supremum of the subvector.
scimatrix_subv & operator*=(const real &)
Assign the componentwise product of the subvector with a scalar to the subvector.
scimatrix_subv & operator=(const scmatrix_subv &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9795
scimatrix_subv & operator=(const rvector &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9745
scimatrix_subv & operator=(const srvector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9725
friend int Lb(const scimatrix_subv &)
Returns the lower index bound of the subvector.
Definition: scimatrix.hpp:9950
scimatrix_subv & operator=(const scivector_slice &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9740
friend scivector operator-(const scimatrix_subv &)
Unary negation operator.
scimatrix_subv & operator=(const cinterval &v)
Assigns v to all elements of the subvector.
Definition: scimatrix.hpp:9700
scimatrix_subv & operator=(const complex &v)
Assigns v to all elements of the subvector.
Definition: scimatrix.hpp:9690
scimatrix_subv & operator=(const simatrix_subv &v)
Assigns a vector to a subvector.
Definition: scimatrix.hpp:9790
scimatrix_subv & operator=(const interval &v)
Assigns v to all elements of the subvector.
Definition: scimatrix.hpp:9695
A sparse complex interval matrix.
Definition: scimatrix.hpp:71
scimatrix & operator+=(const imatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:843
scimatrix & operator|=(const simatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:983
scimatrix & operator*=(const cinterval &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1098
scimatrix & operator=(const cimatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
Definition: scimatrix.hpp:596
scimatrix & operator*=(const imatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1033
scimatrix & operator-=(const rmatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:893
scimatrix(const imatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
Definition: scimatrix.hpp:427
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.
Definition: scimatrix.hpp:616
friend simatrix Im(const scimatrix &)
Returns the imaginary part of the matrix A.
Definition: scimatrix.hpp:1401
scimatrix & operator*=(const cmatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1048
scimatrix & operator+=(const rmatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:813
scimatrix(const simatrix &A)
Creates a sparse interval matrix out of a sparse interval matrix A.
Definition: scimatrix.hpp:374
friend scmatrix mid(const scimatrix &)
Returns the componentwise midpoint of the matrix A.
Definition: scimatrix.hpp:1491
scimatrix(const srmatrix &A)
Creates a sparse interval matrix out of a sparse real matrix A.
Definition: scimatrix.hpp:360
scimatrix & operator=(const cinterval &A)
Assigns a complex interval value to all elements of the matrix (resulting in a dense matrix!...
Definition: scimatrix.hpp:576
scimatrix & operator&=(const cimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:998
scimatrix operator()(const intvector &pervec)
Performs a row permutation using a permutation vector.
Definition: scimatrix.hpp:766
scimatrix & operator*=(const scmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1068
scimatrix & operator|=(const scimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:988
scimatrix & operator=(const real &A)
Assigns a real value to all elements of the matrix (resulting in a dense matrix!)
Definition: scimatrix.hpp:561
const std::vector< cinterval > & values() const
Returns a constant reference to the vector containing the stored values (the array)
Definition: scimatrix.hpp:109
friend srmatrix CompMat(const scimatrix &)
Returns Ostroswkis comparison matrix for A.
Definition: scimatrix.hpp:1241
scimatrix & operator*=(const rmatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1043
scimatrix & operator*=(const rmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1028
scimatrix & operator=(const cmatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
Definition: scimatrix.hpp:586
friend srmatrix SupRe(const scimatrix &)
Returns the real part of the supremum of the matrix A.
Definition: scimatrix.hpp:1563
scimatrix_subv operator[](const cxscmatrix_column &)
Returns a column of the matrix as a sparse subvector object.
friend void SetLb(scimatrix &, const int, const int)
Sets the lower index bound of the rows (i==ROW) or columns (i==COL) to j.
Definition: scimatrix.hpp:1306
std::vector< cinterval > & values()
Returns a reference to the vector containing the stored values (the array)
Definition: scimatrix.hpp:94
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
Definition: scimatrix.hpp:808
friend int ColLen(const scimatrix &)
Returns the number of rows of the matrix.
Definition: scimatrix.hpp:1363
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.
Definition: scimatrix.hpp:606
friend scimatrix conj(const scimatrix &)
Returns the conjugate complex of the matrix A.
Definition: scimatrix.hpp:1455
scimatrix & operator=(const simatrix &A)
Assign a sparse complex to a sparse interval matrix.
Definition: scimatrix.hpp:647
friend int Lb(const scimatrix &, int)
Returns the lower index bound for the rows or columns of A.
Definition: scimatrix.hpp:1335
scimatrix & operator|=(const cmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:938
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.
Definition: scimatrix.hpp:121
scimatrix & operator+=(const scmatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:858
scimatrix & operator+=(const scimatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:868
friend scimatrix Id(const scimatrix &)
Return a sparse unity matrix of the same dimension as A.
Definition: scimatrix.hpp:1218
scimatrix & operator/=(const cinterval &r)
Divide all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1118
scimatrix & operator|=(const rmatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:953
friend scimatrix transp(const scimatrix &)
Returns the transpose of A.
Definition: scimatrix.hpp:1266
scimatrix & operator+=(const simatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:863
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...
Definition: scimatrix.hpp:522
scimatrix & operator&=(const imatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:993
scimatrix & operator+=(const rmatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:833
scimatrix & operator=(const scmatrix &A)
Assign a sparse complex to a sparse complex interval matrix.
Definition: scimatrix.hpp:634
scimatrix & operator*=(const simatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1073
scimatrix & operator*=(const srmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1063
scimatrix & operator/=(const complex &r)
Divide all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1108
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.
Definition: scimatrix.hpp:611
scimatrix(const cimatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
Definition: scimatrix.hpp:450
scimatrix(const cmatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
Definition: scimatrix.hpp:404
scimatrix & operator*=(const imatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1053
scimatrix & operator-=(const cmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:878
scimatrix operator()(const intmatrix &P)
Performs a row permutation using the permutation matrix P. Faster than explicitly computing the produ...
Definition: scimatrix.hpp:797
friend scmatrix Inf(const scimatrix &)
Returns the Infimum of the matrix A.
Definition: scimatrix.hpp:1419
scimatrix & operator|=(const rmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:933
cinterval & element(int i, int j)
Returns a reference to the element (i,j) of the matrix.
Definition: scimatrix.hpp:703
scimatrix & operator-=(const cmatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:898
scimatrix & operator+=(const cimatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:828
scimatrix(const rmatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
Definition: scimatrix.hpp:381
scimatrix & operator=(const srmatrix &A)
Assign a sparse real to a sparse complex interval matrix.
Definition: scimatrix.hpp:621
friend int RowLen(const scimatrix &)
Returns the number of columns of the matrix.
Definition: scimatrix.hpp:1358
scimatrix & operator*=(const cimatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1038
scimatrix & operator-=(const cimatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:908
friend simatrix abs(const scimatrix &)
Returns the componentwise absolute value of the matrix A.
Definition: scimatrix.hpp:1473
scimatrix & operator-=(const scimatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:928
scimatrix operator()(const intvector &pervec, const intvector &q)
Performs a row and column permutation using two permutation vectors.
Definition: scimatrix.hpp:739
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...
Definition: scimatrix.hpp:256
scimatrix & operator-=(const srmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:913
const std::vector< int > & row_indices() const
Returns a constant reference to the vector containing the row indices (the array)
Definition: scimatrix.hpp:104
friend int Ub(const scimatrix &, int)
Returns the upper index bound for the rows or columns of A.
Definition: scimatrix.hpp:1348
scimatrix & operator|=(const srmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:973
scimatrix & operator&=(const cimatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:1008
scimatrix & operator+=(const imatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:823
scimatrix & operator-=(const cimatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:888
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.
Definition: scimatrix.hpp:130
scimatrix & operator*=(const real &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1083
std::vector< int > & column_pointers()
Returns a reference to the vector containing the column pointers (the array)
Definition: scimatrix.hpp:84
scimatrix & operator+=(const cmatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:838
scimatrix & operator*=(const cmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1023
scimatrix & operator-=(const simatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:923
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,...
Definition: scimatrix.hpp:145
friend scmatrix diam(const scimatrix &)
Returns the componentwise diameter of the matrix A.
Definition: scimatrix.hpp:1509
scimatrix & operator+=(const cmatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:818
scimatrix & operator/=(const real &r)
Divide all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1103
void dropzeros()
Drops explicitly stored zeros from the data structure.
Definition: scimatrix.hpp:537
friend scmatrix Sup(const scimatrix &)
Returns the Supremum of the matrix A.
Definition: scimatrix.hpp:1437
friend std::istream & operator>>(std::istream &, scimatrix_slice &)
Standard input operator for sparse matrix slice.
Definition: scimatrix.hpp:9614
scimatrix(const int ms, const int ns, const cimatrix &A)
Constructor for banded matrices.
Definition: scimatrix.hpp:476
scimatrix & operator+=(const srmatrix &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:853
scimatrix & operator-=(const imatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:883
scimatrix & operator=(const complex &A)
Assigns a complex value to all elements of the matrix (resulting in a dense matrix!...
Definition: scimatrix.hpp:571
scimatrix & operator-=(const imatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:903
scimatrix()
Standard constructor, creates an empty matrix of dimension 0x0.
Definition: scimatrix.hpp:114
scimatrix & operator=(const interval &A)
Assigns an interval value to all elements of the matrix (resulting in a dense matrix!...
Definition: scimatrix.hpp:566
scimatrix & operator&=(const simatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:1013
scimatrix & operator|=(const scmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:978
const cinterval operator()(int i, int j) const
Returns a copy of the element in row i and column j.
Definition: scimatrix.hpp:682
scimatrix & operator&=(const imatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:1003
scimatrix & operator+=(const cimatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:848
scimatrix & operator|=(const imatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:943
scimatrix & operator|=(const imatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:963
const std::vector< int > & column_pointers() const
Returns a constant reference to the vector containing the column pointers (the array)
Definition: scimatrix.hpp:99
scimatrix & operator=(const rmatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
Definition: scimatrix.hpp:581
scimatrix(const scmatrix &A)
Creates a sparse interval matrix out of a sparse complex matrix A.
Definition: scimatrix.hpp:367
scimatrix & operator&=(const scimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:1018
friend srmatrix InfRe(const scimatrix &)
Returns the real part of the infimum of the matrix A.
Definition: scimatrix.hpp:1527
scimatrix & operator*=(const scimatrix &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1078
friend simatrix Re(const scimatrix &)
Returns the real part of the matrix A.
Definition: scimatrix.hpp:1383
scimatrix & operator=(const imatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
Definition: scimatrix.hpp:591
scimatrix & operator|=(const cmatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:958
scimatrix & operator*=(const cimatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
Definition: scimatrix.hpp:1058
scimatrix & operator*=(const complex &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1088
scimatrix & operator-=(const scmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:918
scimatrix & operator|=(const cimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:948
friend srmatrix InfIm(const scimatrix &)
Returns the imaginary part of the infimum of the matrix A.
Definition: scimatrix.hpp:1545
scimatrix & operator*=(const interval &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1093
friend srmatrix SupIm(const scimatrix &)
Returns the imaginary part of the supremum of the matrix A.
Definition: scimatrix.hpp:1581
friend void SetUb(scimatrix &, const int, const int)
Sets the upper index bound of the rows (i==ROW) or columns (i==COL) to j.
Definition: scimatrix.hpp:1321
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.
Definition: scimatrix.hpp:601
scimatrix & operator-=(const rmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
Definition: scimatrix.hpp:873
scimatrix & operator/=(const interval &r)
Divide all elements of the sparse matrix by r and assign the result to it.
Definition: scimatrix.hpp:1113
scimatrix & operator|=(const cimatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
Definition: scimatrix.hpp:968
std::vector< int > & row_indices()
Returns a reference to the vector containing the row indices (the array)
Definition: scimatrix.hpp:89
scimatrix operator()(const intmatrix &P, const intmatrix &Q)
Performs row and column permutations using the two permutation matrices P and Q. Faster than explicit...
Definition: scimatrix.hpp:790
real density() const
Returns the density (the number of non-zeros divided by the number of elements) of the matrix.
Definition: scimatrix.hpp:803
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
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.
Definition: scmatrix.hpp:1956
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
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.
Definition: scvector.hpp:1245
A sparse complex vector.
Definition: scvector.hpp:58
A slice of a sparse real interval matrix.
Definition: simatrix.hpp:2431
Represents a row or column vector of a sparse matrix.
Definition: simatrix.hpp:4383
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.
Definition: sivector.hpp:1831
A sparse interval vector.
Definition: sivector.hpp:59
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
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.
Definition: scimatrix.hpp:9966
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
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.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
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.
Definition: cimatrix.inl:1211
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156