C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
scimatrix.hpp
00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: scimatrix.hpp,v 1.20 2014/01/30 17:23:48 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_SCIMATRIX_HPP_INCLUDED
00027 #define _CXSC_SCIMATRIX_HPP_INCLUDED
00028 
00029 #include <cinterval.hpp>
00030 #include <cimatrix.hpp>
00031 #include <civector.hpp>
00032 #include <cidot.hpp>
00033 #include <vector>
00034 #include <algorithm>
00035 #include <iostream>
00036 #include <sparsecidot.hpp>
00037 #include <sparsematrix.hpp>
00038 #include <srmatrix.hpp>
00039 #include <scmatrix.hpp>
00040 #include <simatrix.hpp>
00041 #include <srvector.hpp>
00042 #include <sivector.hpp>
00043 #include <scvector.hpp>
00044 #include <scivector.hpp>
00045 
00046 namespace cxsc {
00047 
00048 //definiert in srmatrix.hpp
00049 //enum STORAGE_TYPE{triplet,compressed_row,compressed_column};
00050 
00051 class scimatrix_slice;
00052 class scimatrix_subv;
00053 
00054 inline bool comp_pair_ci(std::pair<int,cinterval> p1, std::pair<int,cinterval> p2) {
00055   return p1.first < p2.first;
00056 }
00057 
00059 
00071 class scimatrix {
00072 
00073   private:
00074     std::vector<int> p;
00075     std::vector<int> ind;
00076     std::vector<cinterval> x;
00077     int m;
00078     int n;
00079     int lb1,ub1,lb2,ub2;
00080 
00081   public:
00082 
00084     std::vector<int>& column_pointers() {
00085       return p;
00086     }
00087 
00089     std::vector<int>& row_indices() {
00090       return ind;
00091     }
00092 
00094     std::vector<cinterval>& values() {
00095       return x;
00096     }
00097 
00099     const std::vector<int>& column_pointers() const {
00100       return p;
00101     }
00102 
00104     const std::vector<int>& row_indices() const {
00105       return ind;
00106     }
00107 
00109     const std::vector<cinterval>& values() const {
00110       return x;
00111     }
00112 
00114     scimatrix() {
00115       p.push_back(0);
00116       m = n = 0;
00117       lb1 = lb2 = ub1 = ub2 = 0;
00118     }
00119 
00121     scimatrix(const int r, const int c) : m(r),n(c),lb1(1),ub1(r),lb2(1),ub2(c) {
00122       p = std::vector<int>((n>0) ? n+1 : 1, 0);
00123       ind.reserve(2*(m+n));
00124       x.reserve(2*(m+n));
00125 
00126       p[0] = 0;
00127     }
00128 
00130     scimatrix(const int r, const int c, const int e) : m(r),n(c),lb1(1),ub1(r),lb2(1),ub2(c) {
00131       p = std::vector<int>((n>0) ? n+1 : 1, 0);
00132       ind.reserve(e);
00133       x.reserve(e);
00134 
00135       p[0] = 0;
00136     }
00137 
00139 
00145     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) {
00146       if(t == triplet) {
00147          this->m = m;
00148          this->n = n;
00149          p = std::vector<int>(n+1,0);
00150          ind.reserve(nnz);
00151          x.reserve(nnz);
00152          lb1 = lb2 = 1;
00153          ub1 = m; ub2 = n;
00154 
00155          std::vector<triplet_store<cinterval> > work;
00156          work.reserve(nnz);
00157 
00158          for(int k=0 ; k<nnz ; k++) {
00159            work.push_back(triplet_store<cinterval>(rows[Lb(rows)+k],cols[Lb(cols)+k],values[Lb(values)+k]));
00160          }
00161 
00162          sort(work.begin(), work.end());
00163 
00164          int i=0;
00165 
00166          for(int j=0 ; j<n ; j++) {        
00167 
00168            while((unsigned int)i < work.size() && work[i].col == j ) {
00169                ind.push_back(work[i].row);
00170                x.push_back(work[i].val);
00171                i++;
00172            }
00173 
00174            p[j+1] = i;
00175          }
00176          
00177       } else if(t == compressed_row) {
00178 
00179          this->m = m;
00180          this->n = n;
00181          p = std::vector<int>(n+1,0);
00182          ind.reserve(nnz);
00183          x.reserve(nnz);
00184          lb1 = lb2 = 1;
00185          ub1 = m; ub2 = n;
00186 
00187          for(int i=0 ; i<n+1 ; i++)
00188            p[i] = rows[Lb(rows)+i];
00189 
00190          std::vector<triplet_store<cinterval> > work;
00191          work.reserve(nnz);
00192 
00193          for(int j=0 ; j<n ; j++) {
00194            for(int k=p[j] ; k<p[j+1] ; k++) {
00195              work.push_back(triplet_store<cinterval>(j,cols[Lb(cols)+k],values[Lb(values)+k]));
00196            }
00197          }
00198 
00199          sort(work.begin(), work.end());
00200 
00201          int i=0;
00202 
00203          for(int j=0 ; j<n ; j++) {        
00204 
00205            while((unsigned int)i < work.size() && work[i].col == j ) {
00206                ind.push_back(work[i].row);
00207                x.push_back(work[i].val);
00208                i++;
00209            }
00210 
00211            p[j+1] = i;
00212          }
00213     
00214       } else if(t == compressed_column) {
00215          this->m = m;
00216          this->n = n;
00217          p = std::vector<int>(n+1,0);
00218          ind.reserve(nnz);
00219          x.reserve(nnz);
00220          lb1 = lb2 = 1;
00221          ub1 = m; ub2 = n;
00222 
00223          for(int i=0 ; i<n+1 ; i++)
00224            p[i] = rows[Lb(rows)+i];
00225 
00226          std::vector<std::pair<int,cinterval> > work;
00227          work.reserve(n);
00228 
00229          for(int j=0 ; j<n ; j++) {
00230            work.clear();
00231 
00232            for(int k=p[j] ; k<p[j+1] ; k++) {
00233              work.push_back(std::make_pair(cols[Lb(cols)+k],values[Lb(values)+k]));
00234            }
00235 
00236            std::sort(work.begin(),work.end(),comp_pair_ci);
00237 
00238            for(unsigned int i=0 ; i<work.size() ; i++) {
00239              ind.push_back(work[i].first);
00240              x.push_back(work[i].second);
00241            }
00242          }
00243 
00244       }
00245 
00246     }
00247 
00249 
00256     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) {
00257       if(t == triplet) {
00258          this->m = m;
00259          this->n = n;
00260          p = std::vector<int>(n+1,0);
00261          ind.reserve(nnz);
00262          x.reserve(nnz);
00263          lb1 = lb2 = 1;
00264          ub1 = m; ub2 = n;
00265 
00266          std::vector<triplet_store<cinterval> > work;
00267          work.reserve(nnz);
00268 
00269          for(int k=0 ; k<nnz ; k++) {
00270            work.push_back(triplet_store<cinterval>(rows[k],cols[k],values[k]));
00271          }
00272 
00273          sort(work.begin(), work.end());
00274 
00275          int i=0;
00276 
00277          for(int j=0 ; j<n ; j++) {        
00278 
00279            while((unsigned int)i < work.size() && work[i].col == j ) {
00280                ind.push_back(work[i].row);
00281                x.push_back(work[i].val);
00282                i++;
00283            }
00284 
00285            p[j+1] = i;
00286          }
00287          
00288       } else if(t == compressed_row) {
00289 
00290          this->m = m;
00291          this->n = n;
00292          p = std::vector<int>(n+1,0);
00293          ind.reserve(nnz);
00294          x.reserve(nnz);
00295          lb1 = lb2 = 1;
00296          ub1 = m; ub2 = n;
00297 
00298          for(int i=0 ; i<n+1 ; i++)
00299            p[i] = rows[i];
00300 
00301          std::vector<triplet_store<cinterval> > work;
00302          work.reserve(nnz);
00303 
00304          for(int j=0 ; j<n ; j++) {
00305            for(int k=p[j] ; k<p[j+1] ; k++) {
00306              work.push_back(triplet_store<cinterval>(j,cols[k],values[k]));
00307            }
00308          }
00309 
00310          sort(work.begin(), work.end());
00311 
00312          int i=0;
00313 
00314          for(int j=0 ; j<n ; j++) {        
00315 
00316            while((unsigned int)i < work.size() && work[i].col == j ) {
00317                ind.push_back(work[i].row);
00318                x.push_back(work[i].val);
00319                i++;
00320            }
00321 
00322            p[j+1] = i;
00323          }
00324     
00325       } else if(t == compressed_column) {
00326          this->m = m;
00327          this->n = n;
00328          p = std::vector<int>(n+1,0);
00329          ind.reserve(nnz);
00330          x.reserve(nnz);
00331          lb1 = lb2 = 1;
00332          ub1 = m; ub2 = n;
00333 
00334          for(int i=0 ; i<n+1 ; i++)
00335            p[i] = rows[i];
00336 
00337          std::vector<std::pair<int,cinterval> > work;
00338          work.reserve(n);
00339 
00340          for(int j=0 ; j<n ; j++) {
00341            work.clear();
00342 
00343            for(int k=p[j] ; k<p[j+1] ; k++) {
00344              work.push_back(std::make_pair(cols[k],values[k]));
00345            }
00346 
00347            std::sort(work.begin(),work.end(),comp_pair_ci);
00348 
00349            for(unsigned int i=0 ; i<work.size() ; i++) {
00350              ind.push_back(work[i].first);
00351              x.push_back(work[i].second);
00352            }
00353          }
00354 
00355       }
00356 
00357     }
00358 
00360     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) {
00361       x.reserve(A.get_nnz());
00362       for(unsigned int i=0 ; i<A.x.size() ; i++)
00363         x.push_back(cinterval(A.x[i]));
00364     }
00365 
00367     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) {
00368       x.reserve(A.get_nnz());
00369       for(unsigned int i=0 ; i<A.x.size() ; i++)
00370         x.push_back(cinterval(A.x[i]));
00371     }
00372 
00374     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) {
00375       x.reserve(A.get_nnz());
00376       for(unsigned int i=0 ; i<A.x.size() ; i++)
00377         x.push_back(cinterval(A.x[i]));
00378     }
00379 
00381     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)) {
00382       p = std::vector<int>((n>0) ? n+1 : 1, 0);
00383       ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00384       x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00385 
00386       p[0] = 0;
00387       int nnz = 0;
00388 
00389       for(int j=0 ; j<n ; j++) {
00390         for(int i=0 ; i<m ; i++) {
00391           if(A[i+lb1][j+lb2] != 0.0) {
00392              ind.push_back(i);
00393              x.push_back(cinterval(A[i+lb1][j+lb2]));
00394              nnz++;
00395           }
00396         }
00397           
00398         p[j+1] = nnz;
00399       }
00400 
00401     }
00402 
00404     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)) {
00405       p = std::vector<int>((n>0) ? n+1 : 1, 0);
00406       ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00407       x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00408 
00409       p[0] = 0;
00410       int nnz = 0;
00411 
00412       for(int j=0 ; j<n ; j++) {
00413         for(int i=0 ; i<m ; i++) {
00414           if(A[i+lb1][j+lb2] != 0.0) {
00415              ind.push_back(i);
00416              x.push_back(cinterval(A[i+lb1][j+lb2]));
00417              nnz++;
00418           }
00419         }
00420           
00421         p[j+1] = nnz;
00422       }
00423 
00424     }
00425 
00427     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)) {
00428       p = std::vector<int>((n>0) ? n+1 : 1, 0);
00429       ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00430       x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00431 
00432       p[0] = 0;
00433       int nnz = 0;
00434 
00435       for(int j=0 ; j<n ; j++) {
00436         for(int i=0 ; i<m ; i++) {
00437           if(A[i+lb1][j+lb2] != 0.0) {
00438              ind.push_back(i);
00439              x.push_back(cinterval(A[i+lb1][j+lb2]));
00440              nnz++;
00441           }
00442         }
00443           
00444         p[j+1] = nnz;
00445       }
00446 
00447     }
00448 
00450     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)) {
00451       p = std::vector<int>((n>0) ? n+1 : 1, 0);
00452       ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00453       x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
00454 
00455       p[0] = 0;
00456       int nnz = 0;
00457 
00458       for(int j=0 ; j<n ; j++) {
00459         for(int i=0 ; i<m ; i++) {
00460           if(A[i+lb1][j+lb2] != 0.0) {
00461              ind.push_back(i);
00462              x.push_back(A[i+lb1][j+lb2]);
00463              nnz++;
00464           }
00465         }
00466           
00467         p[j+1] = nnz;
00468       }
00469 
00470     }
00471 
00473 
00476     scimatrix(const int ms, const int ns, const cimatrix& A) : m(ms), n(ns), lb1(1), ub1(ms), lb2(1), ub2(ns)  {
00477       //Banded matrix constructor
00478       int nnz = RowLen(A)*ColLen(A);
00479       p = std::vector<int>((n>0) ? n+1 : 1, 0);
00480       ind.reserve(nnz);
00481       x.reserve(nnz);
00482 
00483       std::vector<triplet_store<cinterval> > work;
00484       work.reserve(nnz);
00485 
00486       
00487       for(int i=0 ; i<ColLen(A) ; i++) {
00488         for(int j=Lb(A,2) ; j<=Ub(A,2) ; j++) {
00489           if(i+j >=0  &&  i+j < n) {
00490             work.push_back(triplet_store<cinterval>(i,i+j,A[i+Lb(A,1)][j]));
00491           }
00492         }
00493       }
00494 
00495       sort(work.begin(), work.end());
00496 
00497       int i=0;
00498 
00499       for(int j=0 ; j<n ; j++) {        
00500 
00501         while((unsigned int)i < work.size() && work[i].col == j ) {
00502           ind.push_back(work[i].row);
00503           x.push_back(work[i].val);
00504           i++;
00505         }
00506 
00507         p[j+1] = i;
00508       }
00509 
00510     }
00511 
00513     scimatrix(const srmatrix_slice&);
00515     scimatrix(const scmatrix_slice&);
00517     scimatrix(const simatrix_slice&);
00519     scimatrix(const scimatrix_slice&);
00520 
00522     void full(cimatrix& A) const {
00523        A = cimatrix(lb1,ub1,lb2,ub2);
00524        A = 0.0;
00525        for(int j=0 ; j<n ; j++) {
00526           for(int k=p[j] ; k<p[j+1] ; k++) {
00527              A[ind[k]+lb1][j+lb2] = x[k];
00528           }
00529        }
00530     }
00531 
00533 
00537     void dropzeros() {
00538       std::vector<int> pnew(n+1,0);
00539       std::vector<int> indnew;
00540       std::vector<cinterval> xnew;
00541       int nnznew = 0;
00542 
00543       for(int j=0 ; j<n ; j++) {
00544         for(int k=p[j] ; k<p[j+1] ; k++) {
00545           if(x[k] != 0.0) {
00546             xnew.push_back(x[k]);
00547             indnew.push_back(ind[k]);
00548             nnznew++;
00549           }
00550         }
00551         pnew[j+1] = nnznew;
00552       }
00553 
00554       p = pnew;
00555       ind = indnew;
00556       x = xnew;
00557     }
00558 
00559 
00561     scimatrix& operator=(const real& A) {
00562       return sp_ms_assign<scimatrix,real,cinterval>(*this,A);
00563     }
00564 
00566     scimatrix& operator=(const interval& A) {
00567       return sp_ms_assign<scimatrix,interval,cinterval>(*this,A);
00568     }
00569 
00571     scimatrix& operator=(const complex& A) {
00572       return sp_ms_assign<scimatrix,complex,cinterval>(*this,A);
00573     }
00574 
00576     scimatrix& operator=(const cinterval& A) {
00577       return sp_ms_assign<scimatrix,cinterval,cinterval>(*this,A);
00578     }
00579 
00581     scimatrix& operator=(const rmatrix& A) {
00582       return spf_mm_assign<scimatrix,rmatrix,cinterval>(*this,A);
00583     }
00584 
00586     scimatrix& operator=(const cmatrix& A) {
00587       return spf_mm_assign<scimatrix,cmatrix,cinterval>(*this,A);
00588     }
00589 
00591     scimatrix& operator=(const imatrix& A) {
00592       return spf_mm_assign<scimatrix,imatrix,cinterval>(*this,A);
00593     }
00594 
00596     scimatrix& operator=(const cimatrix& A) {
00597       return spf_mm_assign<scimatrix,cimatrix,cinterval>(*this,A);
00598     }
00599 
00601     scimatrix& operator=(const rmatrix_slice& A) {
00602       return spf_mm_assign<scimatrix,rmatrix_slice,cinterval>(*this,A);
00603     }
00604 
00606     scimatrix& operator=(const cmatrix_slice& A) {
00607       return spf_mm_assign<scimatrix,cmatrix_slice,cinterval>(*this,A);
00608     }
00609 
00611     scimatrix& operator=(const imatrix_slice& A) {
00612       return spf_mm_assign<scimatrix,imatrix_slice,cinterval>(*this,A);
00613     }
00614 
00616     scimatrix& operator=(const cimatrix_slice& A) {
00617       return spf_mm_assign<scimatrix,cimatrix_slice,cinterval>(*this,A);
00618     }
00619 
00621     scimatrix& operator=(const srmatrix& A) {
00622       m = A.m;
00623       n = A.n;
00624       p = A.p;
00625       ind = A.ind;
00626       x.clear();
00627       x.reserve(A.get_nnz());
00628       for(unsigned int i=0 ; i<A.x.size() ; i++)
00629         x.push_back(cinterval(A.x[i]));
00630       return *this;
00631     }
00632 
00634     scimatrix& operator=(const scmatrix& A) {
00635       m = A.m;
00636       n = A.n;
00637       p = A.p;
00638       ind = A.ind;
00639       x.clear();
00640       x.reserve(A.get_nnz());
00641       for(unsigned int i=0 ; i<A.x.size() ; i++)
00642         x.push_back(cinterval(A.x[i]));
00643       return *this;
00644     }
00645 
00647     scimatrix& operator=(const simatrix& A) {
00648       m = A.m;
00649       n = A.n;
00650       p = A.p;
00651       ind = A.ind;
00652       x.clear();
00653       x.reserve(A.get_nnz());
00654       for(unsigned int i=0 ; i<A.x.size() ; i++)
00655         x.push_back(cinterval(A.x[i]));
00656       return *this;
00657     }
00658 
00659     /* scimatrix& operator=(const scimatrix& A) {
00660       p = A.p;
00661       ind = A.ind;
00662       x = A.x;
00663       return *this;
00664     } */
00665 
00667     scimatrix& operator=(const srmatrix_slice&);
00669     scimatrix& operator=(const scmatrix_slice&);
00671     scimatrix& operator=(const simatrix_slice&);
00673     scimatrix& operator=(const scimatrix_slice&);
00674 
00676 
00682     const cinterval operator()(int i, int j) const {
00683 #if(CXSC_INDEX_CHECK)
00684       if(i<lb1 || i>ub1 || j<lb2 || j>ub2)
00685         cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix::operator()(int, int)"));
00686 #endif
00687       cinterval r(0.0);
00688       for(int k=p[j-lb2] ; k<p[j-lb2+1] && ind[k]<=i-lb1 ; k++) {
00689         if(ind[k] == i-lb1)  r = x[k];
00690       }
00691       return r;
00692     }
00693 
00695 
00703     cinterval& element(int i, int j) {
00704 #if(CXSC_INDEX_CHECK)
00705       if(i<lb1 || i>ub1 || j<lb2 || j>ub2)
00706         cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix::element(int, int)"));
00707 #endif
00708       int k;
00709       for(k=p[j-lb2] ; k<p[j-lb2+1] && ind[k]<=i-lb1 ; k++) {
00710         if(ind[k] == i-lb1)  return x[k];
00711       }
00712 
00713       //Nicht gefunden, Element muss angelegt werden, da Schreibzugriff moeglich
00714       std::vector<int>::iterator ind_it = ind.begin() + k;
00715       std::vector<cinterval>::iterator x_it  = x.begin() + k;
00716       ind.insert(ind_it, i-lb1);
00717       x_it = x.insert(x_it, cinterval(0.0));
00718       for(k=j-lb2+1 ; k<(int)p.size() ; k++)
00719         p[k]++;
00720 
00721       return *x_it;
00722     }
00723 
00725     scimatrix_subv operator[](const cxscmatrix_column&);
00727     scimatrix_subv operator[](const int);
00729     const scimatrix_subv operator[](const cxscmatrix_column&) const;
00731     const scimatrix_subv operator[](const int) const;
00732 
00734     scimatrix_slice operator()(const int, const int , const int, const int);
00736     const scimatrix_slice operator()(const int, const int , const int, const int) const;
00737 
00739     scimatrix operator()(const intvector& pervec, const intvector& q) {
00740       scimatrix A(m,n,get_nnz());
00741       intvector per = perminv(pervec);
00742 
00743       int nnz=0;
00744       for(int k=0 ; k<n ; k++) {
00745         A.p[k] = nnz;
00746 
00747         std::map<int,cinterval> work;
00748         for(int j=p[q[Lb(q)+k]] ; j<p[q[Lb(q)+k]+1] ; j++) 
00749            work.insert(std::make_pair(per[Lb(per)+ind[j]], x[j]));
00750         
00751         for(std::map<int,cinterval>::iterator it = work.begin() ; it != work.end() ; it++) {
00752            A.ind.push_back(it->first);
00753            A.x.push_back(it->second);
00754         }
00755 
00756         nnz += work.size();
00757  
00758       }
00759 
00760       A.p[n] = nnz;
00761 
00762       return A;
00763     }
00764 
00766     scimatrix operator()(const intvector& pervec) {
00767       scimatrix A(m,n,get_nnz());
00768       intvector per = perminv(pervec);
00769 
00770       for(int k=0 ; k<n ; k++) {
00771         A.p[k] = p[k];
00772 
00773         std::map<int,cinterval> work;
00774         for(int j=p[k] ; j<p[k+1] ; j++) 
00775            work.insert(std::make_pair(per[Lb(per)+ind[j]], x[j]));
00776         
00777         for(std::map<int,cinterval>::iterator it = work.begin() ; it != work.end() ; it++) {
00778            A.ind.push_back(it->first);
00779            A.x.push_back(it->second);
00780         }
00781  
00782       }
00783 
00784       A.p[n] = p[n];
00785 
00786       return A;
00787     }
00788 
00790     scimatrix operator()(const intmatrix& P, const intmatrix& Q) {
00791       intvector p = permvec(P);
00792       intvector q = perminv(permvec(Q));
00793       return (*this)(p,q);
00794     }
00795 
00797    scimatrix operator()(const intmatrix& P) {
00798       intvector p = permvec(P);
00799       return (*this)(p);
00800     }
00801 
00803     real density() const {
00804       return p[n]/((double)m*n);
00805     }
00806 
00808     int get_nnz() const {
00809       return p[n];
00810     }
00811 
00813     scimatrix& operator+=(const rmatrix& B) {
00814       return spf_mm_addassign<scimatrix,rmatrix,cimatrix>(*this,B);
00815     }
00816 
00818     scimatrix& operator+=(const cmatrix& B) {
00819       return spf_mm_addassign<scimatrix,cmatrix,cimatrix>(*this,B);
00820     }
00821 
00823     scimatrix& operator+=(const imatrix& B) {
00824       return spf_mm_addassign<scimatrix,imatrix,cimatrix>(*this,B);
00825     }
00826 
00828     scimatrix& operator+=(const cimatrix& B) {
00829       return spf_mm_addassign<scimatrix,cimatrix,cimatrix>(*this,B);
00830     }
00831 
00833     scimatrix& operator+=(const rmatrix_slice& B) {
00834       return spf_mm_addassign<scimatrix,rmatrix_slice,cimatrix>(*this,B);
00835     }
00836 
00838     scimatrix& operator+=(const cmatrix_slice& B) {
00839       return spf_mm_addassign<scimatrix,cmatrix_slice,cimatrix>(*this,B);
00840     }
00841 
00843     scimatrix& operator+=(const imatrix_slice& B) {
00844       return spf_mm_addassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
00845     }
00846 
00848     scimatrix& operator+=(const cimatrix_slice& B) {
00849       return spf_mm_addassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
00850     }
00851 
00853     scimatrix& operator+=(const srmatrix& B) {
00854       return spsp_mm_addassign<scimatrix,srmatrix,cinterval>(*this,B);
00855     }
00856 
00858     scimatrix& operator+=(const scmatrix& B) {
00859       return spsp_mm_addassign<scimatrix,scmatrix,cinterval>(*this,B);
00860     }
00861 
00863     scimatrix& operator+=(const simatrix& B) {
00864       return spsp_mm_addassign<scimatrix,simatrix,cinterval>(*this,B);
00865     }
00866 
00868     scimatrix& operator+=(const scimatrix& B) {
00869       return spsp_mm_addassign<scimatrix,scimatrix,cinterval>(*this,B);
00870     }
00871 
00873     scimatrix& operator-=(const rmatrix& B) {
00874       return spf_mm_subassign<scimatrix,rmatrix,cimatrix>(*this,B);
00875     }
00876 
00878     scimatrix& operator-=(const cmatrix& B) {
00879       return spf_mm_subassign<scimatrix,cmatrix,cimatrix>(*this,B);
00880     }
00881 
00883     scimatrix& operator-=(const imatrix& B) {
00884       return spf_mm_subassign<scimatrix,imatrix,cimatrix>(*this,B);
00885     }
00886 
00888     scimatrix& operator-=(const cimatrix& B) {
00889       return spf_mm_subassign<scimatrix,cimatrix,cimatrix>(*this,B);
00890     }
00891 
00893     scimatrix& operator-=(const rmatrix_slice& B) {
00894       return spf_mm_subassign<scimatrix,rmatrix_slice,cimatrix>(*this,B);
00895     }
00896 
00898     scimatrix& operator-=(const cmatrix_slice& B) {
00899       return spf_mm_subassign<scimatrix,cmatrix_slice,cimatrix>(*this,B);
00900     }
00901 
00903     scimatrix& operator-=(const imatrix_slice& B) {
00904       return spf_mm_subassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
00905     }
00906 
00908     scimatrix& operator-=(const cimatrix_slice& B) {
00909       return spf_mm_subassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
00910     }
00911 
00913     scimatrix& operator-=(const srmatrix& B) {
00914       return spsp_mm_subassign<scimatrix,srmatrix,cinterval>(*this,B);
00915     }
00916 
00918     scimatrix& operator-=(const scmatrix& B) {
00919       return spsp_mm_subassign<scimatrix,scmatrix,cinterval>(*this,B);
00920     }
00921 
00923     scimatrix& operator-=(const simatrix& B) {
00924       return spsp_mm_subassign<scimatrix,simatrix,cinterval>(*this,B);
00925     }
00926 
00928     scimatrix& operator-=(const scimatrix& B) {
00929       return spsp_mm_subassign<scimatrix,scimatrix,cinterval>(*this,B);
00930     }
00931 
00933     scimatrix& operator|=(const rmatrix& B) {
00934       return spf_mm_hullassign<scimatrix,rmatrix,cimatrix>(*this,B);
00935     }
00936 
00938     scimatrix& operator|=(const cmatrix& B) {
00939       return spf_mm_hullassign<scimatrix,cmatrix,cimatrix>(*this,B);
00940     }
00941 
00943     scimatrix& operator|=(const imatrix& B) {
00944       return spf_mm_hullassign<scimatrix,imatrix,cimatrix>(*this,B);
00945     }
00946 
00948     scimatrix& operator|=(const cimatrix& B) {
00949       return spf_mm_hullassign<scimatrix,cimatrix,cimatrix>(*this,B);
00950     }
00951 
00953     scimatrix& operator|=(const rmatrix_slice& B) {
00954       return spf_mm_hullassign<scimatrix,rmatrix_slice,cimatrix>(*this,B);
00955     }
00956 
00958     scimatrix& operator|=(const cmatrix_slice& B) {
00959       return spf_mm_hullassign<scimatrix,cmatrix_slice,cimatrix>(*this,B);
00960     }
00961 
00963     scimatrix& operator|=(const imatrix_slice& B) {
00964       return spf_mm_hullassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
00965     }
00966 
00968     scimatrix& operator|=(const cimatrix_slice& B) {
00969       return spf_mm_hullassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
00970     }
00971 
00973     scimatrix& operator|=(const srmatrix& B) {
00974       return spsp_mm_hullassign<scimatrix,srmatrix,cinterval>(*this,B);
00975     }
00976 
00978     scimatrix& operator|=(const scmatrix& B) {
00979       return spsp_mm_hullassign<scimatrix,scmatrix,cinterval>(*this,B);
00980     }
00981 
00983     scimatrix& operator|=(const simatrix& B) {
00984       return spsp_mm_hullassign<scimatrix,simatrix,cinterval>(*this,B);
00985     }
00986 
00988     scimatrix& operator|=(const scimatrix& B) {
00989       return spsp_mm_hullassign<scimatrix,scimatrix,cinterval>(*this,B);
00990     }
00991 
00993     scimatrix& operator&=(const imatrix& B) {
00994       return spf_mm_intersectassign<scimatrix,imatrix,cimatrix>(*this,B);
00995     }
00996 
00998     scimatrix& operator&=(const cimatrix& B) {
00999       return spf_mm_intersectassign<scimatrix,cimatrix,cimatrix>(*this,B);
01000     }
01001 
01003     scimatrix& operator&=(const imatrix_slice& B) {
01004       return spf_mm_intersectassign<scimatrix,imatrix_slice,cimatrix>(*this,B);
01005     }
01006 
01008     scimatrix& operator&=(const cimatrix_slice& B) {
01009       return spf_mm_intersectassign<scimatrix,cimatrix_slice,cimatrix>(*this,B);
01010     }
01011 
01013     scimatrix& operator&=(const simatrix& B) {
01014       return spsp_mm_intersectassign<scimatrix,simatrix,cinterval>(*this,B);
01015     }
01016 
01018     scimatrix& operator&=(const scimatrix& B) {
01019       return spsp_mm_intersectassign<scimatrix,scimatrix,cinterval>(*this,B);
01020     }
01021 
01023     scimatrix& operator*=(const cmatrix& B) {
01024       return spf_mm_multassign<scimatrix,cmatrix,sparse_cidot,cimatrix>(*this,B);
01025     }
01026 
01028     scimatrix& operator*=(const rmatrix& B) {
01029       return spf_mm_multassign<scimatrix,rmatrix,sparse_cidot,cimatrix>(*this,B);
01030     }
01031 
01033     scimatrix& operator*=(const imatrix& B) {
01034       return spf_mm_multassign<scimatrix,imatrix,sparse_cidot,cimatrix>(*this,B);
01035     }
01036 
01038     scimatrix& operator*=(const cimatrix& B) {
01039       return spf_mm_multassign<scimatrix,cimatrix,sparse_cidot,cimatrix>(*this,B);
01040     }
01041 
01043     scimatrix& operator*=(const rmatrix_slice& B) {
01044       return spf_mm_multassign<scimatrix,rmatrix_slice,sparse_cidot,cimatrix>(*this,B);
01045     }
01046 
01048     scimatrix& operator*=(const cmatrix_slice& B) {
01049       return spf_mm_multassign<scimatrix,cmatrix_slice,sparse_cidot,cimatrix>(*this,B);
01050     }
01051 
01053     scimatrix& operator*=(const imatrix_slice& B) {
01054       return spf_mm_multassign<scimatrix,imatrix_slice,sparse_cidot,cimatrix>(*this,B);
01055     }
01056 
01058     scimatrix& operator*=(const cimatrix_slice& B) {
01059       return spf_mm_multassign<scimatrix,cimatrix_slice,sparse_cidot,cimatrix>(*this,B);
01060     }
01061 
01063     scimatrix& operator*=(const srmatrix& B) {
01064       return spsp_mm_multassign<scimatrix,srmatrix,sparse_cidot,cinterval>(*this,B);
01065     }
01066 
01068     scimatrix& operator*=(const scmatrix& B) {
01069       return spsp_mm_multassign<scimatrix,scmatrix,sparse_cidot,cinterval>(*this,B);
01070     }
01071 
01073     scimatrix& operator*=(const simatrix& B) {
01074       return spsp_mm_multassign<scimatrix,simatrix,sparse_cidot,cinterval>(*this,B);
01075     }
01076 
01078     scimatrix& operator*=(const scimatrix& B) {
01079       return spsp_mm_multassign<scimatrix,scimatrix,sparse_cidot,cinterval>(*this,B);
01080     }
01081 
01083     scimatrix& operator*=(const real& r) {
01084       return sp_ms_multassign(*this,r);
01085     }
01086 
01088     scimatrix& operator*=(const complex& r) {
01089       return sp_ms_multassign(*this,r);
01090     }
01091 
01093     scimatrix& operator*=(const interval& r) {
01094       return sp_ms_multassign(*this,r);
01095     }
01096 
01098     scimatrix& operator*=(const cinterval& r) {
01099       return sp_ms_multassign(*this,r);
01100     }
01101 
01103     scimatrix& operator/=(const real& r) {
01104       return sp_ms_divassign(*this,r);
01105     }
01106 
01108     scimatrix& operator/=(const complex& r) {
01109       return sp_ms_divassign(*this,r);
01110     }
01111 
01113     scimatrix& operator/=(const interval& r) {
01114       return sp_ms_divassign(*this,r);
01115     }
01116 
01118     scimatrix& operator/=(const cinterval& r) {
01119       return sp_ms_divassign(*this,r);
01120     }
01121 
01122     friend void SetLb(scimatrix&, const int, const int);
01123     friend void SetUb(scimatrix&, const int, const int);
01124     friend int Lb(const scimatrix&, int);
01125     friend int Ub(const scimatrix&, int);
01126     friend int RowLen(const scimatrix&);
01127     friend int ColLen(const scimatrix&);
01128     friend simatrix Re(const scimatrix&);
01129     friend simatrix Im(const scimatrix&);
01130     friend scmatrix Sup(const scimatrix&);
01131     friend scmatrix Inf(const scimatrix&);
01132     friend srmatrix InfRe(const scimatrix&);
01133     friend srmatrix InfIm(const scimatrix&);
01134     friend srmatrix SupRe(const scimatrix&);
01135     friend srmatrix SupIm(const scimatrix&);
01136     friend scimatrix conj(const scimatrix&);
01137     friend simatrix abs(const scimatrix&);
01138     friend scmatrix mid(const scimatrix&);
01139     friend scmatrix diam(const scimatrix&);
01140 
01141     friend srmatrix CompMat(const scimatrix&);
01142     friend scimatrix transp(const scimatrix&);
01143     friend scimatrix Id(const scimatrix&);
01144 
01145     friend std::istream& operator>>(std::istream&, scimatrix_slice&);
01146     friend std::istream& operator>>(std::istream&, scimatrix_subv&);
01147 
01148     friend class srmatrix_slice;
01149     friend class srmatrix_subv;
01150     friend class srvector;
01151     friend class scmatrix_slice;
01152     friend class scmatrix_subv;
01153     friend class scvector;
01154     friend class simatrix_slice;
01155     friend class simatrix_subv;
01156     friend class sivector;
01157     friend class scimatrix_slice;
01158     friend class scimatrix_subv;
01159     friend class scivector;
01160     friend class cimatrix;
01161 
01162 #include "matrix_friend_declarations.inl"
01163 };
01164 
01165 inline cimatrix::cimatrix(const srmatrix& A) {
01166   dat = new cinterval[A.m*A.n];
01167   lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
01168   xsize = A.n;
01169   ysize = A.m;
01170   *this = 0.0;
01171   for(int j=0 ; j<A.n ; j++) {
01172      for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
01173         dat[A.ind[k]*A.n+j] = A.x[k];
01174      }
01175   }
01176 }
01177 
01178 inline cimatrix::cimatrix(const simatrix& A) {
01179   dat = new cinterval[A.m*A.n];
01180   lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
01181   xsize = A.n;
01182   ysize = A.m;
01183   *this = 0.0;
01184   for(int j=0 ; j<A.n ; j++) {
01185      for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
01186         dat[A.ind[k]*A.n+j] = A.x[k];
01187      }
01188   }
01189 }
01190 
01191 inline cimatrix::cimatrix(const scmatrix& A) {
01192   dat = new cinterval[A.m*A.n];
01193   lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
01194   xsize = A.n;
01195   ysize = A.m;
01196   *this = 0.0;
01197   for(int j=0 ; j<A.n ; j++) {
01198      for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
01199         dat[A.ind[k]*A.n+j] = A.x[k];
01200      }
01201   }
01202 }
01203 
01204 inline cimatrix::cimatrix(const scimatrix& A) {
01205   dat = new cinterval[A.m*A.n];
01206   lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
01207   xsize = A.n;
01208   ysize = A.m;
01209   *this = 0.0;
01210   for(int j=0 ; j<A.n ; j++) {
01211      for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
01212         dat[A.ind[k]*A.n+j] = A.x[k];
01213      }
01214   }
01215 }
01216 
01218 inline scimatrix Id(const scimatrix& A) {
01219   scimatrix I(A.m, A.n, (A.m>A.n) ? A.m : A.n);
01220   I.lb1 = A.lb1; I.lb2 = A.lb2;
01221   I.ub1 = A.ub1; I.ub2 = A.ub2;
01222 
01223   if(A.m < A.n) {
01224     for(int i=0 ; i<A.m ; i++) {
01225       I.p[i+1] = I.p[i] + 1;
01226       I.ind.push_back(i);
01227       I.x.push_back(cinterval(1.0));
01228     }
01229   } else {
01230     for(int i=0 ; i<A.n ; i++) {
01231       I.p[i+1] = I.p[i] + 1;
01232       I.ind.push_back(i);
01233       I.x.push_back(cinterval(1.0));
01234     }
01235   }
01236 
01237   return I;
01238 }
01239 
01241 inline srmatrix CompMat(const scimatrix& A) {
01242   srmatrix res(A.m,A.n,A.get_nnz());
01243   res.lb1 = A.lb1;
01244   res.lb2 = A.lb2;
01245   res.ub1 = A.ub1;
01246   res.ub2 = A.ub2;
01247   res.p   = A.p;
01248   res.ind = A.ind;
01249   res.p[A.n] = A.p[A.n];
01250 
01251   for(int j=0 ; j<res.n ; j++) {
01252     for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
01253       if(A.ind[k] == j)
01254         res.x.push_back(Inf(abs(A.x[k])));
01255       else
01256         res.x.push_back(-Sup(abs(A.x[k])));
01257     }
01258   }
01259 
01260   res.dropzeros();
01261 
01262   return res; 
01263 }
01264 
01266 inline scimatrix transp(const scimatrix& A) {
01267   scimatrix B(A.n, A.m, A.get_nnz());
01268      
01269   //NIchtnullen pro Zeile bestimmen
01270   std::vector<int> w(A.m,0);
01271   for(unsigned int i=0 ; i<A.ind.size() ; i++) 
01272     w[A.ind[i]]++;
01273 
01274   //Spalten"pointer" setzen
01275   B.p.resize(A.m+1);
01276   B.p[0] = 0;
01277   for(unsigned int i=1 ; i<B.p.size() ; i++)
01278     B.p[i] = w[i-1] + B.p[i-1];
01279 
01280   //w vorbereiten
01281   w.insert(w.begin(), 0); 
01282   for(unsigned int i=1 ; i<w.size() ; i++) {
01283     w[i] += w[i-1];
01284   }
01285 
01286   //neuer zeilenindex und wert wird gesetzt
01287   int q;
01288   B.ind.resize(A.get_nnz());
01289   B.x.resize(A.get_nnz());
01290   for(int j=0 ; j<A.n ; j++) {
01291     for(int k=A.p[j] ; k<A.p[j+1] ; k++) {
01292       q = w[A.ind[k]]++;
01293       B.ind[q] = j;
01294       B.x[q] = A.x[k];
01295     }
01296   }
01297 
01298   return B;
01299 }
01300 
01302 
01306 inline void SetLb(scimatrix& A, const int i, const int j) {
01307   if(i==1) {
01308     A.lb1 = j;
01309     A.ub1 = j + A.m - 1;
01310   } else if(i==2) {
01311     A.lb2 = j;
01312     A.ub2 = j + A.n - 1;
01313   }
01314 }
01315 
01317 
01321 inline void SetUb(scimatrix& A, const int i, const int j) {
01322   if(i==1) {
01323     A.ub1 = j;
01324     A.lb1 = j - A.m + 1;
01325   } else if(i==2) {
01326     A.ub2 = j;
01327     A.lb2 = j - A.n + 1;
01328   }
01329 }
01330 
01332 
01335 inline int Lb(const scimatrix& A, int i) {
01336   if(i==1) 
01337     return A.lb1;
01338   else if(i==2)
01339     return A.lb2;
01340   else
01341     return 1;
01342 }
01343 
01345 
01348 inline int Ub(const scimatrix& A, int i) {
01349   if(i==1) 
01350     return A.ub1;
01351   else if(i==2)
01352     return A.ub2;
01353   else
01354     return 1;
01355 }
01356 
01358 inline int RowLen(const scimatrix& A) {
01359   return A.n;
01360 }
01361 
01363 inline int ColLen(const scimatrix& A) {
01364   return A.m;
01365 }
01366 
01368 inline void Resize(scimatrix& A) {
01369   sp_m_resize(A);
01370 }
01371 
01373 inline void Resize(scimatrix& A, const int m, const int n) {
01374   sp_m_resize(A,m,n);
01375 }
01376 
01378 inline void Resize(scimatrix& A, const int l1, const int u1, const int l2, const int u2) {
01379   sp_m_resize(A,l1,u1,l2,u2);
01380 }
01381 
01383 inline simatrix Re(const scimatrix& A) {
01384   simatrix res(A.m,A.n,A.get_nnz());
01385   res.lb1 = A.lb1;
01386   res.lb2 = A.lb2;
01387   res.ub1 = A.ub1;
01388   res.ub2 = A.ub2;
01389   res.p   = A.p;
01390   res.ind = A.ind;
01391 
01392   for(int i=0 ; i<res.get_nnz() ; i++)
01393     res.x.push_back(Re(A.x[i]));
01394 
01395   res.dropzeros();
01396 
01397   return res; 
01398 }
01399 
01401 inline simatrix Im(const scimatrix& A) {
01402   simatrix res(A.m,A.n,A.get_nnz());
01403   res.lb1 = A.lb1;
01404   res.lb2 = A.lb2;
01405   res.ub1 = A.ub1;
01406   res.ub2 = A.ub2;
01407   res.p   = A.p;
01408   res.ind = A.ind;
01409 
01410   for(int i=0 ; i<res.get_nnz() ; i++)
01411     res.x.push_back(Im(A.x[i]));
01412 
01413   res.dropzeros();
01414 
01415   return res; 
01416 }
01417 
01419 inline scmatrix Inf(const scimatrix& A) {
01420   scmatrix res(A.m,A.n,A.get_nnz());
01421   res.lb1 = A.lb1;
01422   res.lb2 = A.lb2;
01423   res.ub1 = A.ub1;
01424   res.ub2 = A.ub2;
01425   res.p   = A.p;
01426   res.ind = A.ind;
01427 
01428   for(int i=0 ; i<res.get_nnz() ; i++)
01429     res.x.push_back(Inf(A.x[i]));
01430 
01431   res.dropzeros();
01432 
01433   return res; 
01434 }
01435 
01437 inline scmatrix Sup(const scimatrix& A) {
01438   scmatrix res(A.m,A.n,A.get_nnz());
01439   res.lb1 = A.lb1;
01440   res.lb2 = A.lb2;
01441   res.ub1 = A.ub1;
01442   res.ub2 = A.ub2;
01443   res.p   = A.p;
01444   res.ind = A.ind;
01445 
01446   for(int i=0 ; i<res.get_nnz() ; i++)
01447     res.x.push_back(Sup(A.x[i]));
01448 
01449   res.dropzeros();
01450 
01451   return res; 
01452 }
01453 
01455 inline scimatrix conj(const scimatrix& A) {
01456   scimatrix res(A.m,A.n,A.get_nnz());
01457   res.lb1 = A.lb1;
01458   res.lb2 = A.lb2;
01459   res.ub1 = A.ub1;
01460   res.ub2 = A.ub2;
01461   res.p   = A.p;
01462   res.ind = A.ind;
01463 
01464   for(int i=0 ; i<res.get_nnz() ; i++)
01465     res.x.push_back(conj(A.x[i]));
01466 
01467   res.dropzeros();
01468 
01469   return res; 
01470 }
01471 
01473 inline simatrix abs(const scimatrix& A) {
01474   simatrix res(A.m,A.n,A.get_nnz());
01475   res.lb1 = A.lb1;
01476   res.lb2 = A.lb2;
01477   res.ub1 = A.ub1;
01478   res.ub2 = A.ub2;
01479   res.p   = A.p;
01480   res.ind = A.ind;
01481 
01482   for(int i=0 ; i<res.get_nnz() ; i++)
01483     res.x.push_back(abs(A.x[i]));
01484 
01485   res.dropzeros();
01486 
01487   return res; 
01488 }
01489 
01491 inline scmatrix mid(const scimatrix& A) {
01492   scmatrix res(A.m,A.n,A.get_nnz());
01493   res.lb1 = A.lb1;
01494   res.lb2 = A.lb2;
01495   res.ub1 = A.ub1;
01496   res.ub2 = A.ub2;
01497   res.p   = A.p;
01498   res.ind = A.ind;
01499 
01500   for(int i=0 ; i<res.get_nnz() ; i++)
01501     res.x.push_back(mid(A.x[i]));
01502 
01503   res.dropzeros();
01504 
01505   return res; 
01506 }
01507 
01509 inline scmatrix diam(const scimatrix& A) {
01510   scmatrix res(A.m,A.n,A.get_nnz());
01511   res.lb1 = A.lb1;
01512   res.lb2 = A.lb2;
01513   res.ub1 = A.ub1;
01514   res.ub2 = A.ub2;
01515   res.p   = A.p;
01516   res.ind = A.ind;
01517 
01518   for(int i=0 ; i<res.get_nnz() ; i++)
01519     res.x.push_back(diam(A.x[i]));
01520 
01521   res.dropzeros();
01522 
01523   return res; 
01524 }
01525 
01527 inline srmatrix InfRe(const scimatrix& A) {
01528   srmatrix res(A.m,A.n,A.get_nnz());
01529   res.lb1 = A.lb1;
01530   res.lb2 = A.lb2;
01531   res.ub1 = A.ub1;
01532   res.ub2 = A.ub2;
01533   res.p   = A.p;
01534   res.ind = A.ind;
01535 
01536   for(int i=0 ; i<res.get_nnz() ; i++)
01537     res.x.push_back(InfRe(A.x[i]));
01538 
01539   res.dropzeros();
01540 
01541   return res; 
01542 }
01543 
01545 inline srmatrix InfIm(const scimatrix& A) {
01546   srmatrix res(A.m,A.n,A.get_nnz());
01547   res.lb1 = A.lb1;
01548   res.lb2 = A.lb2;
01549   res.ub1 = A.ub1;
01550   res.ub2 = A.ub2;
01551   res.p   = A.p;
01552   res.ind = A.ind;
01553 
01554   for(int i=0 ; i<res.get_nnz() ; i++)
01555     res.x.push_back(InfIm(A.x[i]));
01556 
01557   res.dropzeros();
01558 
01559   return res; 
01560 }
01561 
01563 inline srmatrix SupRe(const scimatrix& A) {
01564   srmatrix res(A.m,A.n,A.get_nnz());
01565   res.lb1 = A.lb1;
01566   res.lb2 = A.lb2;
01567   res.ub1 = A.ub1;
01568   res.ub2 = A.ub2;
01569   res.p   = A.p;
01570   res.ind = A.ind;
01571 
01572   for(int i=0 ; i<res.get_nnz() ; i++)
01573     res.x.push_back(SupRe(A.x[i]));
01574 
01575   res.dropzeros();
01576 
01577   return res; 
01578 }
01579 
01581 inline srmatrix SupIm(const scimatrix& A) {
01582   srmatrix res(A.m,A.n,A.get_nnz());
01583   res.lb1 = A.lb1;
01584   res.lb2 = A.lb2;
01585   res.ub1 = A.ub1;
01586   res.ub2 = A.ub2;
01587   res.p   = A.p;
01588   res.ind = A.ind;
01589 
01590   for(int i=0 ; i<res.get_nnz() ; i++)
01591     res.x.push_back(SupIm(A.x[i]));
01592 
01593   res.dropzeros();
01594 
01595   return res; 
01596 }
01597 
01599 
01605 inline cimatrix operator*(const cimatrix& A, const srmatrix& B) {
01606   return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(A,B);
01607 }
01608 
01610 
01616 inline cimatrix operator*(const cimatrix& A, const scmatrix& B) {
01617   return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
01618 }
01619 
01621 
01627 inline cimatrix operator*(const cimatrix& A, const simatrix& B) {
01628   return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(A,B);
01629 }
01630 
01632 
01638 inline cimatrix operator*(const cimatrix& A, const scimatrix& B) {
01639   return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
01640 }
01641 
01643 
01649 inline cimatrix operator*(const rmatrix& A, const scimatrix& B) {
01650   return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
01651 }
01652 
01654 
01660 inline cimatrix operator*(const cmatrix& A, const scimatrix& B) {
01661   return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
01662 }
01663 
01665 
01671 inline cimatrix operator*(const imatrix& A, const scimatrix& B) {
01672   return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
01673 }
01674 
01676 
01682 inline cimatrix operator*(const cmatrix& A, const simatrix& B) {
01683   return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(A,B);
01684 }
01685 
01687 
01693 inline cimatrix operator*(const imatrix& A, const scmatrix& B) {
01694   return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
01695 }
01696 
01698 
01704 inline cimatrix operator*(const scimatrix& A, const rmatrix& B) {
01705   return spf_mm_mult<scimatrix,rmatrix,cimatrix,sparse_cidot>(A,B);
01706 }
01707 
01709 
01715 inline cimatrix operator*(const scimatrix& A, const cmatrix& B) {
01716   return spf_mm_mult<scimatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
01717 }
01718 
01720 
01726 inline cimatrix operator*(const scimatrix& A, const imatrix& B) {
01727   return spf_mm_mult<scimatrix,imatrix,cimatrix,sparse_cidot>(A,B);
01728 }
01729 
01731 
01737 inline cimatrix operator*(const scimatrix& A, const cimatrix& B) {
01738   return spf_mm_mult<scimatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
01739 }
01740 
01742 
01748 inline cimatrix operator*(const srmatrix& A, const cimatrix& B) {
01749   return spf_mm_mult<srmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
01750 }
01751 
01753 
01759 inline cimatrix operator*(const scmatrix& A, const cimatrix& B) {
01760   return spf_mm_mult<scmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
01761 }
01762 
01764 
01770 inline cimatrix operator*(const simatrix& A, const cimatrix& B) {
01771   return spf_mm_mult<simatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
01772 }
01773 
01775 
01781 inline cimatrix operator*(const scmatrix& A, const imatrix& B) {
01782   return spf_mm_mult<scmatrix,imatrix,cimatrix,sparse_cidot>(A,B);
01783 }
01784 
01786 
01792 inline cimatrix operator*(const simatrix& A, const cmatrix& B) {
01793   return spf_mm_mult<simatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
01794 }
01795 
01797 
01803 inline cimatrix operator*(const cimatrix_slice& A, const srmatrix& B) {
01804   return fsp_mm_mult<cimatrix_slice,srmatrix,cimatrix,sparse_cidot>(A,B);
01805 }
01806 
01808 
01814 inline cimatrix operator*(const cimatrix_slice& A, const scmatrix& B) {
01815   return fsp_mm_mult<cimatrix_slice,scmatrix,cimatrix,sparse_cidot>(A,B);
01816 }
01817 
01819 
01825 inline cimatrix operator*(const cimatrix_slice& A, const simatrix& B) {
01826   return fsp_mm_mult<cimatrix_slice,simatrix,cimatrix,sparse_cidot>(A,B);
01827 }
01828 
01830 
01836 inline cimatrix operator*(const cimatrix_slice& A, const scimatrix& B) {
01837   return fsp_mm_mult<cimatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
01838 }
01839 
01841 
01847 inline cimatrix operator*(const rmatrix_slice& A, const scimatrix& B) {
01848   return fsp_mm_mult<rmatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
01849 }
01850 
01852 
01858 inline cimatrix operator*(const imatrix_slice& A, const scimatrix& B) {
01859   return fsp_mm_mult<imatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
01860 }
01861 
01863 
01869 inline cimatrix operator*(const cmatrix_slice& A, const scimatrix& B) {
01870   return fsp_mm_mult<cmatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
01871 }
01872 
01874 
01880 inline cimatrix operator*(const cmatrix_slice& A, const simatrix& B) {
01881   return fsp_mm_mult<cmatrix_slice,simatrix,cimatrix,sparse_cidot>(A,B);
01882 }
01883 
01885 
01891 inline cimatrix operator*(const imatrix_slice& A, const scmatrix& B) {
01892   return fsp_mm_mult<imatrix_slice,scmatrix,cimatrix,sparse_cidot>(A,B);
01893 }
01894 
01896 
01902 inline cimatrix operator*(const scimatrix& A, const rmatrix_slice& B) {
01903   return spf_mm_mult<scimatrix,rmatrix_slice,cimatrix,sparse_cidot>(A,B);
01904 }
01905 
01907 
01913 inline cimatrix operator*(const scimatrix& A, const cmatrix_slice& B) {
01914   return spf_mm_mult<scimatrix,cmatrix_slice,cimatrix,sparse_cidot>(A,B);
01915 }
01916 
01918 
01924 inline cimatrix operator*(const scimatrix& A, const imatrix_slice& B) {
01925   return spf_mm_mult<scimatrix,imatrix_slice,cimatrix,sparse_cidot>(A,B);
01926 }
01927 
01929 
01935 inline cimatrix operator*(const scimatrix& A, const cimatrix_slice& B) {
01936   return spf_mm_mult<scimatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
01937 }
01938 
01940 
01946 inline cimatrix operator*(const srmatrix& A, const cimatrix_slice& B) {
01947   return spf_mm_mult<srmatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
01948 }
01949 
01951 
01957 inline cimatrix operator*(const scmatrix& A, const cimatrix_slice& B) {
01958   return spf_mm_mult<scmatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
01959 }
01960 
01962 
01968 inline cimatrix operator*(const simatrix& A, const cimatrix_slice& B) {
01969   return spf_mm_mult<simatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
01970 }
01971 
01973 
01979 inline cimatrix operator*(const scmatrix& A, const imatrix_slice& B) {
01980   return spf_mm_mult<scmatrix,imatrix_slice,cimatrix,sparse_cidot>(A,B);
01981 }
01982 
01984 
01990 inline cimatrix operator*(const simatrix& A, const cmatrix_slice& B) {
01991   return spf_mm_mult<simatrix,cmatrix_slice,cimatrix,sparse_cidot>(A,B);
01992 }
01993 
01995 
02001 inline scimatrix operator*(const scimatrix& A, const srmatrix& B) {
02002   return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02003 }
02004 
02006 
02012 inline scimatrix operator*(const scimatrix& A, const scmatrix& B) {
02013   return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02014 }
02015 
02017 
02023 inline scimatrix operator*(const scimatrix& A, const simatrix& B) {
02024   return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02025 }
02026 
02028 
02034 inline scimatrix operator*(const scimatrix& A, const scimatrix& B) {
02035   return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02036 }
02037 
02039 
02045 inline scimatrix operator*(const srmatrix& A, const scimatrix& B) {
02046   return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02047 }
02048 
02050 
02056 inline scimatrix operator*(const scmatrix& A, const scimatrix& B) {
02057   return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02058 }
02059 
02061 
02067 inline scimatrix operator*(const simatrix& A, const scimatrix& B) {
02068   return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02069 }
02070 
02072 
02078 inline scimatrix operator*(const scmatrix& A, const simatrix& B) {
02079   return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02080 }
02081 
02083 
02089 inline scimatrix operator*(const simatrix& A, const scmatrix& B) {
02090   return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
02091 }
02092 
02094 inline scimatrix operator/(const scimatrix& A, const real& r) {
02095   return sp_ms_div<scimatrix,real,scimatrix>(A,r);
02096 }
02097 
02099 inline scimatrix operator/(const scimatrix& A, const complex& r) {
02100   return sp_ms_div<scimatrix,complex,scimatrix>(A,r);
02101 }
02102 
02104 inline scimatrix operator/(const scimatrix& A, const interval& r) {
02105   return sp_ms_div<scimatrix,interval,scimatrix>(A,r);
02106 }
02107 
02109 inline scimatrix operator/(const scimatrix& A, const cinterval& r) {
02110   return sp_ms_div<scimatrix,cinterval,scimatrix>(A,r);
02111 }
02112 
02114 inline scimatrix operator/(const srmatrix& A, const cinterval& r) {
02115   return sp_ms_div<srmatrix,cinterval,scimatrix>(A,r);
02116 }
02117 
02119 inline scimatrix operator/(const simatrix& A, const cinterval& r) {
02120   return sp_ms_div<simatrix,cinterval,scimatrix>(A,r);
02121 }
02122 
02124 inline scimatrix operator/(const scmatrix& A, const cinterval& r) {
02125   return sp_ms_div<scmatrix,cinterval,scimatrix>(A,r);
02126 }
02127 
02129 inline scimatrix operator/(const scmatrix& A, const interval& r) {
02130   return sp_ms_div<scmatrix,interval,scimatrix>(A,r);
02131 }
02132 
02134 inline scimatrix operator/(const simatrix& A, const complex& r) {
02135   return sp_ms_div<simatrix,complex,scimatrix>(A,r);
02136 }
02137 
02139 inline scimatrix operator*(const scimatrix& A, const real& r) {
02140   return sp_ms_mult<scimatrix,real,scimatrix>(A,r);
02141 }
02142 
02144 inline scimatrix operator*(const scimatrix& A, const complex& r) {
02145   return sp_ms_mult<scimatrix,complex,scimatrix>(A,r);
02146 }
02147 
02149 inline scimatrix operator*(const scimatrix& A, const interval& r) {
02150   return sp_ms_mult<scimatrix,interval,scimatrix>(A,r);
02151 }
02152 
02154 inline scimatrix operator*(const scimatrix& A, const cinterval& r) {
02155   return sp_ms_mult<scimatrix,cinterval,scimatrix>(A,r);
02156 }
02157 
02159 inline scimatrix operator*(const srmatrix& A, const cinterval& r) {
02160   return sp_ms_mult<srmatrix,cinterval,scimatrix>(A,r);
02161 }
02162 
02164 inline scimatrix operator*(const simatrix& A, const cinterval& r) {
02165   return sp_ms_mult<simatrix,cinterval,scimatrix>(A,r);
02166 }
02167 
02169 inline scimatrix operator*(const scmatrix& A, const cinterval& r) {
02170   return sp_ms_mult<scmatrix,cinterval,scimatrix>(A,r);
02171 }
02172 
02174 inline scimatrix operator*(const scmatrix& A, const interval& r) {
02175   return sp_ms_mult<scmatrix,interval,scimatrix>(A,r);
02176 }
02177 
02179 inline scimatrix operator*(const simatrix& A, const complex& r) {
02180   return sp_ms_mult<simatrix,complex,scimatrix>(A,r);
02181 }
02182 
02184 inline scimatrix operator*(const real& r, const scimatrix& A) {
02185   return sp_sm_mult<real,scimatrix,scimatrix>(r,A);
02186 }
02187 
02189 inline scimatrix operator*(const complex& r, const scimatrix& A) {
02190   return sp_sm_mult<complex,scimatrix,scimatrix>(r,A);
02191 }
02192 
02194 inline scimatrix operator*(const interval& r, const scimatrix& A) {
02195   return sp_sm_mult<interval,scimatrix,scimatrix>(r,A);
02196 }
02197 
02199 inline scimatrix operator*(const cinterval& r, const scimatrix& A) {
02200   return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,A);
02201 }
02202 
02204 inline scimatrix operator*(const cinterval& r, const srmatrix& A) {
02205   return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,A);
02206 }
02207 
02209 inline scimatrix operator*(const cinterval& r, const simatrix& A) {
02210   return sp_sm_mult<cinterval,simatrix,scimatrix>(r,A);
02211 }
02212 
02214 inline scimatrix operator*(const cinterval& r, const scmatrix& A) {
02215   return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,A);
02216 }
02217 
02219 inline scimatrix operator*(const complex& r, const simatrix& A) {
02220   return sp_sm_mult<complex,simatrix,scimatrix>(r,A);
02221 }
02222 
02224 inline scimatrix operator*(const interval& r, const scmatrix& A) {
02225   return sp_sm_mult<interval,scmatrix,scimatrix>(r,A);
02226 }
02227 
02229 
02235 inline civector operator*(const scimatrix& A, const rvector& v) {
02236   return spf_mv_mult<scimatrix,rvector,civector,sparse_cidot>(A,v);
02237 }
02238 
02240 
02246 inline civector operator*(const scimatrix& A, const cvector& v) {
02247   return spf_mv_mult<scimatrix,cvector,civector,sparse_cidot>(A,v);
02248 }
02249 
02251 
02257 inline civector operator*(const scimatrix& A, const ivector& v) {
02258   return spf_mv_mult<scimatrix,ivector,civector,sparse_cidot>(A,v);
02259 }
02260 
02262 
02268 inline civector operator*(const scimatrix& A, const civector& v) {
02269   return spf_mv_mult<scimatrix,civector,civector,sparse_cidot>(A,v);
02270 }
02271 
02273 
02279 inline civector operator*(const srmatrix& A, const civector& v) {
02280   return spf_mv_mult<srmatrix,civector,civector,sparse_cidot>(A,v);
02281 }
02282 
02284 
02290 inline civector operator*(const scmatrix& A, const civector& v) {
02291   return spf_mv_mult<scmatrix,civector,civector,sparse_cidot>(A,v);
02292 }
02293 
02295 
02301 inline civector operator*(const simatrix& A, const civector& v) {
02302   return spf_mv_mult<simatrix,civector,civector,sparse_cidot>(A,v);
02303 }
02304 
02306 
02312 inline civector operator*(const scmatrix& A, const ivector& v) {
02313   return spf_mv_mult<scmatrix,ivector,civector,sparse_cidot>(A,v);
02314 }
02315 
02317 
02323 inline civector operator*(const simatrix& A, const cvector& v) {
02324   return spf_mv_mult<simatrix,cvector,civector,sparse_cidot>(A,v);
02325 }
02326 
02328 
02334 inline civector operator*(const scimatrix& A, const rvector_slice& v) {
02335   return spf_mv_mult<scimatrix,rvector_slice,civector,sparse_cidot>(A,v);
02336 }
02337 
02339 
02345 inline civector operator*(const scimatrix& A, const ivector_slice& v) {
02346   return spf_mv_mult<scimatrix,ivector_slice,civector,sparse_cidot>(A,v);
02347 }
02348 
02350 
02356 inline civector operator*(const scimatrix& A, const cvector_slice& v) {
02357   return spf_mv_mult<scimatrix,cvector_slice,civector,sparse_cidot>(A,v);
02358 }
02359 
02361 
02367 inline civector operator*(const scimatrix& A, const civector_slice& v) {
02368   return spf_mv_mult<scimatrix,civector_slice,civector,sparse_cidot>(A,v);
02369 }
02370 
02372 
02378 inline civector operator*(const srmatrix& A, const civector_slice& v) {
02379   return spf_mv_mult<srmatrix,civector_slice,civector,sparse_cidot>(A,v);
02380 }
02381 
02383 
02389 inline civector operator*(const scmatrix& A, const civector_slice& v) {
02390   return spf_mv_mult<scmatrix,civector_slice,civector,sparse_cidot>(A,v);
02391 }
02392 
02394 
02400 inline civector operator*(const simatrix& A, const civector_slice& v) {
02401   return spf_mv_mult<simatrix,civector_slice,civector,sparse_cidot>(A,v);
02402 }
02403 
02405 
02411 inline civector operator*(const simatrix& A, const cvector_slice& v) {
02412   return spf_mv_mult<simatrix,cvector_slice,civector,sparse_cidot>(A,v);
02413 }
02414 
02416 
02422 inline civector operator*(const scmatrix& A, const ivector_slice& v) {
02423   return spf_mv_mult<scmatrix,ivector_slice,civector,sparse_cidot>(A,v);
02424 }
02425 
02427 
02433 inline scivector operator*(const scimatrix& A, const srvector& v) {
02434   return spsp_mv_mult<scimatrix,srvector,scivector,sparse_cidot,cinterval>(A,v);
02435 }
02436 
02438 
02444 inline scivector operator*(const scimatrix& A, const sivector& v) {
02445   return spsp_mv_mult<scimatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
02446 }
02447 
02449 
02455 inline scivector operator*(const scimatrix& A, const scvector& v) {
02456   return spsp_mv_mult<scimatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
02457 }
02458 
02460 
02466 inline scivector operator*(const scimatrix& A, const scivector& v) {
02467   return spsp_mv_mult<scimatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
02468 }
02469 
02471 
02477 inline scivector operator*(const srmatrix& A, const scivector& v) {
02478   return spsp_mv_mult<srmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
02479 }
02480 
02482 
02488 inline scivector operator*(const scmatrix& A, const scivector& v) {
02489   return spsp_mv_mult<scmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
02490 }
02491 
02493 
02499 inline scivector operator*(const simatrix& A, const scivector& v) {
02500   return spsp_mv_mult<simatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
02501 }
02503 
02509 inline scivector operator*(const scmatrix& A, const sivector& v) {
02510   return spsp_mv_mult<scmatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
02511 }
02512 
02514 
02520 inline scivector operator*(const simatrix& A, const scvector& v) {
02521   return spsp_mv_mult<simatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
02522 }
02523 
02525 
02531 inline scivector operator*(const scimatrix& A, const srvector_slice& v) {
02532   return spsl_mv_mult<scimatrix,srvector_slice,scivector,sparse_cidot,cinterval>(A,v);
02533 }
02534 
02536 
02542 inline scivector operator*(const scimatrix& A, const scvector_slice& v) {
02543   return spsl_mv_mult<scimatrix,scvector_slice,scivector,sparse_cidot,cinterval>(A,v);
02544 }
02545 
02547 
02553 inline scivector operator*(const scimatrix& A, const sivector_slice& v) {
02554   return spsl_mv_mult<scimatrix,sivector_slice,scivector,sparse_cidot,cinterval>(A,v);
02555 }
02556 
02558 
02564 inline scivector operator*(const scimatrix& A, const scivector_slice& v) {
02565   return spsl_mv_mult<scimatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
02566 }
02567 
02569 
02575 inline scivector operator*(const srmatrix& A, const scivector_slice& v) {
02576   return spsl_mv_mult<srmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
02577 }
02578 
02580 
02586 inline scivector operator*(const scmatrix& A, const scivector_slice& v) {
02587   return spsl_mv_mult<scmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
02588 }
02589 
02591 
02597 inline scivector operator*(const simatrix& A, const scivector_slice& v) {
02598   return spsl_mv_mult<simatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
02599 }
02600 
02602 
02608 inline scivector operator*(const simatrix& A, const scvector_slice& v) {
02609   return spsl_mv_mult<simatrix,scvector_slice,scivector,sparse_cidot,cinterval>(A,v);
02610 }
02611 
02613 
02619 inline scivector operator*(const scmatrix& A, const sivector_slice& v) {
02620   return spsl_mv_mult<scmatrix,sivector_slice,scivector,sparse_cidot,cinterval>(A,v);
02621 }
02622 
02624 
02630 inline civector operator*(const cimatrix& A, const srvector& v) {
02631   return fsp_mv_mult<cimatrix,srvector,civector,sparse_cidot>(A,v);
02632 }
02633 
02635 
02641 inline civector operator*(const cimatrix& A, const sivector& v) {
02642   return fsp_mv_mult<cimatrix,sivector,civector,sparse_cidot>(A,v);
02643 }
02644 
02646 
02652 inline civector operator*(const cimatrix& A, const scvector& v) {
02653   return fsp_mv_mult<cimatrix,scvector,civector,sparse_cidot>(A,v);
02654 }
02655 
02657 
02663 inline civector operator*(const cimatrix& A, const scivector& v) {
02664   return fsp_mv_mult<cimatrix,scivector,civector,sparse_cidot>(A,v);
02665 }
02666 
02668 
02674 inline civector operator*(const rmatrix& A, const scivector& v) {
02675   return fsp_mv_mult<rmatrix,scivector,civector,sparse_cidot>(A,v);
02676 }
02677 
02679 
02685 inline civector operator*(const cmatrix& A, const scivector& v) {
02686   return fsp_mv_mult<cmatrix,scivector,civector,sparse_cidot>(A,v);
02687 }
02688 
02690 
02696 inline civector operator*(const imatrix& A, const scivector& v) {
02697   return fsp_mv_mult<imatrix,scivector,civector,sparse_cidot>(A,v);
02698 }
02699 
02701 
02707 inline civector operator*(const cmatrix& A, const sivector& v) {
02708   return fsp_mv_mult<cmatrix,sivector,civector,sparse_cidot>(A,v);
02709 }
02710 
02712 
02718 inline civector operator*(const imatrix& A, const scvector& v) {
02719   return fsp_mv_mult<imatrix,scvector,civector,sparse_cidot>(A,v);
02720 }
02721 
02723 
02729 inline civector operator*(const cimatrix_slice& A, const srvector& v) {
02730   return fsp_mv_mult<cimatrix_slice,srvector,civector,sparse_cidot>(A,v);
02731 }
02732 
02734 
02740 inline civector operator*(const cimatrix_slice& A, const scvector& v) {
02741   return fsp_mv_mult<cimatrix_slice,scvector,civector,sparse_cidot>(A,v);
02742 }
02743 
02745 
02751 inline civector operator*(const cimatrix_slice& A, const sivector& v) {
02752   return fsp_mv_mult<cimatrix_slice,sivector,civector,sparse_cidot>(A,v);
02753 }
02754 
02756 
02762 inline civector operator*(const cimatrix_slice& A, const scivector& v) {
02763   return fsp_mv_mult<cimatrix_slice,scivector,civector,sparse_cidot>(A,v);
02764 }
02765 
02767 
02773 inline civector operator*(const rmatrix_slice& A, const scivector& v) {
02774   return fsp_mv_mult<rmatrix_slice,scivector,civector,sparse_cidot>(A,v);
02775 }
02776 
02778 
02784 inline civector operator*(const cmatrix_slice& A, const scivector& v) {
02785   return fsp_mv_mult<cmatrix_slice,scivector,civector,sparse_cidot>(A,v);
02786 }
02787 
02789 
02795 inline civector operator*(const imatrix_slice& A, const scivector& v) {
02796   return fsp_mv_mult<imatrix_slice,scivector,civector,sparse_cidot>(A,v);
02797 }
02798 
02800 
02806 inline civector operator*(const cmatrix_slice& A, const sivector& v) {
02807   return fsp_mv_mult<cmatrix_slice,sivector,civector,sparse_cidot>(A,v);
02808 }
02809 
02811 
02817 inline civector operator*(const imatrix_slice& A, const scvector& v) {
02818   return fsp_mv_mult<imatrix_slice,scvector,civector,sparse_cidot>(A,v);
02819 }
02820 
02822 
02828 inline civector operator*(const cimatrix& A, const srvector_slice& v) {
02829   return fsl_mv_mult<cimatrix,srvector_slice,civector,sparse_cidot>(A,v);
02830 }
02831 
02833 
02839 inline civector operator*(const cimatrix& A, const scvector_slice& v) {
02840   return fsl_mv_mult<cimatrix,scvector_slice,civector,sparse_cidot>(A,v);
02841 }
02842 
02844 
02850 inline civector operator*(const cimatrix& A, const sivector_slice& v) {
02851   return fsl_mv_mult<cimatrix,sivector_slice,civector,sparse_cidot>(A,v);
02852 }
02853 
02855 
02861 inline civector operator*(const cimatrix& A, const scivector_slice& v) {
02862   return fsl_mv_mult<cimatrix,scivector_slice,civector,sparse_cidot>(A,v);
02863 }
02864 
02866 
02872 inline civector operator*(const rmatrix& A, const scivector_slice& v) {
02873   return fsl_mv_mult<rmatrix,scivector_slice,civector,sparse_cidot>(A,v);
02874 }
02875 
02877 
02883 inline civector operator*(const cmatrix& A, const scivector_slice& v) {
02884   return fsl_mv_mult<cmatrix,scivector_slice,civector,sparse_cidot>(A,v);
02885 }
02886 
02888 
02894 inline civector operator*(const imatrix& A, const scivector_slice& v) {
02895   return fsl_mv_mult<imatrix,scivector_slice,civector,sparse_cidot>(A,v);
02896 }
02897 
02899 
02905 inline civector operator*(const cmatrix& A, const sivector_slice& v) {
02906   return fsl_mv_mult<cmatrix,sivector_slice,civector,sparse_cidot>(A,v);
02907 }
02908 
02910 
02916 inline civector operator*(const imatrix& A, const scvector_slice& v) {
02917   return fsl_mv_mult<imatrix,scvector_slice,civector,sparse_cidot>(A,v);
02918 }
02919 
02921 
02927 inline civector operator*(const cimatrix_slice& A, const srvector_slice& v) {
02928   return fsl_mv_mult<cimatrix_slice,srvector_slice,civector,sparse_cidot>(A,v);
02929 }
02930 
02932 
02938 inline civector operator*(const cimatrix_slice& A, const scvector_slice& v) {
02939   return fsl_mv_mult<cimatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
02940 }
02941 
02943 
02949 inline civector operator*(const cimatrix_slice& A, const sivector_slice& v) {
02950   return fsl_mv_mult<cimatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
02951 }
02952 
02954 
02960 inline civector operator*(const cimatrix_slice& A, const scivector_slice& v) {
02961   return fsl_mv_mult<cimatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
02962 }
02963 
02965 
02971 inline civector operator*(const rmatrix_slice& A, const scivector_slice& v) {
02972   return fsl_mv_mult<rmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
02973 }
02974 
02976 
02982 inline civector operator*(const imatrix_slice& A, const scivector_slice& v) {
02983   return fsl_mv_mult<imatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
02984 }
02985 
02987 
02993 inline civector operator*(const cmatrix_slice& A, const scivector_slice& v) {
02994   return fsl_mv_mult<cmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
02995 }
02996 
02998 
03004 inline civector operator*(const cmatrix_slice& A, const sivector_slice& v) {
03005   return fsl_mv_mult<cmatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
03006 }
03007 
03009 
03015 inline civector operator*(const imatrix_slice& A, const scvector_slice& v) {
03016   return fsl_mv_mult<imatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
03017 }
03018 
03020 inline cimatrix operator+(const cimatrix& A, const srmatrix& B) {
03021   return fsp_mm_add<cimatrix,srmatrix,cimatrix>(A,B);
03022 }
03023 
03025 inline cimatrix operator+(const cimatrix& A, const scmatrix& B) {
03026   return fsp_mm_add<cimatrix,scmatrix,cimatrix>(A,B);
03027 }
03028 
03030 inline cimatrix operator+(const cimatrix& A, const simatrix& B) {
03031   return fsp_mm_add<cimatrix,simatrix,cimatrix>(A,B);
03032 }
03033 
03035 inline cimatrix operator+(const cimatrix& A, const scimatrix& B) {
03036   return fsp_mm_add<cimatrix,scimatrix,cimatrix>(A,B);
03037 }
03038 
03040 inline cimatrix operator+(const rmatrix& A, const scimatrix& B) {
03041   return fsp_mm_add<rmatrix,scimatrix,cimatrix>(A,B);
03042 }
03043 
03045 inline cimatrix operator+(const cmatrix& A, const scimatrix& B) {
03046   return fsp_mm_add<cmatrix,scimatrix,cimatrix>(A,B);
03047 }
03048 
03050 inline cimatrix operator+(const imatrix& A, const scimatrix& B) {
03051   return fsp_mm_add<imatrix,scimatrix,cimatrix>(A,B);
03052 }
03053 
03055 inline cimatrix operator+(const imatrix& A, const scmatrix& B) {
03056   return fsp_mm_add<imatrix,scmatrix,cimatrix>(A,B);
03057 }
03058 
03060 inline cimatrix operator+(const cmatrix& A, const simatrix& B) {
03061   return fsp_mm_add<cmatrix,simatrix,cimatrix>(A,B);
03062 }
03063 
03065 inline cimatrix operator+(const scimatrix& A, const rmatrix& B) {
03066   return spf_mm_add<scimatrix,rmatrix,cimatrix>(A,B);
03067 }
03068 
03070 inline cimatrix operator+(const scimatrix& A, const cmatrix& B) {
03071   return spf_mm_add<scimatrix,cmatrix,cimatrix>(A,B);
03072 }
03073 
03075 inline cimatrix operator+(const scimatrix& A, const imatrix& B) {
03076   return spf_mm_add<scimatrix,imatrix,cimatrix>(A,B);
03077 }
03078 
03080 inline cimatrix operator+(const scimatrix& A, const cimatrix& B) {
03081   return spf_mm_add<scimatrix,cimatrix,cimatrix>(A,B);
03082 }
03083 
03085 inline cimatrix operator+(const srmatrix& A, const cimatrix& B) {
03086   return spf_mm_add<srmatrix,cimatrix,cimatrix>(A,B);
03087 }
03088 
03090 inline cimatrix operator+(const scmatrix& A, const cimatrix& B) {
03091   return spf_mm_add<scmatrix,cimatrix,cimatrix>(A,B);
03092 }
03093 
03095 inline cimatrix operator+(const simatrix& A, const cimatrix& B) {
03096   return spf_mm_add<simatrix,cimatrix,cimatrix>(A,B);
03097 }
03098 
03100 inline cimatrix operator+(const simatrix& A, const cmatrix& B) {
03101   return spf_mm_add<simatrix,cmatrix,cimatrix>(A,B);
03102 }
03103 
03105 inline cimatrix operator+(const scmatrix& A, const imatrix& B) {
03106   return spf_mm_add<scmatrix,imatrix,cimatrix>(A,B);
03107 }
03108 
03110 inline cimatrix operator+(const cimatrix_slice& A, const srmatrix& B) {
03111   return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(A,B);
03112 }
03113 
03115 inline cimatrix operator+(const cimatrix_slice& A, const simatrix& B) {
03116   return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(A,B);
03117 }
03118 
03120 inline cimatrix operator+(const cimatrix_slice& A, const scmatrix& B) {
03121   return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(A,B);
03122 }
03123 
03125 inline cimatrix operator+(const cimatrix_slice& A, const scimatrix& B) {
03126   return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(A,B);
03127 }
03128 
03130 inline cimatrix operator+(const rmatrix_slice& A, const scimatrix& B) {
03131   return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(A,B);
03132 }
03133 
03135 inline cimatrix operator+(const imatrix_slice& A, const scimatrix& B) {
03136   return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(A,B);
03137 }
03138 
03140 inline cimatrix operator+(const cmatrix_slice& A, const scimatrix& B) {
03141   return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(A,B);
03142 }
03143 
03145 inline cimatrix operator+(const cmatrix_slice& A, const simatrix& B) {
03146   return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(A,B);
03147 }
03148 
03150 inline cimatrix operator+(const imatrix_slice& A, const scmatrix& B) {
03151   return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(A,B);
03152 }
03153 
03155 inline cimatrix operator+(const scimatrix& A, const rmatrix_slice& B) {
03156   return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(A,B);
03157 }
03158 
03160 inline cimatrix operator+(const scimatrix& A, const cmatrix_slice& B) {
03161   return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(A,B);
03162 }
03163 
03165 inline cimatrix operator+(const scimatrix& A, const imatrix_slice& B) {
03166   return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(A,B);
03167 }
03168 
03170 inline cimatrix operator+(const scimatrix& A, const cimatrix_slice& B) {
03171   return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(A,B);
03172 }
03173 
03175 inline cimatrix operator+(const srmatrix& A, const cimatrix_slice& B) {
03176   return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(A,B);
03177 }
03178 
03180 inline cimatrix operator+(const scmatrix& A, const cimatrix_slice& B) {
03181   return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(A,B);
03182 }
03183 
03185 inline cimatrix operator+(const simatrix& A, const cimatrix_slice& B) {
03186   return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(A,B);
03187 }
03188 
03190 inline cimatrix operator+(const simatrix& A, const cmatrix_slice& B) {
03191   return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(A,B);
03192 }
03193 
03195 inline cimatrix operator+(const scmatrix& A, const imatrix_slice& B) {
03196   return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(A,B);
03197 }
03198 
03200 inline scimatrix operator+(const scimatrix& A, const srmatrix& B) {
03201   return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
03202 }
03203 
03205 inline scimatrix operator+(const scimatrix& A, const scmatrix& B) {
03206   return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
03207 }
03208 
03210 inline scimatrix operator+(const scimatrix& A, const simatrix& B) {
03211   return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(A,B);
03212 }
03213 
03215 inline scimatrix operator+(const scimatrix& A, const scimatrix& B) {
03216   return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
03217 }
03218 
03220 inline scimatrix operator+(const srmatrix& A, const scimatrix& B) {
03221   return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
03222 }
03223 
03225 inline scimatrix operator+(const scmatrix& A, const scimatrix& B) {
03226   return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
03227 }
03228 
03230 inline scimatrix operator+(const simatrix& A, const scimatrix& B) {
03231   return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(A,B);
03232 }
03233 
03235 inline scimatrix operator+(const simatrix& A, const scmatrix& B) {
03236   return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(A,B);
03237 }
03238 
03240 inline scimatrix operator+(const scmatrix& A, const simatrix& B) {
03241   return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(A,B);
03242 }
03243 
03245 inline cimatrix operator-(const cimatrix& A, const srmatrix& B) {
03246   return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(A,B);
03247 }
03248 
03250 inline cimatrix operator-(const cimatrix& A, const scmatrix& B) {
03251   return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(A,B);
03252 }
03253 
03255 inline cimatrix operator-(const cimatrix& A, const simatrix& B) {
03256   return fsp_mm_sub<cimatrix,simatrix,cimatrix>(A,B);
03257 }
03258 
03260 inline cimatrix operator-(const cimatrix& A, const scimatrix& B) {
03261   return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(A,B);
03262 }
03263 
03265 inline cimatrix operator-(const rmatrix& A, const scimatrix& B) {
03266   return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(A,B);
03267 }
03268 
03270 inline cimatrix operator-(const cmatrix& A, const scimatrix& B) {
03271   return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(A,B);
03272 }
03273 
03275 inline cimatrix operator-(const imatrix& A, const scimatrix& B) {
03276   return fsp_mm_sub<imatrix,scimatrix,cimatrix>(A,B);
03277 }
03278 
03280 inline cimatrix operator-(const imatrix& A, const scmatrix& B) {
03281   return fsp_mm_sub<imatrix,scmatrix,cimatrix>(A,B);
03282 }
03283 
03285 inline cimatrix operator-(const cmatrix& A, const simatrix& B) {
03286   return fsp_mm_sub<cmatrix,simatrix,cimatrix>(A,B);
03287 }
03288 
03290 inline cimatrix operator-(const scimatrix& A, const rmatrix& B) {
03291   return spf_mm_sub<scimatrix,rmatrix,cimatrix>(A,B);
03292 }
03293 
03295 inline cimatrix operator-(const scimatrix& A, const cmatrix& B) {
03296   return spf_mm_sub<scimatrix,cmatrix,cimatrix>(A,B);
03297 }
03298 
03300 inline cimatrix operator-(const scimatrix& A, const imatrix& B) {
03301   return spf_mm_sub<scimatrix,imatrix,cimatrix>(A,B);
03302 }
03303 
03305 inline cimatrix operator-(const scimatrix& A, const cimatrix& B) {
03306   return spf_mm_sub<scimatrix,cimatrix,cimatrix>(A,B);
03307 }
03308 
03310 inline cimatrix operator-(const srmatrix& A, const cimatrix& B) {
03311   return spf_mm_sub<srmatrix,cimatrix,cimatrix>(A,B);
03312 }
03313 
03315 inline cimatrix operator-(const scmatrix& A, const cimatrix& B) {
03316   return spf_mm_sub<scmatrix,cimatrix,cimatrix>(A,B);
03317 }
03318 
03320 inline cimatrix operator-(const simatrix& A, const cimatrix& B) {
03321   return spf_mm_sub<simatrix,cimatrix,cimatrix>(A,B);
03322 }
03323 
03325 inline cimatrix operator-(const simatrix& A, const cmatrix& B) {
03326   return spf_mm_sub<simatrix,cmatrix,cimatrix>(A,B);
03327 }
03328 
03330 inline cimatrix operator-(const scmatrix& A, const imatrix& B) {
03331   return spf_mm_sub<scmatrix,imatrix,cimatrix>(A,B);
03332 }
03333 
03335 inline cimatrix operator-(const cimatrix_slice& A, const srmatrix& B) {
03336   return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(A,B);
03337 }
03338 
03340 inline cimatrix operator-(const cimatrix_slice& A, const simatrix& B) {
03341   return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(A,B);
03342 }
03343 
03345 inline cimatrix operator-(const cimatrix_slice& A, const scmatrix& B) {
03346   return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(A,B);
03347 }
03348 
03350 inline cimatrix operator-(const cimatrix_slice& A, const scimatrix& B) {
03351   return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(A,B);
03352 }
03353 
03355 inline cimatrix operator-(const rmatrix_slice& A, const scimatrix& B) {
03356   return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(A,B);
03357 }
03358 
03360 inline cimatrix operator-(const imatrix_slice& A, const scimatrix& B) {
03361   return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(A,B);
03362 }
03363 
03365 inline cimatrix operator-(const cmatrix_slice& A, const scimatrix& B) {
03366   return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(A,B);
03367 }
03368 
03370 inline cimatrix operator-(const cmatrix_slice& A, const simatrix& B) {
03371   return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(A,B);
03372 }
03373 
03375 inline cimatrix operator-(const imatrix_slice& A, const scmatrix& B) {
03376   return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(A,B);
03377 }
03378 
03380 inline cimatrix operator-(const scimatrix& A, const rmatrix_slice& B) {
03381   return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(A,B);
03382 }
03383 
03385 inline cimatrix operator-(const scimatrix& A, const cmatrix_slice& B) {
03386   return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(A,B);
03387 }
03388 
03390 inline cimatrix operator-(const scimatrix& A, const imatrix_slice& B) {
03391   return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(A,B);
03392 }
03393 
03395 inline cimatrix operator-(const scimatrix& A, const cimatrix_slice& B) {
03396   return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(A,B);
03397 }
03398 
03400 inline cimatrix operator-(const srmatrix& A, const cimatrix_slice& B) {
03401   return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(A,B);
03402 }
03403 
03405 inline cimatrix operator-(const scmatrix& A, const cimatrix_slice& B) {
03406   return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(A,B);
03407 }
03408 
03410 inline cimatrix operator-(const simatrix& A, const cimatrix_slice& B) {
03411   return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(A,B);
03412 }
03413 
03415 inline cimatrix operator-(const simatrix& A, const cmatrix_slice& B) {
03416   return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(A,B);
03417 }
03418 
03420 inline cimatrix operator-(const scmatrix& A, const imatrix_slice& B) {
03421   return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(A,B);
03422 }
03423 
03425 inline scimatrix operator-(const scimatrix& A, const srmatrix& B) {
03426   return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
03427 }
03428 
03430 inline scimatrix operator-(const scimatrix& A, const scmatrix& B) {
03431   return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
03432 }
03433 
03435 inline scimatrix operator-(const scimatrix& A, const simatrix& B) {
03436   return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(A,B);
03437 }
03438 
03440 inline scimatrix operator-(const scimatrix& A, const scimatrix& B) {
03441   return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
03442 }
03443 
03445 inline scimatrix operator-(const srmatrix& A, const scimatrix& B) {
03446   return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
03447 }
03448 
03450 inline scimatrix operator-(const scmatrix& A, const scimatrix& B) {
03451   return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
03452 }
03453 
03455 inline scimatrix operator-(const simatrix& A, const scimatrix& B) {
03456   return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(A,B);
03457 }
03458 
03460 inline scimatrix operator-(const simatrix& A, const scmatrix& B) {
03461   return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(A,B);
03462 }
03463 
03465 inline scimatrix operator-(const scmatrix& A, const simatrix& B) {
03466   return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(A,B);
03467 }
03468 
03470 inline cimatrix operator|(const cimatrix& A, const srmatrix& B) {
03471   return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(A,B);
03472 }
03473 
03475 inline cimatrix operator|(const cimatrix& A, const scmatrix& B) {
03476   return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(A,B);
03477 }
03478 
03480 inline cimatrix operator|(const cimatrix& A, const simatrix& B) {
03481   return fsp_mm_hull<cimatrix,simatrix,cimatrix>(A,B);
03482 }
03483 
03485 inline cimatrix operator|(const cimatrix& A, const scimatrix& B) {
03486   return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(A,B);
03487 }
03488 
03490 inline cimatrix operator|(const rmatrix& A, const scimatrix& B) {
03491   return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(A,B);
03492 }
03493 
03495 inline cimatrix operator|(const cmatrix& A, const scimatrix& B) {
03496   return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(A,B);
03497 }
03498 
03500 inline cimatrix operator|(const imatrix& A, const scimatrix& B) {
03501   return fsp_mm_hull<imatrix,scimatrix,cimatrix>(A,B);
03502 }
03503 
03505 inline cimatrix operator|(const imatrix& A, const scmatrix& B) {
03506   return fsp_mm_hull<imatrix,scmatrix,cimatrix>(A,B);
03507 }
03508 
03510 inline cimatrix operator|(const cmatrix& A, const simatrix& B) {
03511   return fsp_mm_hull<cmatrix,simatrix,cimatrix>(A,B);
03512 }
03513 
03515 inline cimatrix operator|(const scimatrix& A, const rmatrix& B) {
03516   return spf_mm_hull<scimatrix,rmatrix,cimatrix>(A,B);
03517 }
03518 
03520 inline cimatrix operator|(const scimatrix& A, const cmatrix& B) {
03521   return spf_mm_hull<scimatrix,cmatrix,cimatrix>(A,B);
03522 }
03523 
03525 inline cimatrix operator|(const scimatrix& A, const imatrix& B) {
03526   return spf_mm_hull<scimatrix,imatrix,cimatrix>(A,B);
03527 }
03528 
03530 inline cimatrix operator|(const scimatrix& A, const cimatrix& B) {
03531   return spf_mm_hull<scimatrix,cimatrix,cimatrix>(A,B);
03532 }
03533 
03535 inline cimatrix operator|(const srmatrix& A, const cimatrix& B) {
03536   return spf_mm_hull<srmatrix,cimatrix,cimatrix>(A,B);
03537 }
03538 
03540 inline cimatrix operator|(const scmatrix& A, const cimatrix& B) {
03541   return spf_mm_hull<scmatrix,cimatrix,cimatrix>(A,B);
03542 }
03543 
03545 inline cimatrix operator|(const simatrix& A, const cimatrix& B) {
03546   return spf_mm_hull<simatrix,cimatrix,cimatrix>(A,B);
03547 }
03548 
03550 inline cimatrix operator|(const simatrix& A, const cmatrix& B) {
03551   return spf_mm_hull<simatrix,cmatrix,cimatrix>(A,B);
03552 }
03553 
03555 inline cimatrix operator|(const scmatrix& A, const imatrix& B) {
03556   return spf_mm_hull<scmatrix,imatrix,cimatrix>(A,B);
03557 }
03558 
03560 inline cimatrix operator|(const cimatrix_slice& A, const srmatrix& B) {
03561   return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(A,B);
03562 }
03563 
03565 inline cimatrix operator|(const cimatrix_slice& A, const simatrix& B) {
03566   return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(A,B);
03567 }
03568 
03570 inline cimatrix operator|(const cimatrix_slice& A, const scmatrix& B) {
03571   return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(A,B);
03572 }
03573 
03575 inline cimatrix operator|(const cimatrix_slice& A, const scimatrix& B) {
03576   return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(A,B);
03577 }
03578 
03580 inline cimatrix operator|(const rmatrix_slice& A, const scimatrix& B) {
03581   return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(A,B);
03582 }
03583 
03585 inline cimatrix operator|(const imatrix_slice& A, const scimatrix& B) {
03586   return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(A,B);
03587 }
03588 
03590 inline cimatrix operator|(const cmatrix_slice& A, const scimatrix& B) {
03591   return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(A,B);
03592 }
03593 
03595 inline cimatrix operator|(const cmatrix_slice& A, const simatrix& B) {
03596   return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(A,B);
03597 }
03598 
03600 inline cimatrix operator|(const imatrix_slice& A, const scmatrix& B) {
03601   return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(A,B);
03602 }
03603 
03605 inline cimatrix operator|(const scimatrix& A, const rmatrix_slice& B) {
03606   return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(A,B);
03607 }
03608 
03610 inline cimatrix operator|(const scimatrix& A, const cmatrix_slice& B) {
03611   return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(A,B);
03612 }
03613 
03615 inline cimatrix operator|(const scimatrix& A, const imatrix_slice& B) {
03616   return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(A,B);
03617 }
03618 
03620 inline cimatrix operator|(const scimatrix& A, const cimatrix_slice& B) {
03621   return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(A,B);
03622 }
03623 
03625 inline cimatrix operator|(const srmatrix& A, const cimatrix_slice& B) {
03626   return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(A,B);
03627 }
03628 
03630 inline cimatrix operator|(const scmatrix& A, const cimatrix_slice& B) {
03631   return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(A,B);
03632 }
03633 
03635 inline cimatrix operator|(const simatrix& A, const cimatrix_slice& B) {
03636   return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(A,B);
03637 }
03638 
03640 inline cimatrix operator|(const simatrix& A, const cmatrix_slice& B) {
03641   return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(A,B);
03642 }
03643 
03645 inline cimatrix operator|(const scmatrix& A, const imatrix_slice& B) {
03646   return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(A,B);
03647 }
03648 
03650 inline scimatrix operator|(const scimatrix& A, const srmatrix& B) {
03651   return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
03652 }
03653 
03655 inline scimatrix operator|(const scimatrix& A, const scmatrix& B) {
03656   return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
03657 }
03658 
03660 inline scimatrix operator|(const scimatrix& A, const simatrix& B) {
03661   return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(A,B);
03662 }
03663 
03665 inline scimatrix operator|(const scimatrix& A, const scimatrix& B) {
03666   return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
03667 }
03668 
03670 inline scimatrix operator|(const srmatrix& A, const scimatrix& B) {
03671   return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
03672 }
03673 
03675 inline scimatrix operator|(const scmatrix& A, const scimatrix& B) {
03676   return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
03677 }
03678 
03680 inline scimatrix operator|(const simatrix& A, const scimatrix& B) {
03681   return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(A,B);
03682 }
03683 
03685 inline scimatrix operator|(const simatrix& A, const scmatrix& B) {
03686   return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(A,B);
03687 }
03688 
03690 inline scimatrix operator|(const scmatrix& A, const simatrix& B) {
03691   return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(A,B);
03692 }
03693 
03695 inline cimatrix operator|(const cmatrix& A, const srmatrix& B) {
03696   return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(A,B);
03697 }
03698 
03700 inline cimatrix operator|(const rmatrix& A, const scmatrix& B) {
03701   return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(A,B);
03702 }
03703 
03705 inline cimatrix operator|(const cmatrix& A, const scmatrix& B) {
03706   return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(A,B);
03707 }
03708 
03710 inline cimatrix operator|(const scmatrix& A, const rmatrix& B) {
03711   return spf_mm_hull<scmatrix,rmatrix,cimatrix>(A,B);
03712 }
03713 
03715 inline cimatrix operator|(const srmatrix& A, const cmatrix& B) {
03716   return spf_mm_hull<srmatrix,cmatrix,cimatrix>(A,B);
03717 }
03718 
03720 inline cimatrix operator|(const scmatrix& A, const cmatrix& B) {
03721   return spf_mm_hull<scmatrix,cmatrix,cimatrix>(A,B);
03722 }
03723 
03725 inline cimatrix operator|(const cmatrix_slice& A, const srmatrix& B) {
03726   return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(A,B);
03727 }
03728 
03730 inline cimatrix operator|(const rmatrix_slice& A, const scmatrix& B) {
03731   return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(A,B);
03732 }
03733 
03735 inline cimatrix operator|(const cmatrix_slice& A, const scmatrix& B) {
03736   return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(A,B);
03737 }
03738 
03740 inline cimatrix operator|(const scmatrix& A, const rmatrix_slice& B) {
03741   return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(A,B);
03742 }
03743 
03745 inline cimatrix operator|(const srmatrix& A, const cmatrix_slice& B) {
03746   return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(A,B);
03747 }
03748 
03750 inline cimatrix operator|(const scmatrix& A, const cmatrix_slice& B) {
03751   return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(A,B);
03752 }
03753 
03755 inline scimatrix operator|(const scmatrix& A, const srmatrix& B) {
03756   return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(A,B);
03757 }
03758 
03760 inline scimatrix operator|(const srmatrix& A, const scmatrix& B) {
03761   return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(A,B);
03762 }
03763 
03765 inline scimatrix operator|(const scmatrix& A, const scmatrix& B) {
03766   return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(A,B);
03767 }
03768 
03770 inline cimatrix operator&(const cimatrix& A, const simatrix& B) {
03771   return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(A,B);
03772 }
03773 
03775 inline cimatrix operator&(const cimatrix& A, const scimatrix& B) {
03776   return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(A,B);
03777 }
03778 
03780 inline cimatrix operator&(const imatrix& A, const scimatrix& B) {
03781   return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(A,B);
03782 }
03783 
03785 inline cimatrix operator&(const scimatrix& A, const imatrix& B) {
03786   return spf_mm_intersect<scimatrix,imatrix,cimatrix>(A,B);
03787 }
03788 
03790 inline cimatrix operator&(const scimatrix& A, const cimatrix& B) {
03791   return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(A,B);
03792 }
03793 
03795 inline cimatrix operator&(const simatrix& A, const cimatrix& B) {
03796   return spf_mm_intersect<simatrix,cimatrix,cimatrix>(A,B);
03797 }
03798 
03800 inline cimatrix operator&(const cimatrix_slice& A, const simatrix& B) {
03801   return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(A,B);
03802 }
03803 
03805 inline cimatrix operator&(const cimatrix_slice& A, const scimatrix& B) {
03806   return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(A,B);
03807 }
03808 
03810 inline cimatrix operator&(const imatrix_slice& A, const scimatrix& B) {
03811   return fsp_mm_intersect<imatrix_slice,scimatrix,cimatrix>(A,B);
03812 }
03813 
03815 inline cimatrix operator&(const scimatrix& A, const imatrix_slice& B) {
03816   return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(A,B);
03817 }
03818 
03820 inline cimatrix operator&(const scimatrix& A, const cimatrix_slice& B) {
03821   return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(A,B);
03822 }
03823 
03825 inline cimatrix operator&(const simatrix& A, const cimatrix_slice& B) {
03826   return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(A,B);
03827 }
03828 
03830 inline scimatrix operator&(const scimatrix& A, const simatrix& B) {
03831   return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(A,B);
03832 }
03833 
03835 inline scimatrix operator&(const scimatrix& A, const scimatrix& B) {
03836   return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
03837 }
03838 
03840 inline scimatrix operator&(const simatrix& A, const scimatrix& B) {
03841   return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(A,B);
03842 }
03843 
03845 inline scimatrix operator-(const scimatrix& M) {
03846   return sp_m_negative<scimatrix,scimatrix>(M);
03847 }
03848 
03850 inline scimatrix& operator+(scimatrix& A) {
03851   return A;
03852 }
03853 
03854 inline cimatrix& cimatrix::operator=(const srmatrix& B) {
03855   *this = rmatrix(B);
03856   return *this;
03857 }
03858 
03859 inline cimatrix& cimatrix::operator=(const scmatrix& B) {
03860   *this = cmatrix(B);
03861   return *this;
03862 }
03863 
03864 inline cimatrix& cimatrix::operator=(const simatrix& B) {
03865   *this = imatrix(B);
03866   return *this;
03867 }
03868 
03869 inline cimatrix& cimatrix::operator=(const scimatrix& B) {
03870   *this = cimatrix(B);
03871   return *this;
03872 }
03873 
03874 inline cimatrix_slice& cimatrix_slice::operator=(const srmatrix& B) {
03875   *this = rmatrix(B);
03876   return *this;
03877 }
03878 
03879 inline cimatrix_slice& cimatrix_slice::operator=(const scmatrix& B) {
03880   *this = cmatrix(B);
03881   return *this;
03882 }
03883 
03884 inline cimatrix_slice& cimatrix_slice::operator=(const simatrix& B) {
03885   *this = imatrix(B);
03886   return *this;
03887 }
03888 
03889 inline cimatrix_slice& cimatrix_slice::operator=(const scimatrix& B) {
03890   *this = cimatrix(B);
03891   return *this;
03892 }
03893 
03894 inline cimatrix& cimatrix::operator+=(const srmatrix& B) {
03895   return fsp_mm_addassign(*this,B);
03896 }
03897 
03898 inline cimatrix& cimatrix::operator+=(const scmatrix& B) {
03899   return fsp_mm_addassign(*this,B);
03900 }
03901 
03902 inline cimatrix& cimatrix::operator+=(const simatrix& B) {
03903   return fsp_mm_addassign(*this,B);
03904 }
03905 
03906 inline cimatrix& cimatrix::operator+=(const scimatrix& B) {
03907   return fsp_mm_addassign(*this,B);
03908 }
03909 
03910 inline cimatrix_slice& cimatrix_slice::operator+=(const srmatrix& B) {
03911   return fsp_mm_addassign(*this,B);
03912 }
03913 
03914 inline cimatrix_slice& cimatrix_slice::operator+=(const scmatrix& B) {
03915   return fsp_mm_addassign(*this,B);
03916 }
03917 
03918 inline cimatrix_slice& cimatrix_slice::operator+=(const simatrix& B) {
03919   return fsp_mm_addassign(*this,B);
03920 }
03921 
03922 inline cimatrix_slice& cimatrix_slice::operator+=(const scimatrix& B) {
03923   return fsp_mm_addassign(*this,B);
03924 }
03925 
03926 inline cimatrix& cimatrix::operator-=(const srmatrix& B) {
03927   return fsp_mm_subassign(*this,B);
03928 }
03929 
03930 inline cimatrix& cimatrix::operator-=(const scmatrix& B) {
03931   return fsp_mm_subassign(*this,B);
03932 }
03933 
03934 inline cimatrix& cimatrix::operator-=(const scimatrix& B) {
03935   return fsp_mm_subassign(*this,B);
03936 }
03937 
03938 inline cimatrix& cimatrix::operator-=(const simatrix& B) {
03939   return fsp_mm_subassign(*this,B);
03940 }
03941 
03942 inline cimatrix_slice& cimatrix_slice::operator-=(const srmatrix& B) {
03943   return fsp_mm_subassign(*this,B);
03944 }
03945 
03946 inline cimatrix_slice& cimatrix_slice::operator-=(const scmatrix& B) {
03947   return fsp_mm_subassign(*this,B);
03948 }
03949 
03950 inline cimatrix_slice& cimatrix_slice::operator-=(const simatrix& B) {
03951   return fsp_mm_subassign(*this,B);
03952 }
03953 
03954 inline cimatrix_slice& cimatrix_slice::operator-=(const scimatrix& B) {
03955   return fsp_mm_subassign(*this,B);
03956 }
03957 
03958 inline cimatrix& cimatrix::operator|=(const srmatrix& B) {
03959   return fsp_mm_hullassign(*this,B);
03960 }
03961 
03962 inline cimatrix& cimatrix::operator|=(const scmatrix& B) {
03963   return fsp_mm_hullassign(*this,B);
03964 }
03965 
03966 inline cimatrix& cimatrix::operator|=(const simatrix& B) {
03967   return fsp_mm_hullassign(*this,B);
03968 }
03969 
03970 inline cimatrix& cimatrix::operator|=(const scimatrix& B) {
03971   return fsp_mm_hullassign(*this,B);
03972 }
03973 
03974 inline cimatrix_slice& cimatrix_slice::operator|=(const srmatrix& B) {
03975   return fsp_mm_hullassign(*this,B);
03976 }
03977 
03978 inline cimatrix_slice& cimatrix_slice::operator|=(const scmatrix& B) {
03979   return fsp_mm_hullassign(*this,B);
03980 }
03981 
03982 inline cimatrix_slice& cimatrix_slice::operator|=(const simatrix& B) {
03983   return fsp_mm_hullassign(*this,B);
03984 }
03985 
03986 inline cimatrix_slice& cimatrix_slice::operator|=(const scimatrix& B) {
03987   return fsp_mm_hullassign(*this,B);
03988 }
03989 
03990 inline cimatrix& cimatrix::operator&=(const simatrix& B) {
03991   return fsp_mm_intersectassign(*this,B);
03992 }
03993 
03994 inline cimatrix& cimatrix::operator&=(const scimatrix& B) {
03995   return fsp_mm_intersectassign(*this,B);
03996 }
03997 
03998 inline cimatrix_slice& cimatrix_slice::operator&=(const simatrix& B) {
03999   return fsp_mm_intersectassign(*this,B);
04000 }
04001 
04002 inline cimatrix_slice& cimatrix_slice::operator&=(const scimatrix& B) {
04003   return fsp_mm_intersectassign(*this,B);
04004 }
04005 
04006 inline cimatrix& cimatrix::operator*=(const srmatrix& B) {
04007   return fsp_mm_multassign<cimatrix,srmatrix,sparse_cidot,cimatrix>(*this,B);
04008 }
04009 
04010 inline cimatrix& cimatrix::operator*=(const scmatrix& B) {
04011   return fsp_mm_multassign<cimatrix,scmatrix,sparse_cidot,cimatrix>(*this,B);
04012 }
04013 
04014 inline cimatrix& cimatrix::operator*=(const simatrix& B) {
04015   return fsp_mm_multassign<cimatrix,simatrix,sparse_cidot,cimatrix>(*this,B);
04016 }
04017 
04018 inline cimatrix& cimatrix::operator*=(const scimatrix& B) {
04019   return fsp_mm_multassign<cimatrix,scimatrix,sparse_cidot,cimatrix>(*this,B);
04020 }
04021 
04022 inline cimatrix_slice& cimatrix_slice::operator*=(const srmatrix& B) {
04023   return fsp_mm_multassign<cimatrix_slice,srmatrix,sparse_cidot,cimatrix>(*this,B);
04024 }
04025 
04026 inline cimatrix_slice& cimatrix_slice::operator*=(const scmatrix& B) {
04027   return fsp_mm_multassign<cimatrix_slice,scmatrix,sparse_cidot,cimatrix>(*this,B);
04028 }
04029 
04030 inline cimatrix_slice& cimatrix_slice::operator*=(const simatrix& B) {
04031   return fsp_mm_multassign<cimatrix_slice,simatrix,sparse_cidot,cimatrix>(*this,B);
04032 }
04033 
04034 inline cimatrix_slice& cimatrix_slice::operator*=(const scimatrix& B) {
04035   return fsp_mm_multassign<cimatrix_slice,scimatrix,sparse_cidot,cimatrix>(*this,B);
04036 }
04037 
04039 inline bool operator==(const scimatrix& A, const srmatrix& B) {
04040   return spsp_mm_comp(A,B);
04041 }
04042 
04044 inline bool operator==(const scimatrix& A, const scmatrix& B) {
04045   return spsp_mm_comp(A,B);
04046 }
04047 
04049 inline bool operator==(const scimatrix& A, const simatrix& B) {
04050   return spsp_mm_comp(A,B);
04051 }
04052 
04054 inline bool operator==(const scimatrix& A, const scimatrix& B) {
04055   return spsp_mm_comp(A,B);
04056 }
04057 
04059 inline bool operator==(const srmatrix& A, const scimatrix& B) {
04060   return spsp_mm_comp(A,B);
04061 }
04062 
04064 inline bool operator==(const scmatrix& A, const scimatrix& B) {
04065   return spsp_mm_comp(A,B);
04066 }
04067 
04069 inline bool operator==(const simatrix& A, const scimatrix& B) {
04070   return spsp_mm_comp(A,B);
04071 }
04072 
04074 inline bool operator==(const scimatrix& A, const rmatrix& B) {
04075   return spf_mm_comp(A,B);
04076 }
04077 
04079 inline bool operator==(const scimatrix& A, const imatrix& B) {
04080   return spf_mm_comp(A,B);
04081 }
04082 
04084 inline bool operator==(const scimatrix& A, const cmatrix& B) {
04085   return spf_mm_comp(A,B);
04086 }
04087 
04089 inline bool operator==(const scimatrix& A, const cimatrix& B) {
04090   return spf_mm_comp(A,B);
04091 }
04092 
04094 inline bool operator==(const srmatrix& A, const cimatrix& B) {
04095   return spf_mm_comp(A,B);
04096 }
04097 
04099 inline bool operator==(const scmatrix& A, const cimatrix& B) {
04100   return spf_mm_comp(A,B);
04101 }
04102 
04104 inline bool operator==(const simatrix& A, const cimatrix& B) {
04105   return spf_mm_comp(A,B);
04106 }
04107 
04109 inline bool operator==(const cimatrix& A, const srmatrix& B) {
04110   return fsp_mm_comp(A,B);
04111 }
04112 
04114 inline bool operator==(const cimatrix& A, const simatrix& B) {
04115   return fsp_mm_comp(A,B);
04116 }
04117 
04119 inline bool operator==(const cimatrix& A, const scmatrix& B) {
04120   return fsp_mm_comp(A,B);
04121 }
04122 
04124 inline bool operator==(const cimatrix& A, const scimatrix& B) {
04125   return fsp_mm_comp(A,B);
04126 }
04127 
04129 inline bool operator==(const rmatrix& A, const scimatrix& B) {
04130   return fsp_mm_comp(A,B);
04131 }
04132 
04134 inline bool operator==(const cmatrix& A, const scimatrix& B) {
04135   return fsp_mm_comp(A,B);
04136 }
04137 
04139 inline bool operator==(const imatrix& A, const scimatrix& B) {
04140   return fsp_mm_comp(A,B);
04141 }
04142 
04144 inline bool operator==(const cimatrix_slice& A, const srmatrix& B) {
04145   return fsp_mm_comp(A,B);
04146 }
04147 
04149 inline bool operator==(const cimatrix_slice& A, const scmatrix& B) {
04150   return fsp_mm_comp(A,B);
04151 }
04152 
04154 inline bool operator==(const cimatrix_slice& A, const simatrix& B) {
04155   return fsp_mm_comp(A,B);
04156 }
04157 
04159 inline bool operator==(const cimatrix_slice& A, const scimatrix& B) {
04160   return fsp_mm_comp(A,B);
04161 }
04162 
04164 inline bool operator==(const rmatrix_slice& A, const scimatrix& B) {
04165   return fsp_mm_comp(A,B);
04166 }
04167 
04169 inline bool operator==(const cmatrix_slice& A, const scimatrix& B) {
04170   return fsp_mm_comp(A,B);
04171 }
04172 
04174 inline bool operator==(const imatrix_slice& A, const scimatrix& B) {
04175   return fsp_mm_comp(A,B);
04176 }
04177 
04179 inline bool operator==(const scimatrix& A, const rmatrix_slice& B) {
04180   return spf_mm_comp(A,B);
04181 }
04182 
04184 inline bool operator==(const scimatrix& A, const imatrix_slice& B) {
04185   return spf_mm_comp(A,B);
04186 }
04187 
04189 inline bool operator==(const scimatrix& A, const cmatrix_slice& B) {
04190   return spf_mm_comp(A,B);
04191 }
04192 
04194 inline bool operator==(const scimatrix& A, const cimatrix_slice& B) {
04195   return spf_mm_comp(A,B);
04196 }
04197 
04199 inline bool operator==(const srmatrix& A, const cimatrix_slice& B) {
04200   return spf_mm_comp(A,B);
04201 }
04202 
04204 inline bool operator==(const scmatrix& A, const cimatrix_slice& B) {
04205   return spf_mm_comp(A,B);
04206 }
04207 
04209 inline bool operator==(const simatrix& A, const cimatrix_slice& B) {
04210   return spf_mm_comp(A,B);
04211 }
04212 
04214 inline bool operator!=(const scimatrix& A, const srmatrix& B) {
04215   return !spsp_mm_comp(A,B);
04216 }
04217 
04219 inline bool operator!=(const scimatrix& A, const scmatrix& B) {
04220   return !spsp_mm_comp(A,B);
04221 }
04222 
04224 inline bool operator!=(const scimatrix& A, const simatrix& B) {
04225   return !spsp_mm_comp(A,B);
04226 }
04227 
04229 inline bool operator!=(const scimatrix& A, const scimatrix& B) {
04230   return !spsp_mm_comp(A,B);
04231 }
04232 
04234 inline bool operator!=(const srmatrix& A, const scimatrix& B) {
04235   return !spsp_mm_comp(A,B);
04236 }
04237 
04239 inline bool operator!=(const scmatrix& A, const scimatrix& B) {
04240   return !spsp_mm_comp(A,B);
04241 }
04242 
04244 inline bool operator!=(const simatrix& A, const scimatrix& B) {
04245   return !spsp_mm_comp(A,B);
04246 }
04247 
04249 inline bool operator!=(const scimatrix& A, const rmatrix& B) {
04250   return !spf_mm_comp(A,B);
04251 }
04252 
04254 inline bool operator!=(const scimatrix& A, const imatrix& B) {
04255   return !spf_mm_comp(A,B);
04256 }
04257 
04259 inline bool operator!=(const scimatrix& A, const cmatrix& B) {
04260   return !spf_mm_comp(A,B);
04261 }
04262 
04264 inline bool operator!=(const scimatrix& A, const cimatrix& B) {
04265   return !spf_mm_comp(A,B);
04266 }
04267 
04269 inline bool operator!=(const srmatrix& A, const cimatrix& B) {
04270   return !spf_mm_comp(A,B);
04271 }
04272 
04274 inline bool operator!=(const scmatrix& A, const cimatrix& B) {
04275   return !spf_mm_comp(A,B);
04276 }
04277 
04279 inline bool operator!=(const simatrix& A, const cimatrix& B) {
04280   return !spf_mm_comp(A,B);
04281 }
04282 
04284 inline bool operator!=(const cimatrix& A, const srmatrix& B) {
04285   return !fsp_mm_comp(A,B);
04286 }
04287 
04289 inline bool operator!=(const cimatrix& A, const simatrix& B) {
04290   return !fsp_mm_comp(A,B);
04291 }
04292 
04294 inline bool operator!=(const cimatrix& A, const scmatrix& B) {
04295   return !fsp_mm_comp(A,B);
04296 }
04297 
04299 inline bool operator!=(const cimatrix& A, const scimatrix& B) {
04300   return !fsp_mm_comp(A,B);
04301 }
04302 
04304 inline bool operator!=(const rmatrix& A, const scimatrix& B) {
04305   return !fsp_mm_comp(A,B);
04306 }
04307 
04309 inline bool operator!=(const cmatrix& A, const scimatrix& B) {
04310   return !fsp_mm_comp(A,B);
04311 }
04312 
04314 inline bool operator!=(const imatrix& A, const scimatrix& B) {
04315   return !fsp_mm_comp(A,B);
04316 }
04317 
04319 inline bool operator!=(const cimatrix_slice& A, const srmatrix& B) {
04320   return !fsp_mm_comp(A,B);
04321 }
04322 
04324 inline bool operator!=(const cimatrix_slice& A, const scmatrix& B) {
04325   return !fsp_mm_comp(A,B);
04326 }
04327 
04329 inline bool operator!=(const cimatrix_slice& A, const simatrix& B) {
04330   return !fsp_mm_comp(A,B);
04331 }
04332 
04334 inline bool operator!=(const cimatrix_slice& A, const scimatrix& B) {
04335   return !fsp_mm_comp(A,B);
04336 }
04337 
04339 inline bool operator!=(const rmatrix_slice& A, const scimatrix& B) {
04340   return !fsp_mm_comp(A,B);
04341 }
04342 
04344 inline bool operator!=(const cmatrix_slice& A, const scimatrix& B) {
04345   return !fsp_mm_comp(A,B);
04346 }
04347 
04349 inline bool operator!=(const imatrix_slice& A, const scimatrix& B) {
04350   return !fsp_mm_comp(A,B);
04351 }
04352 
04354 inline bool operator!=(const scimatrix& A, const rmatrix_slice& B) {
04355   return !spf_mm_comp(A,B);
04356 }
04357 
04359 inline bool operator!=(const scimatrix& A, const imatrix_slice& B) {
04360   return !spf_mm_comp(A,B);
04361 }
04362 
04364 inline bool operator!=(const scimatrix& A, const cmatrix_slice& B) {
04365   return !spf_mm_comp(A,B);
04366 }
04367 
04369 inline bool operator!=(const scimatrix& A, const cimatrix_slice& B) {
04370   return !spf_mm_comp(A,B);
04371 }
04372 
04374 inline bool operator!=(const srmatrix& A, const cimatrix_slice& B) {
04375   return !spf_mm_comp(A,B);
04376 }
04377 
04379 inline bool operator!=(const scmatrix& A, const cimatrix_slice& B) {
04380   return !spf_mm_comp(A,B);
04381 }
04382 
04384 inline bool operator!=(const simatrix& A, const cimatrix_slice& B) {
04385   return !spf_mm_comp(A,B);
04386 }
04387 
04389 inline bool operator<(const scimatrix& A, const simatrix& B) {
04390   return spsp_mm_less<scimatrix,simatrix,cinterval>(A,B);
04391 }
04392 
04394 inline bool operator<(const scimatrix& A, const scimatrix& B) {
04395   return spsp_mm_less<scimatrix,scimatrix,cinterval>(A,B);
04396 }
04397 
04399 inline bool operator<(const srmatrix& A, const scimatrix& B) {
04400   return spsp_mm_less<srmatrix,scimatrix,cinterval>(A,B);
04401 }
04402 
04404 inline bool operator<(const scmatrix& A, const scimatrix& B) {
04405   return spsp_mm_less<scmatrix,scimatrix,cinterval>(A,B);
04406 }
04407 
04409 inline bool operator<(const simatrix& A, const scimatrix& B) {
04410   return spsp_mm_less<simatrix,scimatrix,cinterval>(A,B);
04411 }
04412 
04414 inline bool operator<(const scimatrix& A, const imatrix& B) {
04415   return spf_mm_less<scimatrix,imatrix,cinterval>(A,B);
04416 }
04417 
04419 inline bool operator<(const scimatrix& A, const cimatrix& B) {
04420   return spf_mm_less<scimatrix,cimatrix,cinterval>(A,B);
04421 }
04422 
04424 inline bool operator<(const srmatrix& A, const cimatrix& B) {
04425   return spf_mm_less<srmatrix,cimatrix,cinterval>(A,B);
04426 }
04427 
04429 inline bool operator<(const scmatrix& A, const cimatrix& B) {
04430   return spf_mm_less<scmatrix,cimatrix,cinterval>(A,B);
04431 }
04432 
04434 inline bool operator<(const simatrix& A, const cimatrix& B) {
04435   return spf_mm_less<simatrix,cimatrix,cinterval>(A,B);
04436 }
04437 
04439 inline bool operator<(const cimatrix& A, const simatrix& B) {
04440   return fsp_mm_less<cimatrix,simatrix,cinterval>(A,B);
04441 }
04442 
04444 inline bool operator<(const cimatrix& A, const scimatrix& B) {
04445   return fsp_mm_less<cimatrix,scimatrix,cinterval>(A,B);
04446 }
04447 
04449 inline bool operator<(const rmatrix& A, const scimatrix& B) {
04450   return fsp_mm_less<rmatrix,scimatrix,cinterval>(A,B);
04451 }
04452 
04454 inline bool operator<(const cmatrix& A, const scimatrix& B) {
04455   return fsp_mm_less<cmatrix,scimatrix,cinterval>(A,B);
04456 }
04457 
04459 inline bool operator<(const imatrix& A, const scimatrix& B) {
04460   return fsp_mm_less<imatrix,scimatrix,cinterval>(A,B);
04461 }
04462 
04464 inline bool operator<(const cimatrix_slice& A, const simatrix& B) {
04465   return fsp_mm_less<cimatrix_slice,simatrix,cinterval>(A,B);
04466 }
04467 
04469 inline bool operator<(const cimatrix_slice& A, const scimatrix& B) {
04470   return fsp_mm_less<cimatrix_slice,scimatrix,cinterval>(A,B);
04471 }
04472 
04474 inline bool operator<(const rmatrix_slice& A, const scimatrix& B) {
04475   return fsp_mm_less<rmatrix_slice,scimatrix,cinterval>(A,B);
04476 }
04477 
04479 inline bool operator<(const cmatrix_slice& A, const scimatrix& B) {
04480   return fsp_mm_less<cmatrix_slice,scimatrix,cinterval>(A,B);
04481 }
04482 
04484 inline bool operator<(const imatrix_slice& A, const scimatrix& B) {
04485   return fsp_mm_less<imatrix_slice,scimatrix,cinterval>(A,B);
04486 }
04487 
04489 inline bool operator<(const scimatrix& A, const imatrix_slice& B) {
04490   return spf_mm_less<scimatrix,imatrix_slice,cinterval>(A,B);
04491 }
04492 
04494 inline bool operator<(const scimatrix& A, const cimatrix_slice& B) {
04495   return spf_mm_less<scimatrix,cimatrix_slice,cinterval>(A,B);
04496 }
04497 
04499 inline bool operator<(const srmatrix& A, const cimatrix_slice& B) {
04500   return spf_mm_less<srmatrix,cimatrix_slice,cinterval>(A,B);
04501 }
04502 
04504 inline bool operator<(const scmatrix& A, const cimatrix_slice& B) {
04505   return spf_mm_less<scmatrix,cimatrix_slice,cinterval>(A,B);
04506 }
04507 
04509 inline bool operator<(const simatrix& A, const cimatrix_slice& B) {
04510   return spf_mm_less<simatrix,cimatrix_slice,cinterval>(A,B);
04511 }
04512 
04514 inline bool operator<=(const scimatrix& A, const simatrix& B) {
04515   return spsp_mm_leq<scimatrix,simatrix,cinterval>(A,B);
04516 }
04517 
04519 inline bool operator<=(const scimatrix& A, const scimatrix& B) {
04520   return spsp_mm_leq<scimatrix,scimatrix,cinterval>(A,B);
04521 }
04522 
04524 inline bool operator<=(const srmatrix& A, const scimatrix& B) {
04525   return spsp_mm_leq<srmatrix,scimatrix,cinterval>(A,B);
04526 }
04527 
04529 inline bool operator<=(const scmatrix& A, const scimatrix& B) {
04530   return spsp_mm_leq<scmatrix,scimatrix,cinterval>(A,B);
04531 }
04532 
04534 inline bool operator<=(const simatrix& A, const scimatrix& B) {
04535   return spsp_mm_leq<simatrix,scimatrix,cinterval>(A,B);
04536 }
04537 
04539 inline bool operator<=(const scimatrix& A, const imatrix& B) {
04540   return spf_mm_leq<scimatrix,imatrix,cinterval>(A,B);
04541 }
04542 
04544 inline bool operator<=(const scimatrix& A, const cimatrix& B) {
04545   return spf_mm_leq<scimatrix,cimatrix,cinterval>(A,B);
04546 }
04547 
04549 inline bool operator<=(const srmatrix& A, const cimatrix& B) {
04550   return spf_mm_leq<srmatrix,cimatrix,cinterval>(A,B);
04551 }
04552 
04554 inline bool operator<=(const scmatrix& A, const cimatrix& B) {
04555   return spf_mm_leq<scmatrix,cimatrix,cinterval>(A,B);
04556 }
04557 
04559 inline bool operator<=(const simatrix& A, const cimatrix& B) {
04560   return spf_mm_leq<simatrix,cimatrix,cinterval>(A,B);
04561 }
04562 
04564 inline bool operator<=(const cimatrix& A, const simatrix& B) {
04565   return fsp_mm_leq<cimatrix,simatrix,cinterval>(A,B);
04566 }
04567 
04569 inline bool operator<=(const cimatrix& A, const scimatrix& B) {
04570   return fsp_mm_leq<cimatrix,scimatrix,cinterval>(A,B);
04571 }
04572 
04574 inline bool operator<=(const rmatrix& A, const scimatrix& B) {
04575   return fsp_mm_leq<rmatrix,scimatrix,cinterval>(A,B);
04576 }
04577 
04579 inline bool operator<=(const cmatrix& A, const scimatrix& B) {
04580   return fsp_mm_leq<cmatrix,scimatrix,cinterval>(A,B);
04581 }
04582 
04584 inline bool operator<=(const imatrix& A, const scimatrix& B) {
04585   return fsp_mm_leq<imatrix,scimatrix,cinterval>(A,B);
04586 }
04587 
04589 inline bool operator<=(const cimatrix_slice& A, const simatrix& B) {
04590   return fsp_mm_leq<cimatrix_slice,simatrix,cinterval>(A,B);
04591 }
04592 
04594 inline bool operator<=(const cimatrix_slice& A, const scimatrix& B) {
04595   return fsp_mm_leq<cimatrix_slice,scimatrix,cinterval>(A,B);
04596 }
04597 
04599 inline bool operator<=(const rmatrix_slice& A, const scimatrix& B) {
04600   return fsp_mm_leq<rmatrix_slice,scimatrix,cinterval>(A,B);
04601 }
04602 
04604 inline bool operator<=(const cmatrix_slice& A, const scimatrix& B) {
04605   return fsp_mm_leq<cmatrix_slice,scimatrix,cinterval>(A,B);
04606 }
04607 
04609 inline bool operator<=(const imatrix_slice& A, const scimatrix& B) {
04610   return fsp_mm_leq<imatrix_slice,scimatrix,cinterval>(A,B);
04611 }
04612 
04614 inline bool operator<=(const scimatrix& A, const imatrix_slice& B) {
04615   return spf_mm_leq<scimatrix,imatrix_slice,cinterval>(A,B);
04616 }
04617 
04619 inline bool operator<=(const scimatrix& A, const cimatrix_slice& B) {
04620   return spf_mm_leq<scimatrix,cimatrix_slice,cinterval>(A,B);
04621 }
04622 
04624 inline bool operator<=(const srmatrix& A, const cimatrix_slice& B) {
04625   return spf_mm_leq<srmatrix,cimatrix_slice,cinterval>(A,B);
04626 }
04627 
04629 inline bool operator<=(const scmatrix& A, const cimatrix_slice& B) {
04630   return spf_mm_leq<scmatrix,cimatrix_slice,cinterval>(A,B);
04631 }
04632 
04634 inline bool operator<=(const simatrix& A, const cimatrix_slice& B) {
04635   return spf_mm_leq<simatrix,cimatrix_slice,cinterval>(A,B);
04636 }
04637 
04639 inline bool operator>(const scimatrix& A, const srmatrix& B) {
04640   return spsp_mm_greater<scimatrix,srmatrix,cinterval>(A,B);
04641 }
04642 
04644 inline bool operator>(const scimatrix& A, const scmatrix& B) {
04645   return spsp_mm_greater<scimatrix,scmatrix,cinterval>(A,B);
04646 }
04647 
04649 inline bool operator>(const scimatrix& A, const simatrix& B) {
04650   return spsp_mm_greater<scimatrix,simatrix,cinterval>(A,B);
04651 }
04652 
04654 inline bool operator>(const scimatrix& A, const scimatrix& B) {
04655   return spsp_mm_greater<scimatrix,scimatrix,cinterval>(A,B);
04656 }
04657 
04659 inline bool operator>(const simatrix& A, const scimatrix& B) {
04660   return spsp_mm_greater<simatrix,scimatrix,cinterval>(A,B);
04661 }
04662 
04664 inline bool operator>(const scimatrix& A, const rmatrix& B) {
04665   return spf_mm_greater<scimatrix,rmatrix,cinterval>(A,B);
04666 }
04667 
04669 inline bool operator>(const scimatrix& A, const imatrix& B) {
04670   return spf_mm_greater<scimatrix,imatrix,cinterval>(A,B);
04671 }
04672 
04674 inline bool operator>(const scimatrix& A, const cmatrix& B) {
04675   return spf_mm_greater<scimatrix,cmatrix,cinterval>(A,B);
04676 }
04677 
04679 inline bool operator>(const scimatrix& A, const cimatrix& B) {
04680   return spf_mm_greater<scimatrix,cimatrix,cinterval>(A,B);
04681 }
04682 
04684 inline bool operator>(const simatrix& A, const cimatrix& B) {
04685   return spf_mm_greater<simatrix,cimatrix,cinterval>(A,B);
04686 }
04687 
04689 inline bool operator>(const cimatrix& A, const srmatrix& B) {
04690   return fsp_mm_greater<cimatrix,srmatrix,cinterval>(A,B);
04691 }
04692 
04694 inline bool operator>(const cimatrix& A, const simatrix& B) {
04695   return fsp_mm_greater<cimatrix,simatrix,cinterval>(A,B);
04696 }
04697 
04699 inline bool operator>(const cimatrix& A, const scmatrix& B) {
04700   return fsp_mm_greater<cimatrix,scmatrix,cinterval>(A,B);
04701 }
04702 
04704 inline bool operator>(const cimatrix& A, const scimatrix& B) {
04705   return fsp_mm_greater<cimatrix,scimatrix,cinterval>(A,B);
04706 }
04707 
04709 inline bool operator>(const imatrix& A, const scimatrix& B) {
04710   return fsp_mm_greater<imatrix,scimatrix,cinterval>(A,B);
04711 }
04712 
04714 inline bool operator>(const cimatrix_slice& A, const srmatrix& B) {
04715   return fsp_mm_greater<cimatrix_slice,srmatrix,cinterval>(A,B);
04716 }
04717 
04719 inline bool operator>(const cimatrix_slice& A, const scmatrix& B) {
04720   return fsp_mm_greater<cimatrix_slice,scmatrix,cinterval>(A,B);
04721 }
04722 
04724 inline bool operator>(const cimatrix_slice& A, const simatrix& B) {
04725   return fsp_mm_greater<cimatrix_slice,simatrix,cinterval>(A,B);
04726 }
04727 
04729 inline bool operator>(const cimatrix_slice& A, const scimatrix& B) {
04730   return fsp_mm_greater<cimatrix_slice,scimatrix,cinterval>(A,B);
04731 }
04732 
04734 inline bool operator>(const imatrix_slice& A, const scimatrix& B) {
04735   return fsp_mm_greater<imatrix_slice,scimatrix,cinterval>(A,B);
04736 }
04737 
04739 inline bool operator>(const scimatrix& A, const rmatrix_slice& B) {
04740   return spf_mm_greater<scimatrix,rmatrix_slice,cinterval>(A,B);
04741 }
04742 
04744 inline bool operator>(const scimatrix& A, const imatrix_slice& B) {
04745   return spf_mm_greater<scimatrix,imatrix_slice,cinterval>(A,B);
04746 }
04747 
04749 inline bool operator>(const scimatrix& A, const cmatrix_slice& B) {
04750   return spf_mm_greater<scimatrix,cmatrix_slice,cinterval>(A,B);
04751 }
04752 
04754 inline bool operator>(const scimatrix& A, const cimatrix_slice& B) {
04755   return spf_mm_greater<scimatrix,cimatrix_slice,cinterval>(A,B);
04756 }
04757 
04759 inline bool operator>(const simatrix& A, const cimatrix_slice& B) {
04760   return spf_mm_greater<simatrix,cimatrix_slice,cinterval>(A,B);
04761 }
04762 
04764 inline bool operator>=(const scimatrix& A, const srmatrix& B) {
04765   return spsp_mm_geq<scimatrix,srmatrix,cinterval>(A,B);
04766 }
04767 
04769 inline bool operator>=(const scimatrix& A, const scmatrix& B) {
04770   return spsp_mm_geq<scimatrix,scmatrix,cinterval>(A,B);
04771 }
04772 
04774 inline bool operator>=(const scimatrix& A, const simatrix& B) {
04775   return spsp_mm_geq<scimatrix,simatrix,cinterval>(A,B);
04776 }
04777 
04779 inline bool operator>=(const scimatrix& A, const scimatrix& B) {
04780   return spsp_mm_geq<scimatrix,scimatrix,cinterval>(A,B);
04781 }
04782 
04784 inline bool operator>=(const simatrix& A, const scimatrix& B) {
04785   return spsp_mm_geq<simatrix,scimatrix,cinterval>(A,B);
04786 }
04787 
04789 inline bool operator>=(const scimatrix& A, const rmatrix& B) {
04790   return spf_mm_geq<scimatrix,rmatrix,cinterval>(A,B);
04791 }
04792 
04794 inline bool operator>=(const scimatrix& A, const imatrix& B) {
04795   return spf_mm_geq<scimatrix,imatrix,cinterval>(A,B);
04796 }
04797 
04799 inline bool operator>=(const scimatrix& A, const cmatrix& B) {
04800   return spf_mm_geq<scimatrix,cmatrix,cinterval>(A,B);
04801 }
04802 
04804 inline bool operator>=(const scimatrix& A, const cimatrix& B) {
04805   return spf_mm_geq<scimatrix,cimatrix,cinterval>(A,B);
04806 }
04807 
04809 inline bool operator>=(const simatrix& A, const cimatrix& B) {
04810   return spf_mm_geq<simatrix,cimatrix,cinterval>(A,B);
04811 }
04812 
04814 inline bool operator>=(const cimatrix& A, const srmatrix& B) {
04815   return fsp_mm_geq<cimatrix,srmatrix,cinterval>(A,B);
04816 }
04817 
04819 inline bool operator>=(const cimatrix& A, const simatrix& B) {
04820   return fsp_mm_geq<cimatrix,simatrix,cinterval>(A,B);
04821 }
04822 
04824 inline bool operator>=(const cimatrix& A, const scmatrix& B) {
04825   return fsp_mm_geq<cimatrix,scmatrix,cinterval>(A,B);
04826 }
04827 
04829 inline bool operator>=(const cimatrix& A, const scimatrix& B) {
04830   return fsp_mm_geq<cimatrix,scimatrix,cinterval>(A,B);
04831 }
04832 
04834 inline bool operator>=(const imatrix& A, const scimatrix& B) {
04835   return fsp_mm_geq<imatrix,scimatrix,cinterval>(A,B);
04836 }
04837 
04839 inline bool operator>=(const cimatrix_slice& A, const srmatrix& B) {
04840   return fsp_mm_geq<cimatrix_slice,srmatrix,cinterval>(A,B);
04841 }
04842 
04844 inline bool operator>=(const cimatrix_slice& A, const scmatrix& B) {
04845   return fsp_mm_geq<cimatrix_slice,scmatrix,cinterval>(A,B);
04846 }
04847 
04849 inline bool operator>=(const cimatrix_slice& A, const simatrix& B) {
04850   return fsp_mm_geq<cimatrix_slice,simatrix,cinterval>(A,B);
04851 }
04852 
04854 inline bool operator>=(const cimatrix_slice& A, const scimatrix& B) {
04855   return fsp_mm_geq<cimatrix_slice,scimatrix,cinterval>(A,B);
04856 }
04857 
04859 inline bool operator>=(const imatrix_slice& A, const scimatrix& B) {
04860   return fsp_mm_geq<imatrix_slice,scimatrix,cinterval>(A,B);
04861 }
04862 
04864 inline bool operator>=(const scimatrix& A, const rmatrix_slice& B) {
04865   return spf_mm_geq<scimatrix,rmatrix_slice,cinterval>(A,B);
04866 }
04867 
04869 inline bool operator>=(const scimatrix& A, const imatrix_slice& B) {
04870   return spf_mm_geq<scimatrix,imatrix_slice,cinterval>(A,B);
04871 }
04872 
04874 inline bool operator>=(const scimatrix& A, const cmatrix_slice& B) {
04875   return spf_mm_geq<scimatrix,cmatrix_slice,cinterval>(A,B);
04876 }
04877 
04879 inline bool operator>=(const scimatrix& A, const cimatrix_slice& B) {
04880   return spf_mm_geq<scimatrix,cimatrix_slice,cinterval>(A,B);
04881 }
04882 
04884 inline bool operator>=(const simatrix& A, const cimatrix_slice& B) {
04885   return spf_mm_geq<simatrix,cimatrix_slice,cinterval>(A,B);
04886 }
04887 
04889 inline bool operator!(const scimatrix& A) {
04890   return sp_m_not(A);
04891 }
04892 
04894 
04899 inline std::ostream& operator<<(std::ostream& os, const scimatrix& A) {
04900   return sp_m_output<scimatrix,cinterval>(os,A);
04901 }
04902 
04904 
04909 inline std::istream& operator>>(std::istream& is, scimatrix& A) {
04910   return sp_m_input<scimatrix,cinterval>(is,A);
04911 }
04912 
04914 
04918 class scimatrix_slice {
04919   public:
04920     scimatrix  A;
04921     scimatrix* M; //Originalmatrix
04922 
04923   private:
04924     scimatrix_slice(scimatrix& Mat, int sl1l, int sl1u, int sl2l, int sl2u) {    
04925         A.lb1 = sl1l;
04926         A.lb2 = sl2l;
04927         A.ub1 = sl1u;
04928         A.ub2 = sl2u;
04929         A.m   = sl1u-sl1l+1;
04930         A.n   = sl2u-sl2l+1;
04931  
04932         //Kopieren der Werte aus A
04933         A.p = std::vector<int>(A.n+1, 0);
04934         A.ind.reserve(A.m + A.n);
04935         A.x.reserve(A.m + A.n);
04936 
04937         for(int i=0 ; i<A.n ; i++) {
04938            A.p[i+1] = A.p[i];
04939            for(int j=Mat.p[sl2l-Mat.lb2+i] ; j<Mat.p[sl2l-Mat.lb2+i+1] ; j++) {
04940               if(Mat.ind[j] >= sl1l-Mat.lb1  &&  Mat.ind[j] <= sl1u-Mat.lb1) {
04941                 A.ind.push_back(Mat.ind[j]-(sl1l-Mat.lb1));
04942                 A.x.push_back(Mat.x[j]);
04943                 A.p[i+1]++;
04944               }
04945            }
04946         }
04947 
04948         //Zeiger auf A fuer Datenmanipulationen
04949         M = &Mat;
04950     }
04951 
04952     scimatrix_slice(const scimatrix& Mat, int sl1l, int sl1u, int sl2l, int sl2u) {    
04953         A.lb1 = sl1l;
04954         A.lb2 = sl2l;
04955         A.ub1 = sl1u;
04956         A.ub2 = sl2u;
04957         A.m   = sl1u-sl1l+1;
04958         A.n   = sl2u-sl2l+1;
04959  
04960         //Kopieren der Werte aus A
04961         A.p = std::vector<int>(A.n+1, 0);
04962         A.ind.reserve(A.m + A.n);
04963         A.x.reserve(A.m + A.n);
04964 
04965         for(int i=0 ; i<A.n ; i++) {
04966            A.p[i+1] = A.p[i];
04967            for(int j=Mat.p[sl2l-Mat.lb2+i] ; j<Mat.p[sl2l-Mat.lb2+i+1] ; j++) {
04968               if(Mat.ind[j] >= sl1l-Mat.lb1  &&  Mat.ind[j] <= sl1u-Mat.lb1) {
04969                 A.ind.push_back(Mat.ind[j]-(sl1l-Mat.lb1));
04970                 A.x.push_back(Mat.x[j]);
04971                 A.p[i+1]++;
04972               }
04973            }
04974         }
04975 
04976         //Zeiger auf A fuer Datenmanipulationen
04977         M = const_cast<scimatrix*>(&Mat);
04978     }
04979 
04980 
04981   public:
04982     
04984     scimatrix_slice& operator=(const real& C) {
04985       return sl_ms_assign<scimatrix_slice, real, std::vector<cinterval>::iterator, cinterval>(*this,C);
04986     }
04987 
04989     scimatrix_slice& operator=(const interval& C) {
04990       return sl_ms_assign<scimatrix_slice, interval, std::vector<cinterval>::iterator, cinterval>(*this,C);
04991     }
04992 
04994     scimatrix_slice& operator=(const complex& C) {
04995       return sl_ms_assign<scimatrix_slice, complex, std::vector<cinterval>::iterator, cinterval>(*this,C);
04996     }
04997 
04999     scimatrix_slice& operator=(const cinterval& C) {
05000       return sl_ms_assign<scimatrix_slice, cinterval, std::vector<cinterval>::iterator, cinterval>(*this,C);
05001     }
05002 
05004     scimatrix_slice& operator=(const srmatrix& C) {
05005       return slsp_mm_assign<scimatrix_slice, srmatrix, std::vector<cinterval>::iterator>(*this,C);
05006     }
05007 
05009     scimatrix_slice& operator=(const scmatrix& C) {
05010       return slsp_mm_assign<scimatrix_slice, scmatrix, std::vector<cinterval>::iterator>(*this,C);
05011     }
05012 
05014     scimatrix_slice& operator=(const simatrix& C) {
05015       return slsp_mm_assign<scimatrix_slice, simatrix, std::vector<cinterval>::iterator>(*this,C);
05016     }
05017 
05019     scimatrix_slice& operator=(const scimatrix& C) {
05020       return slsp_mm_assign<scimatrix_slice, scimatrix, std::vector<cinterval>::iterator>(*this,C);
05021     }
05022 
05024     scimatrix_slice& operator=(const rmatrix& C) {
05025       return slf_mm_assign<scimatrix_slice, rmatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
05026     }
05027 
05029     scimatrix_slice& operator=(const cmatrix& C) {
05030       return slf_mm_assign<scimatrix_slice, cmatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
05031     }
05032 
05034     scimatrix_slice& operator=(const imatrix& C) {
05035       return slf_mm_assign<scimatrix_slice, imatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
05036     }
05037 
05039     scimatrix_slice& operator=(const cimatrix& C) {
05040       return slf_mm_assign<scimatrix_slice, cimatrix, std::vector<cinterval>::iterator, cinterval>(*this,C);
05041     }
05042 
05044     scimatrix_slice& operator=(const rmatrix_slice& C) {
05045       return slf_mm_assign<scimatrix_slice, rmatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
05046     }
05047 
05049     scimatrix_slice& operator=(const cmatrix_slice& C) {
05050       return slf_mm_assign<scimatrix_slice, cmatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
05051     }
05052 
05054     scimatrix_slice& operator=(const imatrix_slice& C) {
05055       return slf_mm_assign<scimatrix_slice, imatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
05056     }
05057 
05059     scimatrix_slice& operator=(const cimatrix_slice& C) {
05060       return slf_mm_assign<scimatrix_slice, cimatrix_slice, std::vector<cinterval>::iterator, cinterval>(*this,C);
05061     }
05062 
05064     scimatrix_slice& operator=(const srmatrix_slice& C) {
05065       *this = C.A;
05066       return *this;
05067     }
05068 
05070     scimatrix_slice& operator=(const scmatrix_slice& C) {
05071       *this = C.A;
05072       return *this;
05073     }
05074 
05076     scimatrix_slice& operator=(const simatrix_slice& C) {
05077       *this = C.A;
05078       return *this;
05079     }
05080 
05082     scimatrix_slice& operator=(const scimatrix_slice& C) {
05083       *this = C.A;
05084       return *this;
05085     }
05086 
05088     scimatrix_slice& operator*=(const srmatrix_slice& M) {
05089       *this = A*M.A;
05090       return *this;
05091     }
05092 
05094     scimatrix_slice& operator*=(const scmatrix_slice& M) {
05095       *this = A*M.A;
05096       return *this;
05097     }
05098 
05100     scimatrix_slice& operator*=(const simatrix_slice& M) {
05101       *this = A*M.A;
05102       return *this;
05103     }
05104 
05106     scimatrix_slice& operator*=(const scimatrix_slice& M) {
05107       *this = A*M.A;
05108       return *this;
05109     }
05110 
05112     scimatrix_slice& operator*=(const srmatrix& M) {
05113       *this = A*M;
05114       return *this;
05115     }
05116 
05118     scimatrix_slice& operator*=(const scmatrix& M) {
05119       *this = A*M;
05120       return *this;
05121     }
05122 
05124     scimatrix_slice& operator*=(const simatrix& M) {
05125       *this = A*M;
05126       return *this;
05127     }
05128 
05130     scimatrix_slice& operator*=(const scimatrix& M) {
05131       *this = A*M;
05132       return *this;
05133     }
05134 
05136     scimatrix_slice& operator*=(const rmatrix& M) {
05137       *this = A*M;
05138       return *this;
05139     }
05140 
05142     scimatrix_slice& operator*=(const cmatrix& M) {
05143       *this = A*M;
05144       return *this;
05145     }
05146 
05148     scimatrix_slice& operator*=(const imatrix& M) {
05149       *this = A*M;
05150       return *this;
05151     }
05152 
05154     scimatrix_slice& operator*=(const cimatrix& M) {
05155       *this = A*M;
05156       return *this;
05157     }
05158 
05160     scimatrix_slice& operator*=(const rmatrix_slice& M) {
05161       *this = A*M;
05162       return *this;
05163     }
05164 
05166     scimatrix_slice& operator*=(const cmatrix_slice& M) {
05167       *this = A*M;
05168       return *this;
05169     }
05170 
05172     scimatrix_slice& operator*=(const imatrix_slice& M) {
05173       *this = A*M;
05174       return *this;
05175     }
05176 
05178     scimatrix_slice& operator*=(const cimatrix_slice& M) {
05179       *this = A*M;
05180       return *this;
05181     }
05182 
05184     scimatrix_slice& operator*=(const real& r) {
05185       *this = A*r;
05186       return *this;
05187     }
05188 
05190     scimatrix_slice& operator*=(const complex& r) {
05191       *this = A*r;
05192       return *this;
05193     }
05194 
05196     scimatrix_slice& operator*=(const interval& r) {
05197       *this = A*r;
05198       return *this;
05199     }
05200 
05202     scimatrix_slice& operator*=(const cinterval& r) {
05203       *this = A*r;
05204       return *this;
05205     }
05206 
05208     scimatrix_slice& operator/=(const real& r) {
05209       *this = A/r;
05210       return *this;
05211     }
05212 
05214     scimatrix_slice& operator/=(const complex& r) {
05215       *this = A/r;
05216       return *this;
05217     }
05218 
05220     scimatrix_slice& operator/=(const interval& r) {
05221       *this = A/r;
05222       return *this;
05223     }
05224 
05226     scimatrix_slice& operator/=(const cinterval& r) {
05227       *this = A/r;
05228       return *this;
05229     }
05230 
05232     scimatrix_slice& operator+=(const srmatrix_slice& M) {
05233       *this = A+M.A;
05234       return *this;
05235     } 
05236 
05238     scimatrix_slice& operator+=(const scmatrix_slice& M) {
05239       *this = A+M.A;
05240       return *this;
05241     } 
05242 
05244     scimatrix_slice& operator+=(const simatrix_slice& M) {
05245       *this = A+M.A;
05246       return *this;
05247     } 
05248 
05250     scimatrix_slice& operator+=(const scimatrix_slice& M) {
05251       *this = A+M.A;
05252       return *this;
05253     } 
05254 
05256     scimatrix_slice& operator+=(const srmatrix& M) {
05257       *this = A+M;
05258       return *this;
05259     } 
05260 
05262     scimatrix_slice& operator+=(const scmatrix& M) {
05263       *this = A+M;
05264       return *this;
05265     } 
05266 
05268     scimatrix_slice& operator+=(const simatrix& M) {
05269       *this = A+M;
05270       return *this;
05271     } 
05272 
05274     scimatrix_slice& operator+=(const scimatrix& M) {
05275       *this = A+M;
05276       return *this;
05277     } 
05278 
05280     scimatrix_slice& operator+=(const rmatrix& M) {
05281       *this = A+M;
05282       return *this;
05283     } 
05284 
05286     scimatrix_slice& operator+=(const cmatrix& M) {
05287       *this = A+M;
05288       return *this;
05289     } 
05290 
05292     scimatrix_slice& operator+=(const imatrix& M) {
05293       *this = A+M;
05294       return *this;
05295     } 
05296 
05298     scimatrix_slice& operator+=(const cimatrix& M) {
05299       *this = A+M;
05300       return *this;
05301     } 
05302 
05304     scimatrix_slice& operator+=(const rmatrix_slice& M) {
05305       *this = A+M;
05306       return *this;
05307     } 
05308 
05310     scimatrix_slice& operator+=(const cmatrix_slice& M) {
05311       *this = A+M;
05312       return *this;
05313     } 
05314 
05316     scimatrix_slice& operator+=(const imatrix_slice& M) {
05317       *this = A+M;
05318       return *this;
05319     } 
05320 
05322     scimatrix_slice& operator+=(const cimatrix_slice& M) {
05323       *this = A+M;
05324       return *this;
05325     } 
05326 
05328     scimatrix_slice& operator-=(const srmatrix_slice& M) {
05329       *this = A-M.A;
05330       return *this;
05331     } 
05332 
05334     scimatrix_slice& operator-=(const scmatrix_slice& M) {
05335       *this = A-M.A;
05336       return *this;
05337     } 
05338 
05340     scimatrix_slice& operator-=(const simatrix_slice& M) {
05341       *this = A-M.A;
05342       return *this;
05343     } 
05344 
05346     scimatrix_slice& operator-=(const scimatrix_slice& M) {
05347       *this = A-M.A;
05348       return *this;
05349     } 
05350 
05352     scimatrix_slice& operator-=(const srmatrix& M) {
05353       *this = A-M;
05354       return *this;
05355     } 
05356 
05358     scimatrix_slice& operator-=(const scmatrix& M) {
05359       *this = A-M;
05360       return *this;
05361     } 
05362 
05364     scimatrix_slice& operator-=(const simatrix& M) {
05365       *this = A-M;
05366       return *this;
05367     } 
05368 
05370     scimatrix_slice& operator-=(const scimatrix& M) {
05371       *this = A-M;
05372       return *this;
05373     } 
05374 
05376     scimatrix_slice& operator-=(const rmatrix& M) {
05377       *this = A-M;
05378       return *this;
05379     } 
05380 
05382     scimatrix_slice& operator-=(const cmatrix& M) {
05383       *this = A-M;
05384       return *this;
05385     } 
05386 
05388     scimatrix_slice& operator-=(const imatrix& M) {
05389       *this = A-M;
05390       return *this;
05391     } 
05392 
05394     scimatrix_slice& operator-=(const cimatrix& M) {
05395       *this = A-M;
05396       return *this;
05397     } 
05398 
05400     scimatrix_slice& operator-=(const rmatrix_slice& M) {
05401       *this = A-M;
05402       return *this;
05403     }
05404 
05406     scimatrix_slice& operator-=(const cmatrix_slice& M) {
05407       *this = A-M;
05408       return *this;
05409     }
05410 
05412     scimatrix_slice& operator-=(const imatrix_slice& M) {
05413       *this = A-M;
05414       return *this;
05415     }
05416 
05418     scimatrix_slice& operator-=(const cimatrix_slice& M) {
05419       *this = A-M;
05420       return *this;
05421     }
05422 
05424     scimatrix_slice& operator|=(const srmatrix_slice& M) {
05425       *this = A|M.A;
05426       return *this;
05427     } 
05428 
05430     scimatrix_slice& operator|=(const scmatrix_slice& M) {
05431       *this = A|M.A;
05432       return *this;
05433     } 
05434 
05436     scimatrix_slice& operator|=(const simatrix_slice& M) {
05437       *this = A|M.A;
05438       return *this;
05439     } 
05440 
05442     scimatrix_slice& operator|=(const scimatrix_slice& M) {
05443       *this = A|M.A;
05444       return *this;
05445     } 
05446 
05448     scimatrix_slice& operator|=(const srmatrix& M) {
05449       *this = A|M;
05450       return *this;
05451     } 
05452 
05454     scimatrix_slice& operator|=(const scmatrix& M) {
05455       *this = A|M;
05456       return *this;
05457     } 
05458 
05460     scimatrix_slice& operator|=(const simatrix& M) {
05461       *this = A|M;
05462       return *this;
05463     } 
05464 
05466     scimatrix_slice& operator|=(const scimatrix& M) {
05467       *this = A|M;
05468       return *this;
05469     } 
05470 
05472     scimatrix_slice& operator|=(const rmatrix& M) {
05473       *this = A|M;
05474       return *this;
05475     } 
05476 
05478     scimatrix_slice& operator|=(const cmatrix& M) {
05479       *this = A|M;
05480       return *this;
05481     } 
05482 
05484     scimatrix_slice& operator|=(const imatrix& M) {
05485       *this = A|M;
05486       return *this;
05487     } 
05488 
05490     scimatrix_slice& operator|=(const cimatrix& M) {
05491       *this = A|M;
05492       return *this;
05493     } 
05494 
05496     scimatrix_slice& operator|=(const rmatrix_slice& M) {
05497       *this = A|M;
05498       return *this;
05499     } 
05500 
05502     scimatrix_slice& operator|=(const cmatrix_slice& M) {
05503       *this = A|M;
05504       return *this;
05505     } 
05506 
05508     scimatrix_slice& operator|=(const imatrix_slice& M) {
05509       *this = A|M;
05510       return *this;
05511     } 
05512 
05514     scimatrix_slice& operator|=(const cimatrix_slice& M) {
05515       *this = A|M;
05516       return *this;
05517     } 
05518 
05520 
05524     const cinterval operator()(const int i, const int j) const {
05525 #if(CXSC_INDEX_CHECK)
05526       if(i<A.lb1 || i>A.ub1 || j<A.lb2 || j>A.ub2)
05527         cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_slice::operator()(int, int)"));
05528 #endif
05529       cinterval r = A(i,j);
05530       return r;
05531     }
05532 
05534 
05538     cinterval& element(const int i, const int j) {
05539 #if(CXSC_INDEX_CHECK)
05540       if(i<A.lb1 || i>A.ub1 || j<A.lb2 || j>A.ub2)
05541         cxscthrow(ELEMENT_NOT_IN_VEC("scimatrix_slice::element(int, int)"));
05542 #endif
05543       return M->element(i,j);
05544     }
05545 
05547     scimatrix_subv operator[](const int);
05549     scimatrix_subv operator[](const cxscmatrix_column&);
05551     const scimatrix_subv operator[](const int) const;
05553     const scimatrix_subv operator[](const cxscmatrix_column&) const;
05554 
05555     friend std::ostream& operator<<(std::ostream&, const scimatrix_slice&);
05556 
05557     friend int Lb(const scimatrix_slice&, const int);
05558     friend int Ub(const scimatrix_slice&, const int);
05559     friend simatrix Re(const scimatrix_slice&);
05560     friend simatrix Im(const scimatrix_slice&);
05561     friend scmatrix Inf(const scimatrix_slice&);
05562     friend scmatrix Sup(const scimatrix_slice&);
05563     friend srmatrix InfRe(const scimatrix_slice&);
05564     friend srmatrix InfIm(const scimatrix_slice&);
05565     friend srmatrix SupRe(const scimatrix_slice&);
05566     friend srmatrix SupIm(const scimatrix_slice&);
05567     friend int RowLen(const scimatrix_slice&);
05568     friend int ColLen(const scimatrix_slice&);
05569 
05570     friend class srmatrix;
05571     friend class srmatrix_subv;
05572     friend class srvector;
05573     friend class scmatrix;
05574     friend class scmatrix_subv;
05575     friend class scvector;
05576     friend class simatrix;
05577     friend class simatrix_subv;
05578     friend class sivector;
05579     friend class scimatrix;
05580     friend class scimatrix_subv;
05581     friend class scivector;
05582 
05583 #include "matrix_friend_declarations.inl"    
05584 };
05585 
05586 inline cimatrix::cimatrix(const srmatrix_slice& A) {
05587   dat = new cinterval[A.A.m*A.A.n];
05588   lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
05589   xsize = A.A.n;
05590   ysize = A.A.m;
05591   *this = 0.0;
05592   for(int j=0 ; j<A.A.n ; j++) {
05593      for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
05594         dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
05595      }
05596   }
05597 }
05598 
05599 inline cimatrix::cimatrix(const scmatrix_slice& A) {
05600   dat = new cinterval[A.A.m*A.A.n];
05601   lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
05602   xsize = A.A.n;
05603   ysize = A.A.m;
05604   *this = 0.0;
05605   for(int j=0 ; j<A.A.n ; j++) {
05606      for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
05607         dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
05608      }
05609   }
05610 }
05611 
05612 inline cimatrix::cimatrix(const simatrix_slice& A) {
05613   dat = new cinterval[A.A.m*A.A.n];
05614   lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
05615   xsize = A.A.n;
05616   ysize = A.A.m;
05617   *this = 0.0;
05618   for(int j=0 ; j<A.A.n ; j++) {
05619      for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
05620         dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
05621      }
05622   }
05623 }
05624 
05625 inline cimatrix::cimatrix(const scimatrix_slice& A) {
05626   dat = new cinterval[A.A.m*A.A.n];
05627   lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
05628   xsize = A.A.n;
05629   ysize = A.A.m;
05630   *this = 0.0;
05631   for(int j=0 ; j<A.A.n ; j++) {
05632      for(int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
05633         dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
05634      }
05635   }
05636 }
05637 
05639 inline int RowLen(const scimatrix_slice& S) {
05640   return RowLen(S.A);
05641 }
05642 
05644 inline int ColLen(const scimatrix_slice& S) {
05645   return ColLen(S.A);
05646 }
05647 
05648 inline scimatrix_slice scimatrix::operator()(const int i, const int j, const int k, const int l) {
05649 #if(CXSC_INDEX_CHECK)
05650   if(i<lb1 || j>ub1 || k<lb2 || l>ub2)
05651     cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator()(int, int, int, int)"));
05652 #endif
05653   return scimatrix_slice(*this, i, j, k, l);
05654 }
05655 
05656 inline const scimatrix_slice scimatrix::operator()(const int i, const int j, const int k, const int l) const{
05657 #if(CXSC_INDEX_CHECK)
05658   if(i<lb1 || j>ub1 || k<lb2 || l>ub2)
05659     cxscthrow(ROW_OR_COL_NOT_IN_MAT("scimatrix::operator()(int, int, int, int) const"));
05660 #endif
05661   return scimatrix_slice(*this, i, j, k, l);
05662 }
05663 
05664 inline scimatrix& scimatrix::operator=(const srmatrix_slice& S) {
05665   *this = S.A;
05666   return *this;
05667 }
05668 
05669 inline scimatrix& scimatrix::operator=(const scmatrix_slice& S) {
05670   *this = S.A;
05671   return *this;
05672 }
05673 
05674 inline scimatrix& scimatrix::operator=(const simatrix_slice& S) {
05675   *this = S.A;
05676   return *this;
05677 }
05678 
05679 inline scimatrix& scimatrix::operator=(const scimatrix_slice& S) {
05680   *this = S.A;
05681   return *this;
05682 }
05683 
05685 inline int Lb(const scimatrix_slice& S, const int i) {
05686   return Lb(S.A, i);
05687 }
05688 
05690 inline int Ub(const scimatrix_slice& S, const int i) {
05691   return Ub(S.A, i);
05692 }
05693 
05695 inline simatrix Re(const scimatrix_slice& S) {
05696   return Re(S.A);
05697 }
05698 
05700 inline simatrix Im(const scimatrix_slice& S) {
05701   return Im(S.A);
05702 }
05703 
05705 inline scimatrix conj(const scimatrix_slice& S) {
05706   return conj(S.A);
05707 }
05708 
05710 inline simatrix abs(const scimatrix_slice& S) {
05711   return abs(S.A);
05712 }
05713 
05715 inline scmatrix mid(const scimatrix_slice& S) {
05716   return mid(S.A);
05717 }
05718 
05720 inline scmatrix diam(const scimatrix_slice& S) {
05721   return diam(S.A);
05722 }
05723 
05725 inline scmatrix Inf(const scimatrix_slice& S) {
05726   return Inf(S.A);
05727 }
05728 
05730 inline scmatrix Sup(const scimatrix_slice& S) {
05731   return Sup(S.A);
05732 }
05733 
05735 inline srmatrix InfRe(const scimatrix_slice& S) {
05736   return InfRe(S.A);
05737 }
05738 
05740 inline srmatrix InfIm(const scimatrix_slice& S) {
05741   return InfIm(S.A);
05742 }
05743 
05745 inline srmatrix SupRe(const scimatrix_slice& S) {
05746   return SupRe(S.A);
05747 }
05748 
05750 inline srmatrix SupIm(const scimatrix_slice& S) {
05751   return SupIm(S.A);
05752 }
05753 
05754 inline scimatrix::scimatrix(const srmatrix_slice& S) {
05755   m = S.A.m;
05756   n = S.A.n;
05757   lb1 = S.A.lb1;
05758   ub1 = S.A.ub1;
05759   lb2 = S.A.lb2;
05760   ub2 = S.A.ub2;
05761   *this = S.A;
05762 }
05763 
05764 inline scimatrix::scimatrix(const scmatrix_slice& S) {
05765   m = S.A.m;
05766   n = S.A.n;
05767   lb1 = S.A.lb1;
05768   ub1 = S.A.ub1;
05769   lb2 = S.A.lb2;
05770   ub2 = S.A.ub2;
05771   *this = S.A;
05772 }
05773 
05774 inline scimatrix::scimatrix(const simatrix_slice& S) {
05775   m = S.A.m;
05776   n = S.A.n;
05777   lb1 = S.A.lb1;
05778   ub1 = S.A.ub1;
05779   lb2 = S.A.lb2;
05780   ub2 = S.A.ub2;
05781   *this = S.A;
05782 }
05783 
05784 inline scimatrix::scimatrix(const scimatrix_slice& S) {
05785   m = S.A.m;
05786   n = S.A.n;
05787   lb1 = S.A.lb1;
05788   ub1 = S.A.ub1;
05789   lb2 = S.A.lb2;
05790   ub2 = S.A.ub2;
05791   *this = S.A;
05792 }
05793 
05795 inline scimatrix operator-(const scimatrix_slice& M) {
05796   return sp_m_negative<scimatrix,scimatrix>(M.A);
05797 }
05798 
05800 inline scimatrix operator+(const scimatrix_slice& M) {
05801   return M.A;
05802 }
05803 
05805 
05811 inline scimatrix operator*(const scimatrix_slice& M1, const srmatrix_slice& M2) {
05812   return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05813 }
05814 
05816 
05822 inline scimatrix operator*(const scimatrix_slice& M1, const simatrix_slice& M2) {
05823   return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05824 }
05825 
05827 
05833 inline scimatrix operator*(const scimatrix_slice& M1, const scmatrix_slice& M2) {
05834   return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05835 }
05836 
05838 
05844 inline scimatrix operator*(const scimatrix_slice& M1, const scimatrix_slice& M2) {
05845   return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05846 }
05847 
05849 
05855 inline scimatrix operator*(const srmatrix_slice& M1, const scimatrix_slice& M2) {
05856   return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05857 }
05858 
05860 
05866 inline scimatrix operator*(const scmatrix_slice& M1, const scimatrix_slice& M2) {
05867   return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05868 }
05869 
05871 
05877 inline scimatrix operator*(const simatrix_slice& M1, const scimatrix_slice& M2) {
05878   return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05879 }
05880 
05882 
05888 inline scimatrix operator*(const simatrix_slice& M1, const scmatrix_slice& M2) {
05889   return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05890 }
05891 
05893 
05899 inline scimatrix operator*(const scmatrix_slice& M1, const simatrix_slice& M2) {
05900   return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
05901 }
05902 
05904 
05910 inline scimatrix operator*(const scimatrix_slice& M1, const srmatrix& M2) {
05911   return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05912 }
05913 
05915 
05921 inline scimatrix operator*(const scimatrix_slice& M1, const scmatrix& M2) {
05922   return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05923 }
05924 
05926 
05932 inline scimatrix operator*(const scimatrix_slice& M1, const simatrix& M2) {
05933   return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05934 }
05935 
05937 
05943 inline scimatrix operator*(const scimatrix_slice& M1, const scimatrix& M2) {
05944   return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05945 }
05946 
05948 
05954 inline scimatrix operator*(const srmatrix_slice& M1, const scimatrix& M2) {
05955   return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05956 }
05957 
05959 
05965 inline scimatrix operator*(const simatrix_slice& M1, const scimatrix& M2) {
05966   return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05967 }
05968 
05970 
05976 inline scimatrix operator*(const scmatrix_slice& M1, const scimatrix& M2) {
05977   return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05978 }
05979 
05981 
05987 inline scimatrix operator*(const simatrix_slice& M1, const scmatrix& M2) {
05988   return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
05989 }
05990 
05992 
05998 inline scimatrix operator*(const scmatrix_slice& M1, const simatrix& M2) {
05999   return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
06000 }
06001 
06003 
06009 inline scimatrix operator*(const scimatrix& M1, const srmatrix_slice& M2) {
06010   return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06011 }
06012 
06014 
06020 inline scimatrix operator*(const scimatrix& M1, const scmatrix_slice& M2) {
06021   return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06022 }
06023 
06025 
06031 inline scimatrix operator*(const scimatrix& M1, const simatrix_slice& M2) {
06032   return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06033 }
06034 
06036 
06042 inline scimatrix operator*(const scimatrix& M1, const scimatrix_slice& M2) {
06043   return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06044 }
06045 
06047 
06053 inline scimatrix operator*(const srmatrix& M1, const scimatrix_slice& M2) {
06054   return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06055 }
06056 
06058 
06064 inline scimatrix operator*(const scmatrix& M1, const scimatrix_slice& M2) {
06065   return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06066 }
06067 
06069 
06075 inline scimatrix operator*(const simatrix& M1, const scimatrix_slice& M2) {
06076   return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06077 }
06078 
06080 
06086 inline scimatrix operator*(const simatrix& M1, const scmatrix_slice& M2) {
06087   return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06088 }
06089 
06091 
06097 inline scimatrix operator*(const scmatrix& M1, const simatrix_slice& M2) {
06098   return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
06099 }
06100 
06102 
06108 inline cimatrix operator*(const scimatrix_slice& M1, const rmatrix& M2) {
06109   return spf_mm_mult<scimatrix,rmatrix,cimatrix,sparse_cidot>(M1.A,M2);
06110 }
06111 
06113 
06119 inline cimatrix operator*(const scimatrix_slice& M1, const imatrix& M2) {
06120   return spf_mm_mult<scimatrix,imatrix,cimatrix,sparse_cidot>(M1.A,M2);
06121 }
06122 
06124 
06130 inline cimatrix operator*(const scimatrix_slice& M1, const cmatrix& M2) {
06131   return spf_mm_mult<scimatrix,cmatrix,cimatrix,sparse_cidot>(M1.A,M2);
06132 }
06133 
06135 
06141 inline cimatrix operator*(const scimatrix_slice& M1, const cimatrix& M2) {
06142   return spf_mm_mult<scimatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
06143 }
06144 
06146 
06152 inline cimatrix operator*(const srmatrix_slice& M1, const cimatrix& M2) {
06153   return spf_mm_mult<srmatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
06154 }
06155 
06157 
06163 inline cimatrix operator*(const simatrix_slice& M1, const cimatrix& M2) {
06164   return spf_mm_mult<simatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
06165 }
06166 
06168 
06174 inline cimatrix operator*(const scmatrix_slice& M1, const cimatrix& M2) {
06175   return spf_mm_mult<scmatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
06176 }
06177 
06179 
06185 inline cimatrix operator*(const simatrix_slice& M1, const cmatrix& M2) {
06186   return spf_mm_mult<simatrix,cmatrix,cimatrix,sparse_cidot>(M1.A,M2);
06187 }
06188 
06190 
06196 inline cimatrix operator*(const scmatrix_slice& M1, const imatrix& M2) {
06197   return spf_mm_mult<scmatrix,imatrix,cimatrix,sparse_cidot>(M1.A,M2);
06198 }
06199 
06201 
06207 inline cimatrix operator*(const cimatrix& M1, const srmatrix_slice& M2) {
06208   return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(M1,M2.A);
06209 }
06210 
06212 
06218 inline cimatrix operator*(const cimatrix& M1, const scmatrix_slice& M2) {
06219   return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
06220 }
06221 
06223 
06229 inline cimatrix operator*(const cimatrix& M1, const simatrix_slice& M2) {
06230   return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
06231 }
06232 
06234 
06240 inline cimatrix operator*(const cimatrix& M1, const scimatrix_slice& M2) {
06241   return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06242 }
06243 
06245 
06251 inline cimatrix operator*(const rmatrix& M1, const scimatrix_slice& M2) {
06252   return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06253 }
06254 
06256 
06262 inline cimatrix operator*(const cmatrix& M1, const scimatrix_slice& M2) {
06263   return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06264 }
06265 
06267 
06273 inline cimatrix operator*(const imatrix& M1, const scimatrix_slice& M2) {
06274   return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06275 }
06276 
06278 
06284 inline cimatrix operator*(const imatrix& M1, const scmatrix_slice& M2) {
06285   return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
06286 }
06287 
06289 
06295 inline cimatrix operator*(const cmatrix& M1, const simatrix_slice& M2) {
06296   return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
06297 }
06298 
06300 
06306 inline cimatrix operator*(const scimatrix_slice& M1, const rmatrix_slice& M2) {
06307   return spf_mm_mult<scimatrix,rmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06308 }
06309 
06311 
06317 inline cimatrix operator*(const scimatrix_slice& M1, const cmatrix_slice& M2) {
06318   return spf_mm_mult<scimatrix,cmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06319 }
06320 
06322 
06328 inline cimatrix operator*(const scimatrix_slice& M1, const imatrix_slice& M2) {
06329   return spf_mm_mult<scimatrix,imatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06330 }
06331 
06333 
06339 inline cimatrix operator*(const scimatrix_slice& M1, const cimatrix_slice& M2) {
06340   return spf_mm_mult<scimatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06341 }
06342 
06344 
06350 inline cimatrix operator*(const srmatrix_slice& M1, const cimatrix_slice& M2) {
06351   return spf_mm_mult<srmatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06352 }
06353 
06355 
06361 inline cimatrix operator*(const simatrix_slice& M1, const cimatrix_slice& M2) {
06362   return spf_mm_mult<simatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06363 }
06364 
06366 
06372 inline cimatrix operator*(const scmatrix_slice& M1, const cimatrix_slice& M2) {
06373   return spf_mm_mult<scmatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06374 }
06375 
06377 
06383 inline cimatrix operator*(const simatrix_slice& M1, const cmatrix_slice& M2) {
06384   return spf_mm_mult<simatrix,cmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06385 }
06386 
06388 
06394 inline cimatrix operator*(const scmatrix_slice& M1, const imatrix_slice& M2) {
06395   return spf_mm_mult<scmatrix,imatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
06396 }
06397 
06399 
06405 inline cimatrix operator*(const cimatrix_slice& M1, const srmatrix_slice& M2) {
06406   return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(M1,M2.A);
06407 }
06408 
06410 
06416 inline cimatrix operator*(const cimatrix_slice& M1, const scmatrix_slice& M2) {
06417   return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
06418 }
06419 
06421 
06427 inline cimatrix operator*(const cimatrix_slice& M1, const simatrix_slice& M2) {
06428   return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
06429 }
06430 
06432 
06438 inline cimatrix operator*(const cimatrix_slice& M1, const scimatrix_slice& M2) {
06439   return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06440 }
06441 
06443 
06449 inline cimatrix operator*(const rmatrix_slice& M1, const scimatrix_slice& M2) {
06450   return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06451 }
06452 
06454 
06460 inline cimatrix operator*(const imatrix_slice& M1, const scimatrix_slice& M2) {
06461   return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06462 }
06463 
06465 
06471 inline cimatrix operator*(const cmatrix_slice& M1, const scimatrix_slice& M2) {
06472   return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
06473 }
06474 
06476 
06482 inline cimatrix operator*(const imatrix_slice& M1, const scmatrix_slice& M2) {
06483   return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
06484 }
06485 
06487 
06493 inline cimatrix operator*(const cmatrix_slice& M1, const simatrix_slice& M2) {
06494   return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
06495 }
06496 
06498 
06504 inline scivector operator*(const scimatrix_slice& M, const srvector& v) {
06505   return spsp_mv_mult<scimatrix,srvector,scivector,sparse_cidot,cinterval>(M.A,v);
06506 }
06507 
06509 
06515 inline scivector operator*(const scimatrix_slice& M, const sivector& v) {
06516   return spsp_mv_mult<scimatrix,sivector,scivector,sparse_cidot,cinterval>(M.A,v);
06517 }
06518 
06520 
06526 inline scivector operator*(const scimatrix_slice& M, const scvector& v) {
06527   return spsp_mv_mult<scimatrix,scvector,scivector,sparse_cidot,cinterval>(M.A,v);
06528 }
06529 
06531 
06537 inline scivector operator*(const scimatrix_slice& M, const scivector& v) {
06538   return spsp_mv_mult<scimatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
06539 }
06540 
06542 
06548 inline scivector operator*(const srmatrix_slice& M, const scivector& v) {
06549   return spsp_mv_mult<srmatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
06550 }
06551 
06553 
06559 inline scivector operator*(const simatrix_slice& M, const scivector& v) {
06560   return spsp_mv_mult<simatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
06561 }
06562 
06564 
06570 inline scivector operator*(const scmatrix_slice& M, const scivector& v) {
06571   return spsp_mv_mult<scmatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
06572 }
06573 
06575 
06581 inline scivector operator*(const simatrix_slice& M, const scvector& v) {
06582   return spsp_mv_mult<simatrix,scvector,scivector,sparse_cidot,cinterval>(M.A,v);
06583 }
06584 
06586 
06592 inline scivector operator*(const scmatrix_slice& M, const sivector& v) {
06593   return spsp_mv_mult<scmatrix,sivector,scivector,sparse_cidot,cinterval>(M.A,v);
06594 }
06595 
06597 
06603 inline scivector operator*(const scimatrix_slice& M, const srvector_slice& v) {
06604   return spsl_mv_mult<scimatrix,srvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06605 }
06606 
06608 
06614 inline scivector operator*(const scimatrix_slice& M, const sivector_slice& v) {
06615   return spsl_mv_mult<scimatrix,sivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06616 }
06617 
06619 
06625 inline scivector operator*(const scimatrix_slice& M, const scvector_slice& v) {
06626   return spsl_mv_mult<scimatrix,scvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06627 }
06628 
06630 
06636 inline scivector operator*(const scimatrix_slice& M, const scivector_slice& v) {
06637   return spsl_mv_mult<scimatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06638 }
06639 
06641 
06647 inline scivector operator*(const srmatrix_slice& M, const scivector_slice& v) {
06648   return spsl_mv_mult<srmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06649 }
06650 
06652 
06658 inline scivector operator*(const scmatrix_slice& M, const scivector_slice& v) {
06659   return spsl_mv_mult<scmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06660 }
06661 
06663 
06669 inline scivector operator*(const simatrix_slice& M, const scivector_slice& v) {
06670   return spsl_mv_mult<simatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06671 }
06672 
06674 
06680 inline scivector operator*(const simatrix_slice& M, const scvector_slice& v) {
06681   return spsl_mv_mult<simatrix,scvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06682 }
06683 
06685 
06691 inline scivector operator*(const scmatrix_slice& M, const sivector_slice& v) {
06692   return spsl_mv_mult<scmatrix,sivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
06693 }
06694 
06696 
06702 inline civector operator*(const scimatrix_slice& M, const rvector& v) {
06703   return spf_mv_mult<scimatrix,rvector,civector,sparse_cidot>(M.A,v);
06704 }
06705 
06707 
06713 inline civector operator*(const scimatrix_slice& M, const ivector& v) {
06714   return spf_mv_mult<scimatrix,ivector,civector,sparse_cidot>(M.A,v);
06715 }
06716 
06718 
06724 inline civector operator*(const scimatrix_slice& M, const cvector& v) {
06725   return spf_mv_mult<scimatrix,cvector,civector,sparse_cidot>(M.A,v);
06726 }
06727 
06729 
06735 inline civector operator*(const scimatrix_slice& M, const civector& v) {
06736   return spf_mv_mult<scimatrix,civector,civector,sparse_cidot>(M.A,v);
06737 }
06738 
06740 
06746 inline civector operator*(const srmatrix_slice& M, const civector& v) {
06747   return spf_mv_mult<srmatrix,civector,civector,sparse_cidot>(M.A,v);
06748 }
06749 
06751 
06757 inline civector operator*(const simatrix_slice& M, const civector& v) {
06758   return spf_mv_mult<simatrix,civector,civector,sparse_cidot>(M.A,v);
06759 }
06760 
06762 
06768 inline civector operator*(const scmatrix_slice& M, const civector& v) {
06769   return spf_mv_mult<scmatrix,civector,civector,sparse_cidot>(M.A,v);
06770 }
06771 
06773 
06779 inline civector operator*(const simatrix_slice& M, const cvector& v) {
06780   return spf_mv_mult<simatrix,cvector,civector,sparse_cidot>(M.A,v);
06781 }
06782 
06784 
06790 inline civector operator*(const scmatrix_slice& M, const ivector& v) {
06791   return spf_mv_mult<scmatrix,ivector,civector,sparse_cidot>(M.A,v);
06792 }
06793 
06795 
06801 inline civector operator*(const scimatrix_slice& M, const rvector_slice& v) {
06802   return spf_mv_mult<scimatrix,rvector_slice,civector,sparse_cidot>(M.A,v);
06803 }
06804 
06806 
06812 inline civector operator*(const scimatrix_slice& M, const ivector_slice& v) {
06813   return spf_mv_mult<scimatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
06814 }
06815 
06817 
06823 inline civector operator*(const scimatrix_slice& M, const cvector_slice& v) {
06824   return spf_mv_mult<scimatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
06825 }
06826 
06828 
06834 inline civector operator*(const scimatrix_slice& M, const civector_slice& v) {
06835   return spf_mv_mult<scimatrix,civector_slice,civector,sparse_cidot>(M.A,v);
06836 }
06837 
06839 
06845 inline civector operator*(const srmatrix_slice& M, const civector_slice& v) {
06846   return spf_mv_mult<srmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
06847 }
06848 
06850 
06856 inline civector operator*(const scmatrix_slice& M, const civector_slice& v) {
06857   return spf_mv_mult<scmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
06858 }
06859 
06861 
06867 inline civector operator*(const simatrix_slice& M, const civector_slice& v) {
06868   return spf_mv_mult<simatrix,civector_slice,civector,sparse_cidot>(M.A,v);
06869 }
06870 
06872 
06878 inline civector operator*(const simatrix_slice& M, const cvector_slice& v) {
06879   return spf_mv_mult<simatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
06880 }
06881 
06883 
06889 inline civector operator*(const scmatrix_slice& M, const ivector_slice& v) {
06890   return spf_mv_mult<scmatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
06891 }
06892 
06894 inline scimatrix operator/(const scimatrix_slice& M, const real& r) {
06895   return sp_ms_div<scimatrix,real,scimatrix>(M.A,r);
06896 }
06897 
06899 inline scimatrix operator/(const scimatrix_slice& M, const complex& r) {
06900   return sp_ms_div<scimatrix,complex,scimatrix>(M.A,r);
06901 }
06902 
06904 inline scimatrix operator/(const scimatrix_slice& M, const interval& r) {
06905   return sp_ms_div<scimatrix,interval,scimatrix>(M.A,r);
06906 }
06907 
06909 inline scimatrix operator/(const scimatrix_slice& M, const cinterval& r) {
06910   return sp_ms_div<scimatrix,cinterval,scimatrix>(M.A,r);
06911 }
06912 
06914 inline scimatrix operator/(const srmatrix_slice& M, const cinterval& r) {
06915   return sp_ms_div<srmatrix,cinterval,scimatrix>(M.A,r);
06916 }
06917 
06919 inline scimatrix operator/(const simatrix_slice& M, const cinterval& r) {
06920   return sp_ms_div<simatrix,cinterval,scimatrix>(M.A,r);
06921 }
06922 
06924 inline scimatrix operator/(const scmatrix_slice& M, const cinterval& r) {
06925   return sp_ms_div<scmatrix,cinterval,scimatrix>(M.A,r);
06926 }
06927 
06929 inline scimatrix operator/(const simatrix_slice& M, const complex& r) {
06930   return sp_ms_div<simatrix,complex,scimatrix>(M.A,r);
06931 }
06932 
06934 inline scimatrix operator/(const scmatrix_slice& M, const interval& r) {
06935   return sp_ms_div<scmatrix,interval,scimatrix>(M.A,r);
06936 }
06937 
06939 inline scimatrix operator*(const scimatrix_slice& M, const real& r) {
06940   return sp_ms_mult<scimatrix,real,scimatrix>(M.A,r);
06941 }
06942 
06944 inline scimatrix operator*(const scimatrix_slice& M, const complex& r) {
06945   return sp_ms_mult<scimatrix,complex,scimatrix>(M.A,r);
06946 }
06947 
06949 inline scimatrix operator*(const scimatrix_slice& M, const interval& r) {
06950   return sp_ms_mult<scimatrix,interval,scimatrix>(M.A,r);
06951 }
06952 
06954 inline scimatrix operator*(const scimatrix_slice& M, const cinterval& r) {
06955   return sp_ms_mult<scimatrix,cinterval,scimatrix>(M.A,r);
06956 }
06957 
06959 inline scimatrix operator*(const srmatrix_slice& M, const cinterval& r) {
06960   return sp_ms_mult<srmatrix,cinterval,scimatrix>(M.A,r);
06961 }
06962 
06964 inline scimatrix operator*(const simatrix_slice& M, const cinterval& r) {
06965   return sp_ms_mult<simatrix,cinterval,scimatrix>(M.A,r);
06966 }
06967 
06969 inline scimatrix operator*(const scmatrix_slice& M, const cinterval& r) {
06970   return sp_ms_mult<scmatrix,cinterval,scimatrix>(M.A,r);
06971 }
06972 
06974 inline scimatrix operator*(const simatrix_slice& M, const complex& r) {
06975   return sp_ms_mult<simatrix,complex,scimatrix>(M.A,r);
06976 }
06977 
06979 inline scimatrix operator*(const scmatrix_slice& M, const interval& r) {
06980   return sp_ms_mult<scmatrix,interval,scimatrix>(M.A,r);
06981 }
06982 
06984 inline scimatrix operator*(const real& r, const scimatrix_slice& M) {
06985   return sp_sm_mult<real,scimatrix,scimatrix>(r,M.A);
06986 }
06987 
06989 inline scimatrix operator*(const complex& r, const scimatrix_slice& M) {
06990   return sp_sm_mult<complex,scimatrix,scimatrix>(r,M.A);
06991 }
06992 
06994 inline scimatrix operator*(const interval& r, const scimatrix_slice& M) {
06995   return sp_sm_mult<interval,scimatrix,scimatrix>(r,M.A);
06996 }
06997 
06999 inline scimatrix operator*(const cinterval& r, const scimatrix_slice& M) {
07000   return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,M.A);
07001 }
07002 
07004 inline scimatrix operator*(const cinterval& r, const srmatrix_slice& M) {
07005   return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,M.A);
07006 }
07007 
07009 inline scimatrix operator*(const cinterval& r, const simatrix_slice& M) {
07010   return sp_sm_mult<cinterval,simatrix,scimatrix>(r,M.A);
07011 }
07012 
07014 inline scimatrix operator*(const cinterval& r, const scmatrix_slice& M) {
07015   return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,M.A);
07016 }
07017 
07019 inline scimatrix operator*(const complex& r, const simatrix_slice& M) {
07020   return sp_sm_mult<complex,simatrix,scimatrix>(r,M.A);
07021 }
07022 
07024 inline scimatrix operator*(const interval& r, const scmatrix_slice& M) {
07025   return sp_sm_mult<interval,scmatrix,scimatrix>(r,M.A);
07026 }
07027 
07029 inline scimatrix operator+(const scimatrix_slice& M1, const srmatrix_slice& M2) {
07030   return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
07031 }
07032 
07034 inline scimatrix operator+(const scimatrix_slice& M1, const scmatrix_slice& M2) {
07035   return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07036 }
07037 
07039 inline scimatrix operator+(const scimatrix_slice& M1, const simatrix_slice& M2) {
07040   return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
07041 }
07042 
07044 inline scimatrix operator+(const scimatrix_slice& M1, const scimatrix_slice& M2) {
07045   return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07046 }
07047 
07049 inline scimatrix operator+(const srmatrix_slice& M1, const scimatrix_slice& M2) {
07050   return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07051 }
07052 
07054 inline scimatrix operator+(const scmatrix_slice& M1, const scimatrix_slice& M2) {
07055   return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07056 }
07057 
07059 inline scimatrix operator+(const simatrix_slice& M1, const scimatrix_slice& M2) {
07060   return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07061 }
07062 
07064 inline scimatrix operator+(const scmatrix_slice& M1, const simatrix_slice& M2) {
07065   return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
07066 }
07067 
07069 inline scimatrix operator+(const simatrix_slice& M1, const scmatrix_slice& M2) {
07070   return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07071 }
07072 
07074 inline scimatrix operator+(const scimatrix_slice& M1, const srmatrix& M2) {
07075   return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
07076 }
07077 
07079 inline scimatrix operator+(const scimatrix_slice& M1, const scmatrix& M2) {
07080   return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
07081 }
07082 
07084 inline scimatrix operator+(const scimatrix_slice& M1, const simatrix& M2) {
07085   return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
07086 }
07087 
07089 inline scimatrix operator+(const scimatrix_slice& M1, const scimatrix& M2) {
07090   return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07091 }
07092 
07094 inline scimatrix operator+(const srmatrix_slice& M1, const scimatrix& M2) {
07095   return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07096 }
07097 
07099 inline scimatrix operator+(const simatrix_slice& M1, const scimatrix& M2) {
07100   return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07101 }
07102 
07104 inline scimatrix operator+(const scmatrix_slice& M1, const scimatrix& M2) {
07105   return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07106 }
07107 
07109 inline scimatrix operator+(const simatrix_slice& M1, const scmatrix& M2) {
07110   return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
07111 }
07112 
07114 inline scimatrix operator+(const scmatrix_slice& M1, const simatrix& M2) {
07115   return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
07116 }
07117 
07119 inline scimatrix operator+(const scimatrix& M1, const srmatrix_slice& M2) {
07120   return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
07121 }
07122 
07124 inline scimatrix operator+(const scimatrix& M1, const scmatrix_slice& M2) {
07125   return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
07126 }
07127 
07129 inline scimatrix operator+(const scimatrix& M1, const simatrix_slice& M2) {
07130   return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
07131 }
07132 
07134 inline scimatrix operator+(const scimatrix& M1, const scimatrix_slice& M2) {
07135   return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07136 }
07137 
07139 inline scimatrix operator+(const srmatrix& M1, const scimatrix_slice& M2) {
07140   return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07141 }
07142 
07144 inline scimatrix operator+(const simatrix& M1, const scimatrix_slice& M2) {
07145   return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07146 }
07147 
07149 inline scimatrix operator+(const scmatrix& M1, const scimatrix_slice& M2) {
07150   return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07151 }
07152 
07154 inline scimatrix operator+(const simatrix& M1, const scmatrix_slice& M2) {
07155   return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
07156 }
07157 
07159 inline scimatrix operator+(const scmatrix& M1, const simatrix_slice& M2) {
07160   return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
07161 }
07162 
07164 inline cimatrix operator+(const scimatrix_slice& M1, const rmatrix& M2) {
07165   return spf_mm_add<scimatrix,rmatrix,cimatrix>(M1.A,M2);
07166 }
07167 
07169 inline cimatrix operator+(const scimatrix_slice& M1, const imatrix& M2) {
07170   return spf_mm_add<scimatrix,imatrix,cimatrix>(M1.A,M2);
07171 }
07172 
07174 inline cimatrix operator+(const scimatrix_slice& M1, const cmatrix& M2) {
07175   return spf_mm_add<scimatrix,cmatrix,cimatrix>(M1.A,M2);
07176 }
07177 
07179 inline cimatrix operator+(const scimatrix_slice& M1, const cimatrix& M2) {
07180   return spf_mm_add<scimatrix,cimatrix,cimatrix>(M1.A,M2);
07181 }
07182 
07184 inline cimatrix operator+(const srmatrix_slice& M1, const cimatrix& M2) {
07185   return spf_mm_add<srmatrix,cimatrix,cimatrix>(M1.A,M2);
07186 }
07187 
07189 inline cimatrix operator+(const simatrix_slice& M1, const cimatrix& M2) {
07190   return spf_mm_add<simatrix,cimatrix,cimatrix>(M1.A,M2);
07191 }
07192 
07194 inline cimatrix operator+(const scmatrix_slice& M1, const cimatrix& M2) {
07195   return spf_mm_add<scmatrix,cimatrix,cimatrix>(M1.A,M2);
07196 }
07197 
07199 inline cimatrix operator+(const simatrix_slice& M1, const cmatrix& M2) {
07200   return spf_mm_add<simatrix,cmatrix,cimatrix>(M1.A,M2);
07201 }
07202 
07204 inline cimatrix operator+(const scmatrix_slice& M1, const imatrix& M2) {
07205   return spf_mm_add<scmatrix,imatrix,cimatrix>(M1.A,M2);
07206 }
07207 
07209 inline cimatrix operator+(const cimatrix& M1, const srmatrix_slice& M2) {
07210   return fsp_mm_add<cimatrix,srmatrix,cimatrix>(M1,M2.A);
07211 }
07212 
07214 inline cimatrix operator+(const cimatrix& M1, const simatrix_slice& M2) {
07215   return fsp_mm_add<cimatrix,simatrix,cimatrix>(M1,M2.A);
07216 }
07217 
07219 inline cimatrix operator+(const cimatrix& M1, const scmatrix_slice& M2) {
07220   return fsp_mm_add<cimatrix,scmatrix,cimatrix>(M1,M2.A);
07221 }
07222 
07224 inline cimatrix operator+(const cimatrix& M1, const scimatrix_slice& M2) {
07225   return fsp_mm_add<cimatrix,scimatrix,cimatrix>(M1,M2.A);
07226 }
07227 
07229 inline cimatrix operator+(const rmatrix& M1, const scimatrix_slice& M2) {
07230   return fsp_mm_add<rmatrix,scimatrix,cimatrix>(M1,M2.A);
07231 }
07232 
07234 inline cimatrix operator+(const imatrix& M1, const scimatrix_slice& M2) {
07235   return fsp_mm_add<imatrix,scimatrix,cimatrix>(M1,M2.A);
07236 }
07237 
07239 inline cimatrix operator+(const cmatrix& M1, const scimatrix_slice& M2) {
07240   return fsp_mm_add<cmatrix,scimatrix,cimatrix>(M1,M2.A);
07241 }
07242 
07244 inline cimatrix operator+(const imatrix& M1, const scmatrix_slice& M2) {
07245   return fsp_mm_add<imatrix,scmatrix,cimatrix>(M1,M2.A);
07246 }
07247 
07249 inline cimatrix operator+(const cmatrix& M1, const simatrix_slice& M2) {
07250   return fsp_mm_add<cmatrix,simatrix,cimatrix>(M1,M2.A);
07251 }
07252 
07254 inline cimatrix operator+(const scimatrix_slice& M1, const rmatrix_slice& M2) {
07255   return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
07256 }
07257 
07259 inline cimatrix operator+(const scimatrix_slice& M1, const cmatrix_slice& M2) {
07260   return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
07261 }
07262 
07264 inline cimatrix operator+(const scimatrix_slice& M1, const imatrix_slice& M2) {
07265   return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
07266 }
07267 
07269 inline cimatrix operator+(const scimatrix_slice& M1, const cimatrix_slice& M2) {
07270   return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07271 }
07272 
07274 inline cimatrix operator+(const srmatrix_slice& M1, const cimatrix_slice& M2) {
07275   return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07276 }
07277 
07279 inline cimatrix operator+(const simatrix_slice& M1, const cimatrix_slice& M2) {
07280   return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07281 }
07282 
07284 inline cimatrix operator+(const scmatrix_slice& M1, const cimatrix_slice& M2) {
07285   return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07286 }
07287 
07289 inline cimatrix operator+(const simatrix_slice& M1, const cmatrix_slice& M2) {
07290   return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
07291 }
07292 
07294 inline cimatrix operator+(const scmatrix_slice& M1, const imatrix_slice& M2) {
07295   return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
07296 }
07297 
07299 inline cimatrix operator+(const cimatrix_slice& M1, const srmatrix_slice& M2) {
07300   return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
07301 }
07302 
07304 inline cimatrix operator+(const cimatrix_slice& M1, const simatrix_slice& M2) {
07305   return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
07306 }
07307 
07309 inline cimatrix operator+(const cimatrix_slice& M1, const scmatrix_slice& M2) {
07310   return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
07311 }
07312 
07314 inline cimatrix operator+(const cimatrix_slice& M1, const scimatrix_slice& M2) {
07315   return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07316 }
07317 
07319 inline cimatrix operator+(const rmatrix_slice& M1, const scimatrix_slice& M2) {
07320   return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07321 }
07322 
07324 inline cimatrix operator+(const imatrix_slice& M1, const scimatrix_slice& M2) {
07325   return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07326 }
07327 
07329 inline cimatrix operator+(const cmatrix_slice& M1, const scimatrix_slice& M2) {
07330   return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07331 }
07332 
07334 inline cimatrix operator+(const imatrix_slice& M1, const scmatrix_slice& M2) {
07335   return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
07336 }
07337 
07339 inline cimatrix operator+(const cmatrix_slice& M1, const simatrix_slice& M2) {
07340   return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
07341 }
07342 
07344 inline scimatrix operator-(const scimatrix_slice& M1, const srmatrix_slice& M2) {
07345   return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
07346 }
07347 
07349 inline scimatrix operator-(const scimatrix_slice& M1, const scmatrix_slice& M2) {
07350   return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07351 }
07352 
07354 inline scimatrix operator-(const scimatrix_slice& M1, const simatrix_slice& M2) {
07355   return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
07356 }
07357 
07359 inline scimatrix operator-(const scimatrix_slice& M1, const scimatrix_slice& M2) {
07360   return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07361 }
07362 
07364 inline scimatrix operator-(const srmatrix_slice& M1, const scimatrix_slice& M2) {
07365   return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07366 }
07367 
07369 inline scimatrix operator-(const scmatrix_slice& M1, const scimatrix_slice& M2) {
07370   return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07371 }
07372 
07374 inline scimatrix operator-(const simatrix_slice& M1, const scimatrix_slice& M2) {
07375   return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07376 }
07377 
07379 inline scimatrix operator-(const scmatrix_slice& M1, const simatrix_slice& M2) {
07380   return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
07381 }
07382 
07384 inline scimatrix operator-(const simatrix_slice& M1, const scmatrix_slice& M2) {
07385   return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07386 }
07387 
07389 inline scimatrix operator-(const scimatrix_slice& M1, const srmatrix& M2) {
07390   return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
07391 }
07392 
07394 inline scimatrix operator-(const scimatrix_slice& M1, const scmatrix& M2) {
07395   return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
07396 }
07397 
07399 inline scimatrix operator-(const scimatrix_slice& M1, const simatrix& M2) {
07400   return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
07401 }
07402 
07404 inline scimatrix operator-(const scimatrix_slice& M1, const scimatrix& M2) {
07405   return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07406 }
07407 
07409 inline scimatrix operator-(const srmatrix_slice& M1, const scimatrix& M2) {
07410   return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07411 }
07412 
07414 inline scimatrix operator-(const simatrix_slice& M1, const scimatrix& M2) {
07415   return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07416 }
07417 
07419 inline scimatrix operator-(const scmatrix_slice& M1, const scimatrix& M2) {
07420   return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07421 }
07422 
07424 inline scimatrix operator-(const simatrix_slice& M1, const scmatrix& M2) {
07425   return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
07426 }
07427 
07429 inline scimatrix operator-(const scmatrix_slice& M1, const simatrix& M2) {
07430   return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
07431 }
07432 
07434 inline scimatrix operator-(const scimatrix& M1, const srmatrix_slice& M2) {
07435   return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
07436 }
07437 
07439 inline scimatrix operator-(const scimatrix& M1, const scmatrix_slice& M2) {
07440   return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
07441 }
07442 
07444 inline scimatrix operator-(const scimatrix& M1, const simatrix_slice& M2) {
07445   return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
07446 }
07447 
07449 inline scimatrix operator-(const scimatrix& M1, const scimatrix_slice& M2) {
07450   return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07451 }
07452 
07454 inline scimatrix operator-(const srmatrix& M1, const scimatrix_slice& M2) {
07455   return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07456 }
07457 
07459 inline scimatrix operator-(const simatrix& M1, const scimatrix_slice& M2) {
07460   return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07461 }
07462 
07464 inline scimatrix operator-(const scmatrix& M1, const scimatrix_slice& M2) {
07465   return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07466 }
07467 
07469 inline scimatrix operator-(const simatrix& M1, const scmatrix_slice& M2) {
07470   return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
07471 }
07472 
07474 inline scimatrix operator-(const scmatrix& M1, const simatrix_slice& M2) {
07475   return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
07476 }
07477 
07479 inline cimatrix operator-(const scimatrix_slice& M1, const rmatrix& M2) {
07480   return spf_mm_sub<scimatrix,rmatrix,cimatrix>(M1.A,M2);
07481 }
07482 
07484 inline cimatrix operator-(const scimatrix_slice& M1, const imatrix& M2) {
07485   return spf_mm_sub<scimatrix,imatrix,cimatrix>(M1.A,M2);
07486 }
07487 
07489 inline cimatrix operator-(const scimatrix_slice& M1, const cmatrix& M2) {
07490   return spf_mm_sub<scimatrix,cmatrix,cimatrix>(M1.A,M2);
07491 }
07492 
07494 inline cimatrix operator-(const scimatrix_slice& M1, const cimatrix& M2) {
07495   return spf_mm_sub<scimatrix,cimatrix,cimatrix>(M1.A,M2);
07496 }
07497 
07499 inline cimatrix operator-(const srmatrix_slice& M1, const cimatrix& M2) {
07500   return spf_mm_sub<srmatrix,cimatrix,cimatrix>(M1.A,M2);
07501 }
07502 
07504 inline cimatrix operator-(const simatrix_slice& M1, const cimatrix& M2) {
07505   return spf_mm_sub<simatrix,cimatrix,cimatrix>(M1.A,M2);
07506 }
07507 
07509 inline cimatrix operator-(const scmatrix_slice& M1, const cimatrix& M2) {
07510   return spf_mm_sub<scmatrix,cimatrix,cimatrix>(M1.A,M2);
07511 }
07512 
07514 inline cimatrix operator-(const simatrix_slice& M1, const cmatrix& M2) {
07515   return spf_mm_sub<simatrix,cmatrix,cimatrix>(M1.A,M2);
07516 }
07517 
07519 inline cimatrix operator-(const scmatrix_slice& M1, const imatrix& M2) {
07520   return spf_mm_sub<scmatrix,imatrix,cimatrix>(M1.A,M2);
07521 }
07522 
07524 inline cimatrix operator-(const cimatrix& M1, const srmatrix_slice& M2) {
07525   return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(M1,M2.A);
07526 }
07527 
07529 inline cimatrix operator-(const cimatrix& M1, const simatrix_slice& M2) {
07530   return fsp_mm_sub<cimatrix,simatrix,cimatrix>(M1,M2.A);
07531 }
07532 
07534 inline cimatrix operator-(const cimatrix& M1, const scmatrix_slice& M2) {
07535   return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(M1,M2.A);
07536 }
07537 
07539 inline cimatrix operator-(const cimatrix& M1, const scimatrix_slice& M2) {
07540   return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(M1,M2.A);
07541 }
07542 
07544 inline cimatrix operator-(const rmatrix& M1, const scimatrix_slice& M2) {
07545   return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(M1,M2.A);
07546 }
07547 
07549 inline cimatrix operator-(const imatrix& M1, const scimatrix_slice& M2) {
07550   return fsp_mm_sub<imatrix,scimatrix,cimatrix>(M1,M2.A);
07551 }
07552 
07554 inline cimatrix operator-(const cmatrix& M1, const scimatrix_slice& M2) {
07555   return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(M1,M2.A);
07556 }
07557 
07559 inline cimatrix operator-(const imatrix& M1, const scmatrix_slice& M2) {
07560   return fsp_mm_sub<imatrix,scmatrix,cimatrix>(M1,M2.A);
07561 }
07562 
07564 inline cimatrix operator-(const cmatrix& M1, const simatrix_slice& M2) {
07565   return fsp_mm_sub<cmatrix,simatrix,cimatrix>(M1,M2.A);
07566 }
07567 
07569 inline cimatrix operator-(const scimatrix_slice& M1, const rmatrix_slice& M2) {
07570   return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
07571 }
07572 
07574 inline cimatrix operator-(const scimatrix_slice& M1, const cmatrix_slice& M2) {
07575   return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
07576 }
07577 
07579 inline cimatrix operator-(const scimatrix_slice& M1, const imatrix_slice& M2) {
07580   return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
07581 }
07582 
07584 inline cimatrix operator-(const scimatrix_slice& M1, const cimatrix_slice& M2) {
07585   return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07586 }
07587 
07589 inline cimatrix operator-(const srmatrix_slice& M1, const cimatrix_slice& M2) {
07590   return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07591 }
07592 
07594 inline cimatrix operator-(const simatrix_slice& M1, const cimatrix_slice& M2) {
07595   return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07596 }
07597 
07599 inline cimatrix operator-(const scmatrix_slice& M1, const cimatrix_slice& M2) {
07600   return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07601 }
07602 
07604 inline cimatrix operator-(const simatrix_slice& M1, const cmatrix_slice& M2) {
07605   return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
07606 }
07607 
07609 inline cimatrix operator-(const scmatrix_slice& M1, const imatrix_slice& M2) {
07610   return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
07611 }
07612 
07614 inline cimatrix operator-(const cimatrix_slice& M1, const srmatrix_slice& M2) {
07615   return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
07616 }
07617 
07619 inline cimatrix operator-(const cimatrix_slice& M1, const simatrix_slice& M2) {
07620   return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
07621 }
07622 
07624 inline cimatrix operator-(const cimatrix_slice& M1, const scmatrix_slice& M2) {
07625   return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
07626 }
07627 
07629 inline cimatrix operator-(const cimatrix_slice& M1, const scimatrix_slice& M2) {
07630   return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07631 }
07632 
07634 inline cimatrix operator-(const rmatrix_slice& M1, const scimatrix_slice& M2) {
07635   return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07636 }
07637 
07639 inline cimatrix operator-(const imatrix_slice& M1, const scimatrix_slice& M2) {
07640   return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07641 }
07642 
07644 inline cimatrix operator-(const cmatrix_slice& M1, const scimatrix_slice& M2) {
07645   return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07646 }
07647 
07649 inline cimatrix operator-(const imatrix_slice& M1, const scmatrix_slice& M2) {
07650   return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
07651 }
07652 
07654 inline cimatrix operator-(const cmatrix_slice& M1, const simatrix_slice& M2) {
07655   return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
07656 }
07657 
07659 inline scimatrix operator|(const scimatrix_slice& M1, const srmatrix_slice& M2) {
07660   return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
07661 }
07662 
07664 inline scimatrix operator|(const scimatrix_slice& M1, const scmatrix_slice& M2) {
07665   return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07666 }
07667 
07669 inline scimatrix operator|(const scimatrix_slice& M1, const simatrix_slice& M2) {
07670   return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
07671 }
07672 
07674 inline scimatrix operator|(const scimatrix_slice& M1, const scimatrix_slice& M2) {
07675   return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07676 }
07677 
07679 inline scimatrix operator|(const srmatrix_slice& M1, const scimatrix_slice& M2) {
07680   return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07681 }
07682 
07684 inline scimatrix operator|(const scmatrix_slice& M1, const scimatrix_slice& M2) {
07685   return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07686 }
07687 
07689 inline scimatrix operator|(const simatrix_slice& M1, const scimatrix_slice& M2) {
07690   return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
07691 }
07692 
07694 inline scimatrix operator|(const scmatrix_slice& M1, const simatrix_slice& M2) {
07695   return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
07696 }
07697 
07699 inline scimatrix operator|(const simatrix_slice& M1, const scmatrix_slice& M2) {
07700   return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07701 }
07702 
07704 inline scimatrix operator|(const scimatrix_slice& M1, const srmatrix& M2) {
07705   return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
07706 }
07707 
07709 inline scimatrix operator|(const scimatrix_slice& M1, const scmatrix& M2) {
07710   return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
07711 }
07712 
07714 inline scimatrix operator|(const scimatrix_slice& M1, const simatrix& M2) {
07715   return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
07716 }
07717 
07719 inline scimatrix operator|(const scimatrix_slice& M1, const scimatrix& M2) {
07720   return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07721 }
07722 
07724 inline scimatrix operator|(const srmatrix_slice& M1, const scimatrix& M2) {
07725   return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07726 }
07727 
07729 inline scimatrix operator|(const simatrix_slice& M1, const scimatrix& M2) {
07730   return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07731 }
07732 
07734 inline scimatrix operator|(const scmatrix_slice& M1, const scimatrix& M2) {
07735   return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
07736 }
07737 
07739 inline scimatrix operator|(const simatrix_slice& M1, const scmatrix& M2) {
07740   return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
07741 }
07742 
07744 inline scimatrix operator|(const scmatrix_slice& M1, const simatrix& M2) {
07745   return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
07746 }
07747 
07749 inline scimatrix operator|(const scimatrix& M1, const srmatrix_slice& M2) {
07750   return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
07751 }
07752 
07754 inline scimatrix operator|(const scimatrix& M1, const scmatrix_slice& M2) {
07755   return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
07756 }
07757 
07759 inline scimatrix operator|(const scimatrix& M1, const simatrix_slice& M2) {
07760   return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
07761 }
07762 
07764 inline scimatrix operator|(const scimatrix& M1, const scimatrix_slice& M2) {
07765   return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07766 }
07767 
07769 inline scimatrix operator|(const srmatrix& M1, const scimatrix_slice& M2) {
07770   return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07771 }
07772 
07774 inline scimatrix operator|(const simatrix& M1, const scimatrix_slice& M2) {
07775   return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07776 }
07777 
07779 inline scimatrix operator|(const scmatrix& M1, const scimatrix_slice& M2) {
07780   return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
07781 }
07782 
07784 inline scimatrix operator|(const simatrix& M1, const scmatrix_slice& M2) {
07785   return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
07786 }
07787 
07789 inline scimatrix operator|(const scmatrix& M1, const simatrix_slice& M2) {
07790   return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
07791 }
07792 
07794 inline cimatrix operator|(const scimatrix_slice& M1, const rmatrix& M2) {
07795   return spf_mm_hull<scimatrix,rmatrix,cimatrix>(M1.A,M2);
07796 }
07797 
07799 inline cimatrix operator|(const scimatrix_slice& M1, const imatrix& M2) {
07800   return spf_mm_hull<scimatrix,imatrix,cimatrix>(M1.A,M2);
07801 }
07802 
07804 inline cimatrix operator|(const scimatrix_slice& M1, const cmatrix& M2) {
07805   return spf_mm_hull<scimatrix,cmatrix,cimatrix>(M1.A,M2);
07806 }
07807 
07809 inline cimatrix operator|(const scimatrix_slice& M1, const cimatrix& M2) {
07810   return spf_mm_hull<scimatrix,cimatrix,cimatrix>(M1.A,M2);
07811 }
07812 
07814 inline cimatrix operator|(const srmatrix_slice& M1, const cimatrix& M2) {
07815   return spf_mm_hull<srmatrix,cimatrix,cimatrix>(M1.A,M2);
07816 }
07817 
07819 inline cimatrix operator|(const simatrix_slice& M1, const cimatrix& M2) {
07820   return spf_mm_hull<simatrix,cimatrix,cimatrix>(M1.A,M2);
07821 }
07822 
07824 inline cimatrix operator|(const scmatrix_slice& M1, const cimatrix& M2) {
07825   return spf_mm_hull<scmatrix,cimatrix,cimatrix>(M1.A,M2);
07826 }
07827 
07829 inline cimatrix operator|(const simatrix_slice& M1, const cmatrix& M2) {
07830   return spf_mm_hull<simatrix,cmatrix,cimatrix>(M1.A,M2);
07831 }
07832 
07834 inline cimatrix operator|(const scmatrix_slice& M1, const imatrix& M2) {
07835   return spf_mm_hull<scmatrix,imatrix,cimatrix>(M1.A,M2);
07836 }
07837 
07839 inline cimatrix operator|(const cimatrix& M1, const srmatrix_slice& M2) {
07840   return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(M1,M2.A);
07841 }
07842 
07844 inline cimatrix operator|(const cimatrix& M1, const simatrix_slice& M2) {
07845   return fsp_mm_hull<cimatrix,simatrix,cimatrix>(M1,M2.A);
07846 }
07847 
07849 inline cimatrix operator|(const cimatrix& M1, const scmatrix_slice& M2) {
07850   return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(M1,M2.A);
07851 }
07852 
07854 inline cimatrix operator|(const cimatrix& M1, const scimatrix_slice& M2) {
07855   return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(M1,M2.A);
07856 }
07857 
07859 inline cimatrix operator|(const rmatrix& M1, const scimatrix_slice& M2) {
07860   return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(M1,M2.A);
07861 }
07862 
07864 inline cimatrix operator|(const imatrix& M1, const scimatrix_slice& M2) {
07865   return fsp_mm_hull<imatrix,scimatrix,cimatrix>(M1,M2.A);
07866 }
07867 
07869 inline cimatrix operator|(const cmatrix& M1, const scimatrix_slice& M2) {
07870   return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(M1,M2.A);
07871 }
07872 
07874 inline cimatrix operator|(const imatrix& M1, const scmatrix_slice& M2) {
07875   return fsp_mm_hull<imatrix,scmatrix,cimatrix>(M1,M2.A);
07876 }
07877 
07879 inline cimatrix operator|(const cmatrix& M1, const simatrix_slice& M2) {
07880   return fsp_mm_hull<cmatrix,simatrix,cimatrix>(M1,M2.A);
07881 }
07882 
07884 inline cimatrix operator|(const scimatrix_slice& M1, const rmatrix_slice& M2) {
07885   return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
07886 }
07887 
07889 inline cimatrix operator|(const scimatrix_slice& M1, const cmatrix_slice& M2) {
07890   return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
07891 }
07892 
07894 inline cimatrix operator|(const scimatrix_slice& M1, const imatrix_slice& M2) {
07895   return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
07896 }
07897 
07899 inline cimatrix operator|(const scimatrix_slice& M1, const cimatrix_slice& M2) {
07900   return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07901 }
07902 
07904 inline cimatrix operator|(const srmatrix_slice& M1, const cimatrix_slice& M2) {
07905   return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07906 }
07907 
07909 inline cimatrix operator|(const simatrix_slice& M1, const cimatrix_slice& M2) {
07910   return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07911 }
07912 
07914 inline cimatrix operator|(const scmatrix_slice& M1, const cimatrix_slice& M2) {
07915   return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
07916 }
07917 
07919 inline cimatrix operator|(const simatrix_slice& M1, const cmatrix_slice& M2) {
07920   return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
07921 }
07922 
07924 inline cimatrix operator|(const scmatrix_slice& M1, const imatrix_slice& M2) {
07925   return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
07926 }
07927 
07929 inline cimatrix operator|(const cimatrix_slice& M1, const srmatrix_slice& M2) {
07930   return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
07931 }
07932 
07934 inline cimatrix operator|(const cimatrix_slice& M1, const simatrix_slice& M2) {
07935   return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
07936 }
07937 
07939 inline cimatrix operator|(const cimatrix_slice& M1, const scmatrix_slice& M2) {
07940   return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
07941 }
07942 
07944 inline cimatrix operator|(const cimatrix_slice& M1, const scimatrix_slice& M2) {
07945   return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07946 }
07947 
07949 inline cimatrix operator|(const rmatrix_slice& M1, const scimatrix_slice& M2) {
07950   return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07951 }
07952 
07954 inline cimatrix operator|(const imatrix_slice& M1, const scimatrix_slice& M2) {
07955   return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07956 }
07957 
07959 inline cimatrix operator|(const cmatrix_slice& M1, const scimatrix_slice& M2) {
07960   return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
07961 }
07962 
07964 inline cimatrix operator|(const imatrix_slice& M1, const scmatrix_slice& M2) {
07965   return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
07966 }
07967 
07969 inline cimatrix operator|(const cmatrix_slice& M1, const simatrix_slice& M2) {
07970   return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
07971 }
07972 
07974 inline scimatrix operator|(const scmatrix_slice& M1, const srmatrix_slice& M2) {
07975   return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
07976 }
07977 
07979 inline scimatrix operator|(const srmatrix_slice& M1, const scmatrix_slice& M2) {
07980   return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07981 }
07982 
07984 inline scimatrix operator|(const scmatrix_slice& M1, const scmatrix_slice& M2) {
07985   return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
07986 }
07987 
07989 inline scimatrix operator|(const scmatrix_slice& M1, const srmatrix& M2) {
07990   return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
07991 }
07992 
07994 inline scimatrix operator|(const srmatrix_slice& M1, const scmatrix& M2) {
07995   return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
07996 }
07997 
07999 inline scimatrix operator|(const scmatrix_slice& M1, const scmatrix& M2) {
08000   return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
08001 }
08002 
08004 inline scimatrix operator|(const scmatrix& M1, const srmatrix_slice& M2) {
08005   return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
08006 }
08007 
08009 inline scimatrix operator|(const srmatrix& M1, const scmatrix_slice& M2) {
08010   return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
08011 }
08012 
08014 inline scimatrix operator|(const scmatrix& M1, const scmatrix_slice& M2) {
08015   return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
08016 }
08017 
08019 inline cimatrix operator|(const scmatrix_slice& M1, const rmatrix& M2) {
08020   return spf_mm_hull<scmatrix,rmatrix,cimatrix>(M1.A,M2);
08021 }
08022 
08024 inline cimatrix operator|(const srmatrix_slice& M1, const cmatrix& M2) {
08025   return spf_mm_hull<srmatrix,cmatrix,cimatrix>(M1.A,M2);
08026 }
08027 
08029 inline cimatrix operator|(const scmatrix_slice& M1, const cmatrix& M2) {
08030   return spf_mm_hull<scmatrix,cmatrix,cimatrix>(M1.A,M2);
08031 }
08032 
08034 inline cimatrix operator|(const cmatrix& M1, const srmatrix_slice& M2) {
08035   return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(M1,M2.A);
08036 }
08037 
08039 inline cimatrix operator|(const rmatrix& M1, const scmatrix_slice& M2) {
08040   return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(M1,M2.A);
08041 }
08042 
08044 inline cimatrix operator|(const cmatrix& M1, const scmatrix_slice& M2) {
08045   return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(M1,M2.A);
08046 }
08047 
08049 inline cimatrix operator|(const scmatrix_slice& M1, const rmatrix_slice& M2) {
08050   return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(M1.A,M2);
08051 }
08052 
08054 inline cimatrix operator|(const srmatrix_slice& M1, const cmatrix_slice& M2) {
08055   return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
08056 }
08057 
08059 inline cimatrix operator|(const scmatrix_slice& M1, const cmatrix_slice& M2) {
08060   return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
08061 }
08062 
08064 inline cimatrix operator|(const cmatrix_slice& M1, const srmatrix_slice& M2) {
08065   return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(M1,M2.A);
08066 }
08067 
08069 inline cimatrix operator|(const rmatrix_slice& M1, const scmatrix_slice& M2) {
08070   return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
08071 }
08072 
08074 inline cimatrix operator|(const cmatrix_slice& M1, const scmatrix_slice& M2) {
08075   return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
08076 }
08077 
08079 inline scimatrix operator&(const scimatrix_slice& M1, const simatrix_slice& M2) {
08080   return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
08081 }
08082 
08084 inline scimatrix operator&(const scimatrix_slice& M1, const scimatrix_slice& M2) {
08085   return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
08086 }
08087 
08089 inline scimatrix operator&(const simatrix_slice& M1, const scimatrix_slice& M2) {
08090   return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
08091 }
08092 
08094 inline scimatrix operator&(const scimatrix_slice& M1, const simatrix& M2) {
08095   return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
08096 }
08097 
08099 inline scimatrix operator&(const scimatrix_slice& M1, const scimatrix& M2) {
08100   return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
08101 }
08102 
08104 inline scimatrix operator&(const simatrix_slice& M1, const scimatrix& M2) {
08105   return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
08106 }
08107 
08109 inline scimatrix operator&(const scimatrix& M1, const simatrix_slice& M2) {
08110   return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
08111 }
08112 
08114 inline scimatrix operator&(const scimatrix& M1, const scimatrix_slice& M2) {
08115   return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
08116 }
08117 
08119 inline scimatrix operator&(const simatrix& M1, const scimatrix_slice& M2) {
08120   return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
08121 }
08122 
08124 inline cimatrix operator&(const scimatrix_slice& M1, const imatrix& M2) {
08125   return spf_mm_intersect<scimatrix,imatrix,cimatrix>(M1.A,M2);
08126 }
08127 
08129 inline cimatrix operator&(const scimatrix_slice& M1, const cimatrix& M2) {
08130   return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(M1.A,M2);
08131 }
08132 
08134 inline cimatrix operator&(const simatrix_slice& M1, const cimatrix& M2) {
08135   return spf_mm_intersect<simatrix,cimatrix,cimatrix>(M1.A,M2);
08136 }
08137 
08139 inline cimatrix operator&(const cimatrix& M1, const simatrix_slice& M2) {
08140   return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(M1,M2.A);
08141 }
08142 
08144 inline cimatrix operator&(const cimatrix& M1, const scimatrix_slice& M2) {
08145   return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(M1,M2.A);
08146 }
08147 
08149 inline cimatrix operator&(const imatrix& M1, const scimatrix_slice& M2) {
08150   return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(M1,M2.A);
08151 }
08152 
08154 inline cimatrix operator&(const scimatrix_slice& M1, const imatrix_slice& M2) {
08155   return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
08156 }
08157 
08159 inline cimatrix operator&(const scimatrix_slice& M1, const cimatrix_slice& M2) {
08160   return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
08161 }
08162 
08164 inline cimatrix operator&(const simatrix_slice& M1, const cimatrix_slice& M2) {
08165   return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
08166 }
08167 
08169 inline cimatrix operator&(const cimatrix_slice& M1, const simatrix_slice& M2) {
08170   return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
08171 }
08172 
08174 inline cimatrix operator&(const cimatrix_slice& M1, const scimatrix_slice& M2) {
08175   return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
08176 }
08177 
08179 inline cimatrix operator&(const imatrix_slice& M1, const scimatrix_slice& M2) {
08180   return fsp_mm_intersect<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
08181 }
08182 
08183 inline cimatrix& cimatrix::operator=(const srmatrix_slice& M) {
08184   *this = rmatrix(M);
08185   return *this;
08186 }
08187 
08188 inline cimatrix_slice& cimatrix_slice::operator=(const srmatrix_slice& M) {
08189   *this = rmatrix(M);
08190   return *this;
08191 }
08192 
08193 inline cimatrix& cimatrix::operator=(const simatrix_slice& M) {
08194   *this = imatrix(M);
08195   return *this;
08196 }
08197 
08198 inline cimatrix_slice& cimatrix_slice::operator=(const simatrix_slice& M) {
08199   *this = imatrix(M);
08200   return *this;
08201 }
08202 
08203 inline cimatrix& cimatrix::operator=(const scmatrix_slice& M) {
08204   *this = cmatrix(M);
08205   return *this;
08206 }
08207 
08208 inline cimatrix_slice& cimatrix_slice::operator=(const scmatrix_slice& M) {
08209   *this = cmatrix(M);
08210   return *this;
08211 }
08212 
08213 inline cimatrix& cimatrix::operator=(const scimatrix_slice& M) {
08214   *this = cimatrix(M);
08215   return *this;
08216 }
08217 
08218 inline cimatrix_slice& cimatrix_slice::operator=(const scimatrix_slice& M) {
08219   *this = cimatrix(M);
08220   return *this;
08221 }
08222 
08223 inline cimatrix& cimatrix::operator+=(const srmatrix_slice& M) {
08224   *this += M.A;
08225   return *this;
08226 }
08227 
08228 inline cimatrix_slice& cimatrix_slice::operator+=(const srmatrix_slice& M) {
08229   *this += M.A;
08230   return *this;
08231 }
08232 
08233 inline cimatrix& cimatrix::operator+=(const scmatrix_slice& M) {
08234   *this += M.A;
08235   return *this;
08236 }
08237 
08238 inline cimatrix_slice& cimatrix_slice::operator+=(const scmatrix_slice& M) {
08239   *this += M.A;
08240   return *this;
08241 }
08242 
08243 inline cimatrix& cimatrix::operator+=(const simatrix_slice& M) {
08244   *this += M.A;
08245   return *this;
08246 }
08247 
08248 inline cimatrix_slice& cimatrix_slice::operator+=(const simatrix_slice& M) {
08249   *this += M.A;
08250   return *this;
08251 }
08252 
08253 inline cimatrix& cimatrix::operator+=(const scimatrix_slice& M) {
08254   *this += M.A;
08255   return *this;
08256 }
08257 
08258 inline cimatrix_slice& cimatrix_slice::operator+=(const scimatrix_slice& M) {
08259   *this += M.A;
08260   return *this;
08261 }
08262 
08263 inline cimatrix& cimatrix::operator-=(const srmatrix_slice& M) {
08264   *this -= M.A;
08265   return *this;
08266 }
08267 
08268 inline cimatrix_slice& cimatrix_slice::operator-=(const srmatrix_slice& M) {
08269   *this -= M.A;
08270   return *this;
08271 }
08272 
08273 inline cimatrix& cimatrix::operator-=(const scmatrix_slice& M) {
08274   *this -= M.A;
08275   return *this;
08276 }
08277 
08278 inline cimatrix_slice& cimatrix_slice::operator-=(const scmatrix_slice& M) {
08279   *this -= M.A;
08280   return *this;
08281 }
08282 
08283 inline cimatrix& cimatrix::operator-=(const simatrix_slice& M) {
08284   *this -= M.A;
08285   return *this;
08286 }
08287 
08288 inline cimatrix_slice& cimatrix_slice::operator-=(const simatrix_slice& M) {
08289   *this -= M.A;
08290   return *this;
08291 }
08292 
08293 inline cimatrix& cimatrix::operator-=(const scimatrix_slice& M) {
08294   *this -= M.A;
08295   return *this;
08296 }
08297 
08298 inline cimatrix_slice& cimatrix_slice::operator-=(const scimatrix_slice& M) {
08299   *this -= M.A;
08300   return *this;
08301 }
08302 
08303 inline cimatrix& cimatrix::operator*=(const srmatrix_slice& M) {
08304   *this *= M.A;
08305   return *this;
08306 }
08307 
08308 inline cimatrix_slice& cimatrix_slice::operator*=(const srmatrix_slice& M) {
08309   *this *= M.A;
08310   return *this;
08311 }
08312 
08313 inline cimatrix& cimatrix::operator*=(const scmatrix_slice& M) {
08314   *this *= M.A;
08315   return *this;
08316 }
08317 
08318 inline cimatrix_slice& cimatrix_slice::operator*=(const scmatrix_slice& M) {
08319   *this *= M.A;
08320   return *this;
08321 }
08322 
08323 inline cimatrix& cimatrix::operator*=(const simatrix_slice& M) {
08324   *this *= M.A;
08325   return *this;
08326 }
08327 
08328 inline cimatrix_slice& cimatrix_slice::operator*=(const simatrix_slice& M) {
08329   *this *= M.A;
08330   return *this;
08331 }
08332 
08333 inline cimatrix& cimatrix::operator*=(const scimatrix_slice& M) {
08334   *this *= M.A;
08335   return *this;
08336 }
08337 
08338 inline cimatrix_slice& cimatrix_slice::operator*=(const scimatrix_slice& M) {
08339   *this *= M.A;
08340   return *this;
08341 }
08342 
08343 inline cimatrix& cimatrix::operator|=(const srmatrix_slice& M) {
08344   *this |= M.A;
08345   return *this;
08346 }
08347 
08348 inline cimatrix_slice& cimatrix_slice::operator|=(const srmatrix_slice& M) {
08349   *this |= M.A;
08350   return *this;
08351 }
08352 
08353 inline cimatrix& cimatrix::operator|=(const scmatrix_slice& M) {
08354   *this |= M.A;
08355   return *this;
08356 }
08357 
08358 inline cimatrix_slice& cimatrix_slice::operator|=(const scmatrix_slice& M) {
08359   *this |= M.A;
08360   return *this;
08361 }
08362 
08363 inline cimatrix& cimatrix::operator|=(const simatrix_slice& M) {
08364   *this |= M.A;
08365   return *this;
08366 }
08367 
08368 inline cimatrix_slice& cimatrix_slice::operator|=(const simatrix_slice& M) {
08369   *this |= M.A;
08370   return *this;
08371 }
08372 
08373 inline cimatrix& cimatrix::operator|=(const scimatrix_slice& M) {
08374   *this |= M.A;
08375   return *this;
08376 }
08377 
08378 inline cimatrix_slice& cimatrix_slice::operator|=(const scimatrix_slice& M) {
08379   *this |= M.A;
08380   return *this;
08381 }
08382 
08383 inline cimatrix& cimatrix::operator&=(const simatrix_slice& M) {
08384   *this &= M.A;
08385   return *this;
08386 }
08387 
08388 inline cimatrix_slice& cimatrix_slice::operator&=(const simatrix_slice& M) {
08389   *this &= M.A;
08390   return *this;
08391 }
08392 
08393 inline cimatrix& cimatrix::operator&=(const scimatrix_slice& M) {
08394   *this &= M.A;
08395   return *this;
08396 }
08397 
08398 inline cimatrix_slice& cimatrix_slice::operator&=(const scimatrix_slice& M) {
08399   *this &= M.A;
08400   return *this;
08401 }
08402 
08404 inline bool operator==(const scimatrix_slice& M1, const srmatrix_slice& M2) {
08405   return spsp_mm_comp(M1.A,M2.A);
08406 }
08407 
08409 inline bool operator==(const scimatrix_slice& M1, const scmatrix_slice& M2) {
08410   return spsp_mm_comp(M1.A,M2.A);
08411 }
08412 
08414 inline bool operator==(const scimatrix_slice& M1, const simatrix_slice& M2) {
08415   return spsp_mm_comp(M1.A,M2.A);
08416 }
08417 
08419 inline bool operator==(const scimatrix_slice& M1, const scimatrix_slice& M2) {
08420   return spsp_mm_comp(M1.A,M2.A);
08421 }
08422 
08424 inline bool operator==(const srmatrix_slice& M1, const scimatrix_slice& M2) {
08425   return spsp_mm_comp(M1.A,M2.A);
08426 }
08427 
08429 inline bool operator==(const scmatrix_slice& M1, const scimatrix_slice& M2) {
08430   return spsp_mm_comp(M1.A,M2.A);
08431 }
08432 
08434 inline bool operator==(const simatrix_slice& M1, const scimatrix_slice& M2) {
08435   return spsp_mm_comp(M1.A,M2.A);
08436 }
08437 
08439 inline bool operator==(const scimatrix_slice& M1, const srmatrix& M2) {
08440   return spsp_mm_comp(M1.A,M2);
08441 }
08442 
08444 inline bool operator==(const scimatrix_slice& M1, const