26#ifndef _CXSC_SCIMATRIX_HPP_INCLUDED
27#define _CXSC_SCIMATRIX_HPP_INCLUDED
29#include <cinterval.hpp>
30#include <cimatrix.hpp>
31#include <civector.hpp>
36#include <sparsecidot.hpp>
37#include <sparsematrix.hpp>
38#include <srmatrix.hpp>
39#include <scmatrix.hpp>
40#include <simatrix.hpp>
41#include <srvector.hpp>
42#include <sivector.hpp>
43#include <scvector.hpp>
44#include <scivector.hpp>
54inline bool comp_pair_ci(std::pair<int,cinterval> p1, std::pair<int,cinterval> p2) {
55 return p1.first < p2.first;
76 std::vector<cinterval> x;
109 const std::vector<cinterval>&
values()
const {
117 lb1 = lb2 = ub1 = ub2 = 0;
121 scimatrix(
const int r,
const int c) : m(r),n(c),lb1(1),ub1(r),lb2(1),ub2(c) {
122 p = std::vector<int>((n>0) ? n+1 : 1, 0);
123 ind.reserve(2*(m+n));
130 scimatrix(
const int r,
const int c,
const int e) : m(r),n(c),lb1(1),ub1(r),lb2(1),ub2(c) {
131 p = std::vector<int>((n>0) ? n+1 : 1, 0);
149 p = std::vector<int>(n+1,0);
155 std::vector<triplet_store<cinterval> > work;
158 for(
int k=0 ; k<nnz ; k++) {
159 work.push_back(triplet_store<cinterval>(rows[
Lb(rows)+k],cols[
Lb(cols)+k],
values[
Lb(
values)+k]));
162 sort(work.begin(), work.end());
166 for(
int j=0 ; j<n ; j++) {
168 while((
unsigned int)i < work.size() && work[i].col == j ) {
169 ind.push_back(work[i].row);
170 x.push_back(work[i].val);
177 }
else if(t == compressed_row) {
181 p = std::vector<int>(n+1,0);
187 for(
int i=0 ; i<n+1 ; i++)
188 p[i] = rows[
Lb(rows)+i];
190 std::vector<triplet_store<cinterval> > work;
193 for(
int j=0 ; j<n ; j++) {
194 for(
int k=p[j] ; k<p[j+1] ; k++) {
195 work.push_back(triplet_store<cinterval>(j,cols[
Lb(cols)+k],
values[
Lb(
values)+k]));
199 sort(work.begin(), work.end());
203 for(
int j=0 ; j<n ; j++) {
205 while((
unsigned int)i < work.size() && work[i].col == j ) {
206 ind.push_back(work[i].row);
207 x.push_back(work[i].val);
214 }
else if(t == compressed_column) {
217 p = std::vector<int>(n+1,0);
223 for(
int i=0 ; i<n+1 ; i++)
224 p[i] = rows[
Lb(rows)+i];
226 std::vector<std::pair<int,cinterval> > work;
229 for(
int j=0 ; j<n ; j++) {
232 for(
int k=p[j] ; k<p[j+1] ; k++) {
236 std::sort(work.begin(),work.end(),comp_pair_ci);
238 for(
unsigned int i=0 ; i<work.size() ; i++) {
239 ind.push_back(work[i].first);
240 x.push_back(work[i].second);
260 p = std::vector<int>(n+1,0);
266 std::vector<triplet_store<cinterval> > work;
269 for(
int k=0 ; k<nnz ; k++) {
270 work.push_back(triplet_store<cinterval>(rows[k],cols[k],
values[k]));
273 sort(work.begin(), work.end());
277 for(
int j=0 ; j<n ; j++) {
279 while((
unsigned int)i < work.size() && work[i].col == j ) {
280 ind.push_back(work[i].row);
281 x.push_back(work[i].val);
288 }
else if(t == compressed_row) {
292 p = std::vector<int>(n+1,0);
298 for(
int i=0 ; i<n+1 ; i++)
301 std::vector<triplet_store<cinterval> > work;
304 for(
int j=0 ; j<n ; j++) {
305 for(
int k=p[j] ; k<p[j+1] ; k++) {
306 work.push_back(triplet_store<cinterval>(j,cols[k],
values[k]));
310 sort(work.begin(), work.end());
314 for(
int j=0 ; j<n ; j++) {
316 while((
unsigned int)i < work.size() && work[i].col == j ) {
317 ind.push_back(work[i].row);
318 x.push_back(work[i].val);
325 }
else if(t == compressed_column) {
328 p = std::vector<int>(n+1,0);
334 for(
int i=0 ; i<n+1 ; i++)
337 std::vector<std::pair<int,cinterval> > work;
340 for(
int j=0 ; j<n ; j++) {
343 for(
int k=p[j] ; k<p[j+1] ; k++) {
344 work.push_back(std::make_pair(cols[k],
values[k]));
347 std::sort(work.begin(),work.end(),comp_pair_ci);
349 for(
unsigned int i=0 ; i<work.size() ; i++) {
350 ind.push_back(work[i].first);
351 x.push_back(work[i].second);
360 scimatrix(
const srmatrix& A) : p(A.p), ind(A.ind), m(A.m), n(A.n), lb1(A.lb1), ub1(A.ub1), lb2(A.lb2), ub2(A.ub2) {
362 for(
unsigned int i=0 ; i<A.x.size() ; i++)
367 scimatrix(
const scmatrix& A) : p(A.p), ind(A.ind), m(A.m), n(A.n), lb1(A.lb1), ub1(A.ub1), lb2(A.lb2), ub2(A.ub2) {
369 for(
unsigned int i=0 ; i<A.x.size() ; i++)
374 scimatrix(
const simatrix& A) : p(A.p), ind(A.ind), m(A.m), n(A.n), lb1(A.lb1), ub1(A.ub1), lb2(A.lb2), ub2(A.ub2) {
376 for(
unsigned int i=0 ; i<A.x.size() ; i++)
382 p = std::vector<int>((n>0) ? n+1 : 1, 0);
383 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
384 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
389 for(
int j=0 ; j<n ; j++) {
390 for(
int i=0 ; i<m ; i++) {
391 if(A[i+lb1][j+lb2] != 0.0) {
405 p = std::vector<int>((n>0) ? n+1 : 1, 0);
406 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
407 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
412 for(
int j=0 ; j<n ; j++) {
413 for(
int i=0 ; i<m ; i++) {
414 if(A[i+lb1][j+lb2] != 0.0) {
428 p = std::vector<int>((n>0) ? n+1 : 1, 0);
429 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
430 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
435 for(
int j=0 ; j<n ; j++) {
436 for(
int i=0 ; i<m ; i++) {
437 if(A[i+lb1][j+lb2] != 0.0) {
451 p = std::vector<int>((n>0) ? n+1 : 1, 0);
452 ind.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
453 x.reserve((m*n*0.1 < 2*m) ? (int)(m*n*0.1) : 2*m);
458 for(
int j=0 ; j<n ; j++) {
459 for(
int i=0 ; i<m ; i++) {
460 if(A[i+lb1][j+lb2] != 0.0) {
462 x.push_back(A[i+lb1][j+lb2]);
476 scimatrix(
const int ms,
const int ns,
const cimatrix& A) : m(ms), n(ns), lb1(1), ub1(ms), lb2(1), ub2(ns) {
479 p = std::vector<int>((n>0) ? n+1 : 1, 0);
483 std::vector<triplet_store<cinterval> > work;
487 for(
int i=0 ; i<
ColLen(A) ; i++) {
488 for(
int j=
Lb(A,2) ; j<=
Ub(A,2) ; j++) {
489 if(i+j >=0 && i+j < n) {
490 work.push_back(triplet_store<cinterval>(i,i+j,A[i+
Lb(A,1)][j]));
495 sort(work.begin(), work.end());
499 for(
int j=0 ; j<n ; j++) {
501 while((
unsigned int)i < work.size() && work[i].col == j ) {
502 ind.push_back(work[i].row);
503 x.push_back(work[i].val);
525 for(
int j=0 ; j<n ; j++) {
526 for(
int k=p[j] ; k<p[j+1] ; k++) {
527 A[ind[k]+lb1][j+lb2] = x[k];
538 std::vector<int> pnew(n+1,0);
539 std::vector<int> indnew;
540 std::vector<cinterval> xnew;
543 for(
int j=0 ; j<n ; j++) {
544 for(
int k=p[j] ; k<p[j+1] ; k++) {
546 xnew.push_back(x[k]);
547 indnew.push_back(ind[k]);
562 return sp_ms_assign<scimatrix,real,cinterval>(*
this,A);
567 return sp_ms_assign<scimatrix,interval,cinterval>(*
this,A);
572 return sp_ms_assign<scimatrix,complex,cinterval>(*
this,A);
577 return sp_ms_assign<scimatrix,cinterval,cinterval>(*
this,A);
582 return spf_mm_assign<scimatrix,rmatrix,cinterval>(*
this,A);
587 return spf_mm_assign<scimatrix,cmatrix,cinterval>(*
this,A);
592 return spf_mm_assign<scimatrix,imatrix,cinterval>(*
this,A);
597 return spf_mm_assign<scimatrix,cimatrix,cinterval>(*
this,A);
602 return spf_mm_assign<scimatrix,rmatrix_slice,cinterval>(*
this,A);
607 return spf_mm_assign<scimatrix,cmatrix_slice,cinterval>(*
this,A);
612 return spf_mm_assign<scimatrix,imatrix_slice,cinterval>(*
this,A);
617 return spf_mm_assign<scimatrix,cimatrix_slice,cinterval>(*
this,A);
628 for(
unsigned int i=0 ; i<A.x.size() ; i++)
641 for(
unsigned int i=0 ; i<A.x.size() ; i++)
654 for(
unsigned int i=0 ; i<A.x.size() ; i++)
684 if(i<lb1 || i>ub1 || j<lb2 || j>ub2)
685 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix::operator()(int, int)"));
688 for(
int k=p[j-lb2] ; k<p[j-lb2+1] && ind[k]<=i-lb1 ; k++) {
689 if(ind[k] == i-lb1) r = x[k];
705 if(i<lb1 || i>ub1 || j<lb2 || j>ub2)
706 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix::element(int, int)"));
709 for(k=p[j-lb2] ; k<p[j-lb2+1] && ind[k]<=i-lb1 ; k++) {
710 if(ind[k] == i-lb1)
return x[k];
714 std::vector<int>::iterator ind_it = ind.begin() + k;
715 std::vector<cinterval>::iterator x_it = x.begin() + k;
716 ind.insert(ind_it, i-lb1);
718 for(k=j-lb2+1 ; k<(int)p.size() ; k++)
744 for(
int k=0 ; k<n ; k++) {
747 std::map<int,cinterval> work;
748 for(
int j=p[q[
Lb(q)+k]] ; j<p[q[
Lb(q)+k]+1] ; j++)
749 work.insert(std::make_pair(per[
Lb(per)+ind[j]], x[j]));
751 for(std::map<int,cinterval>::iterator it = work.begin() ; it != work.end() ; it++) {
752 A.ind.push_back(it->first);
753 A.x.push_back(it->second);
770 for(
int k=0 ; k<n ; k++) {
773 std::map<int,cinterval> work;
774 for(
int j=p[k] ; j<p[k+1] ; j++)
775 work.insert(std::make_pair(per[
Lb(per)+ind[j]], x[j]));
777 for(std::map<int,cinterval>::iterator it = work.begin() ; it != work.end() ; it++) {
778 A.ind.push_back(it->first);
779 A.x.push_back(it->second);
804 return p[n]/((double)m*n);
814 return spf_mm_addassign<scimatrix,rmatrix,cimatrix>(*
this,B);
819 return spf_mm_addassign<scimatrix,cmatrix,cimatrix>(*
this,B);
824 return spf_mm_addassign<scimatrix,imatrix,cimatrix>(*
this,B);
829 return spf_mm_addassign<scimatrix,cimatrix,cimatrix>(*
this,B);
834 return spf_mm_addassign<scimatrix,rmatrix_slice,cimatrix>(*
this,B);
839 return spf_mm_addassign<scimatrix,cmatrix_slice,cimatrix>(*
this,B);
844 return spf_mm_addassign<scimatrix,imatrix_slice,cimatrix>(*
this,B);
849 return spf_mm_addassign<scimatrix,cimatrix_slice,cimatrix>(*
this,B);
854 return spsp_mm_addassign<scimatrix,srmatrix,cinterval>(*
this,B);
859 return spsp_mm_addassign<scimatrix,scmatrix,cinterval>(*
this,B);
864 return spsp_mm_addassign<scimatrix,simatrix,cinterval>(*
this,B);
869 return spsp_mm_addassign<scimatrix,scimatrix,cinterval>(*
this,B);
874 return spf_mm_subassign<scimatrix,rmatrix,cimatrix>(*
this,B);
879 return spf_mm_subassign<scimatrix,cmatrix,cimatrix>(*
this,B);
884 return spf_mm_subassign<scimatrix,imatrix,cimatrix>(*
this,B);
889 return spf_mm_subassign<scimatrix,cimatrix,cimatrix>(*
this,B);
894 return spf_mm_subassign<scimatrix,rmatrix_slice,cimatrix>(*
this,B);
899 return spf_mm_subassign<scimatrix,cmatrix_slice,cimatrix>(*
this,B);
904 return spf_mm_subassign<scimatrix,imatrix_slice,cimatrix>(*
this,B);
909 return spf_mm_subassign<scimatrix,cimatrix_slice,cimatrix>(*
this,B);
914 return spsp_mm_subassign<scimatrix,srmatrix,cinterval>(*
this,B);
919 return spsp_mm_subassign<scimatrix,scmatrix,cinterval>(*
this,B);
924 return spsp_mm_subassign<scimatrix,simatrix,cinterval>(*
this,B);
929 return spsp_mm_subassign<scimatrix,scimatrix,cinterval>(*
this,B);
934 return spf_mm_hullassign<scimatrix,rmatrix,cimatrix>(*
this,B);
939 return spf_mm_hullassign<scimatrix,cmatrix,cimatrix>(*
this,B);
944 return spf_mm_hullassign<scimatrix,imatrix,cimatrix>(*
this,B);
949 return spf_mm_hullassign<scimatrix,cimatrix,cimatrix>(*
this,B);
954 return spf_mm_hullassign<scimatrix,rmatrix_slice,cimatrix>(*
this,B);
959 return spf_mm_hullassign<scimatrix,cmatrix_slice,cimatrix>(*
this,B);
964 return spf_mm_hullassign<scimatrix,imatrix_slice,cimatrix>(*
this,B);
969 return spf_mm_hullassign<scimatrix,cimatrix_slice,cimatrix>(*
this,B);
974 return spsp_mm_hullassign<scimatrix,srmatrix,cinterval>(*
this,B);
979 return spsp_mm_hullassign<scimatrix,scmatrix,cinterval>(*
this,B);
984 return spsp_mm_hullassign<scimatrix,simatrix,cinterval>(*
this,B);
989 return spsp_mm_hullassign<scimatrix,scimatrix,cinterval>(*
this,B);
994 return spf_mm_intersectassign<scimatrix,imatrix,cimatrix>(*
this,B);
999 return spf_mm_intersectassign<scimatrix,cimatrix,cimatrix>(*
this,B);
1004 return spf_mm_intersectassign<scimatrix,imatrix_slice,cimatrix>(*
this,B);
1009 return spf_mm_intersectassign<scimatrix,cimatrix_slice,cimatrix>(*
this,B);
1014 return spsp_mm_intersectassign<scimatrix,simatrix,cinterval>(*
this,B);
1019 return spsp_mm_intersectassign<scimatrix,scimatrix,cinterval>(*
this,B);
1024 return spf_mm_multassign<scimatrix,cmatrix,sparse_cidot,cimatrix>(*
this,B);
1029 return spf_mm_multassign<scimatrix,rmatrix,sparse_cidot,cimatrix>(*
this,B);
1034 return spf_mm_multassign<scimatrix,imatrix,sparse_cidot,cimatrix>(*
this,B);
1039 return spf_mm_multassign<scimatrix,cimatrix,sparse_cidot,cimatrix>(*
this,B);
1044 return spf_mm_multassign<scimatrix,rmatrix_slice,sparse_cidot,cimatrix>(*
this,B);
1049 return spf_mm_multassign<scimatrix,cmatrix_slice,sparse_cidot,cimatrix>(*
this,B);
1054 return spf_mm_multassign<scimatrix,imatrix_slice,sparse_cidot,cimatrix>(*
this,B);
1059 return spf_mm_multassign<scimatrix,cimatrix_slice,sparse_cidot,cimatrix>(*
this,B);
1064 return spsp_mm_multassign<scimatrix,srmatrix,sparse_cidot,cinterval>(*
this,B);
1069 return spsp_mm_multassign<scimatrix,scmatrix,sparse_cidot,cinterval>(*
this,B);
1074 return spsp_mm_multassign<scimatrix,simatrix,sparse_cidot,cinterval>(*
this,B);
1079 return spsp_mm_multassign<scimatrix,scimatrix,sparse_cidot,cinterval>(*
this,B);
1084 return sp_ms_multassign(*
this,r);
1089 return sp_ms_multassign(*
this,r);
1094 return sp_ms_multassign(*
this,r);
1099 return sp_ms_multassign(*
this,r);
1104 return sp_ms_divassign(*
this,r);
1109 return sp_ms_divassign(*
this,r);
1114 return sp_ms_divassign(*
this,r);
1119 return sp_ms_divassign(*
this,r);
1162#include "matrix_friend_declarations.inl"
1167 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1171 for(
int j=0 ; j<A.n ; j++) {
1172 for(
int k=A.p[j] ; k<A.p[j+1] ; k++) {
1173 dat[A.ind[k]*A.n+j] = A.x[k];
1180 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1184 for(
int j=0 ; j<A.n ; j++) {
1185 for(
int k=A.p[j] ; k<A.p[j+1] ; k++) {
1186 dat[A.ind[k]*A.n+j] = A.x[k];
1193 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1197 for(
int j=0 ; j<A.n ; j++) {
1198 for(
int k=A.p[j] ; k<A.p[j+1] ; k++) {
1199 dat[A.ind[k]*A.n+j] = A.x[k];
1206 lb1 = A.lb1; lb2 = A.lb2; ub1 = A.ub1; ub2 = A.ub2;
1210 for(
int j=0 ; j<A.n ; j++) {
1211 for(
int k=A.p[j] ; k<A.p[j+1] ; k++) {
1212 dat[A.ind[k]*A.n+j] = A.x[k];
1219 scimatrix I(A.m, A.n, (A.m>A.n) ? A.m : A.n);
1220 I.lb1 = A.lb1; I.lb2 = A.lb2;
1221 I.ub1 = A.ub1; I.ub2 = A.ub2;
1224 for(
int i=0 ; i<A.m ; i++) {
1225 I.p[i+1] = I.p[i] + 1;
1230 for(
int i=0 ; i<A.n ; i++) {
1231 I.p[i+1] = I.p[i] + 1;
1249 res.p[A.n] = A.p[A.n];
1251 for(
int j=0 ; j<res.n ; j++) {
1252 for(
int k=A.p[j] ; k<A.p[j+1] ; k++) {
1254 res.x.push_back(Inf(
abs(A.x[k])));
1256 res.x.push_back(-Sup(
abs(A.x[k])));
1270 std::vector<int> w(A.m,0);
1271 for(
unsigned int i=0 ; i<A.ind.size() ; i++)
1277 for(
unsigned int i=1 ; i<B.p.size() ; i++)
1278 B.p[i] = w[i-1] + B.p[i-1];
1281 w.insert(w.begin(), 0);
1282 for(
unsigned int i=1 ; i<w.size() ; i++) {
1290 for(
int j=0 ; j<A.n ; j++) {
1291 for(
int k=A.p[j] ; k<A.p[j+1] ; k++) {
1309 A.ub1 = j + A.m - 1;
1312 A.ub2 = j + A.n - 1;
1324 A.lb1 = j - A.m + 1;
1327 A.lb2 = j - A.n + 1;
1379 sp_m_resize(A,l1,u1,l2,u2);
1392 for(
int i=0 ; i<res.
get_nnz() ; i++)
1393 res.x.push_back(Re(A.x[i]));
1410 for(
int i=0 ; i<res.
get_nnz() ; i++)
1411 res.x.push_back(Im(A.x[i]));
1428 for(
int i=0 ; i<res.
get_nnz() ; i++)
1429 res.x.push_back(Inf(A.x[i]));
1446 for(
int i=0 ; i<res.
get_nnz() ; i++)
1447 res.x.push_back(Sup(A.x[i]));
1464 for(
int i=0 ; i<res.
get_nnz() ; i++)
1465 res.x.push_back(conj(A.x[i]));
1482 for(
int i=0 ; i<res.
get_nnz() ; i++)
1483 res.x.push_back(
abs(A.x[i]));
1500 for(
int i=0 ; i<res.
get_nnz() ; i++)
1501 res.x.push_back(
mid(A.x[i]));
1518 for(
int i=0 ; i<res.
get_nnz() ; i++)
1519 res.x.push_back(
diam(A.x[i]));
1536 for(
int i=0 ; i<res.
get_nnz() ; i++)
1537 res.x.push_back(InfRe(A.x[i]));
1554 for(
int i=0 ; i<res.
get_nnz() ; i++)
1555 res.x.push_back(InfIm(A.x[i]));
1572 for(
int i=0 ; i<res.
get_nnz() ; i++)
1573 res.x.push_back(SupRe(A.x[i]));
1590 for(
int i=0 ; i<res.
get_nnz() ; i++)
1591 res.x.push_back(SupIm(A.x[i]));
1606 return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(A,B);
1617 return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
1628 return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(A,B);
1639 return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1650 return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1661 return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1672 return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(A,B);
1683 return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(A,B);
1694 return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(A,B);
1705 return spf_mm_mult<scimatrix,rmatrix,cimatrix,sparse_cidot>(A,B);
1716 return spf_mm_mult<scimatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
1727 return spf_mm_mult<scimatrix,imatrix,cimatrix,sparse_cidot>(A,B);
1738 return spf_mm_mult<scimatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1749 return spf_mm_mult<srmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1760 return spf_mm_mult<scmatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1771 return spf_mm_mult<simatrix,cimatrix,cimatrix,sparse_cidot>(A,B);
1782 return spf_mm_mult<scmatrix,imatrix,cimatrix,sparse_cidot>(A,B);
1793 return spf_mm_mult<simatrix,cmatrix,cimatrix,sparse_cidot>(A,B);
1804 return fsp_mm_mult<cimatrix_slice,srmatrix,cimatrix,sparse_cidot>(A,B);
1815 return fsp_mm_mult<cimatrix_slice,scmatrix,cimatrix,sparse_cidot>(A,B);
1826 return fsp_mm_mult<cimatrix_slice,simatrix,cimatrix,sparse_cidot>(A,B);
1837 return fsp_mm_mult<cimatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1848 return fsp_mm_mult<rmatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1859 return fsp_mm_mult<imatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1870 return fsp_mm_mult<cmatrix_slice,scimatrix,cimatrix,sparse_cidot>(A,B);
1881 return fsp_mm_mult<cmatrix_slice,simatrix,cimatrix,sparse_cidot>(A,B);
1892 return fsp_mm_mult<imatrix_slice,scmatrix,cimatrix,sparse_cidot>(A,B);
1903 return spf_mm_mult<scimatrix,rmatrix_slice,cimatrix,sparse_cidot>(A,B);
1914 return spf_mm_mult<scimatrix,cmatrix_slice,cimatrix,sparse_cidot>(A,B);
1925 return spf_mm_mult<scimatrix,imatrix_slice,cimatrix,sparse_cidot>(A,B);
1936 return spf_mm_mult<scimatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1947 return spf_mm_mult<srmatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1958 return spf_mm_mult<scmatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1969 return spf_mm_mult<simatrix,cimatrix_slice,cimatrix,sparse_cidot>(A,B);
1980 return spf_mm_mult<scmatrix,imatrix_slice,cimatrix,sparse_cidot>(A,B);
1991 return spf_mm_mult<simatrix,cmatrix_slice,cimatrix,sparse_cidot>(A,B);
2002 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2013 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2024 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2035 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2046 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2057 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2068 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2079 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2090 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(A,B);
2095 return sp_ms_div<scimatrix,real,scimatrix>(A,r);
2100 return sp_ms_div<scimatrix,complex,scimatrix>(A,r);
2105 return sp_ms_div<scimatrix,interval,scimatrix>(A,r);
2110 return sp_ms_div<scimatrix,cinterval,scimatrix>(A,r);
2115 return sp_ms_div<srmatrix,cinterval,scimatrix>(A,r);
2120 return sp_ms_div<simatrix,cinterval,scimatrix>(A,r);
2125 return sp_ms_div<scmatrix,cinterval,scimatrix>(A,r);
2130 return sp_ms_div<scmatrix,interval,scimatrix>(A,r);
2135 return sp_ms_div<simatrix,complex,scimatrix>(A,r);
2140 return sp_ms_mult<scimatrix,real,scimatrix>(A,r);
2145 return sp_ms_mult<scimatrix,complex,scimatrix>(A,r);
2150 return sp_ms_mult<scimatrix,interval,scimatrix>(A,r);
2155 return sp_ms_mult<scimatrix,cinterval,scimatrix>(A,r);
2160 return sp_ms_mult<srmatrix,cinterval,scimatrix>(A,r);
2165 return sp_ms_mult<simatrix,cinterval,scimatrix>(A,r);
2170 return sp_ms_mult<scmatrix,cinterval,scimatrix>(A,r);
2175 return sp_ms_mult<scmatrix,interval,scimatrix>(A,r);
2180 return sp_ms_mult<simatrix,complex,scimatrix>(A,r);
2185 return sp_sm_mult<real,scimatrix,scimatrix>(r,A);
2190 return sp_sm_mult<complex,scimatrix,scimatrix>(r,A);
2195 return sp_sm_mult<interval,scimatrix,scimatrix>(r,A);
2200 return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,A);
2205 return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,A);
2210 return sp_sm_mult<cinterval,simatrix,scimatrix>(r,A);
2215 return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,A);
2220 return sp_sm_mult<complex,simatrix,scimatrix>(r,A);
2225 return sp_sm_mult<interval,scmatrix,scimatrix>(r,A);
2236 return spf_mv_mult<scimatrix,rvector,civector,sparse_cidot>(A,v);
2247 return spf_mv_mult<scimatrix,cvector,civector,sparse_cidot>(A,v);
2258 return spf_mv_mult<scimatrix,ivector,civector,sparse_cidot>(A,v);
2269 return spf_mv_mult<scimatrix,civector,civector,sparse_cidot>(A,v);
2280 return spf_mv_mult<srmatrix,civector,civector,sparse_cidot>(A,v);
2291 return spf_mv_mult<scmatrix,civector,civector,sparse_cidot>(A,v);
2302 return spf_mv_mult<simatrix,civector,civector,sparse_cidot>(A,v);
2313 return spf_mv_mult<scmatrix,ivector,civector,sparse_cidot>(A,v);
2324 return spf_mv_mult<simatrix,cvector,civector,sparse_cidot>(A,v);
2335 return spf_mv_mult<scimatrix,rvector_slice,civector,sparse_cidot>(A,v);
2346 return spf_mv_mult<scimatrix,ivector_slice,civector,sparse_cidot>(A,v);
2357 return spf_mv_mult<scimatrix,cvector_slice,civector,sparse_cidot>(A,v);
2368 return spf_mv_mult<scimatrix,civector_slice,civector,sparse_cidot>(A,v);
2379 return spf_mv_mult<srmatrix,civector_slice,civector,sparse_cidot>(A,v);
2390 return spf_mv_mult<scmatrix,civector_slice,civector,sparse_cidot>(A,v);
2401 return spf_mv_mult<simatrix,civector_slice,civector,sparse_cidot>(A,v);
2412 return spf_mv_mult<simatrix,cvector_slice,civector,sparse_cidot>(A,v);
2423 return spf_mv_mult<scmatrix,ivector_slice,civector,sparse_cidot>(A,v);
2434 return spsp_mv_mult<scimatrix,srvector,scivector,sparse_cidot,cinterval>(A,v);
2445 return spsp_mv_mult<scimatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
2456 return spsp_mv_mult<scimatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
2467 return spsp_mv_mult<scimatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2478 return spsp_mv_mult<srmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2489 return spsp_mv_mult<scmatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2500 return spsp_mv_mult<simatrix,scivector,scivector,sparse_cidot,cinterval>(A,v);
2510 return spsp_mv_mult<scmatrix,sivector,scivector,sparse_cidot,cinterval>(A,v);
2521 return spsp_mv_mult<simatrix,scvector,scivector,sparse_cidot,cinterval>(A,v);
2532 return spsl_mv_mult<scimatrix,srvector_slice,scivector,sparse_cidot,cinterval>(A,v);
2543 return spsl_mv_mult<scimatrix,scvector_slice,scivector,sparse_cidot,cinterval>(A,v);
2554 return spsl_mv_mult<scimatrix,sivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2565 return spsl_mv_mult<scimatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2576 return spsl_mv_mult<srmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2587 return spsl_mv_mult<scmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2598 return spsl_mv_mult<simatrix,scivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2609 return spsl_mv_mult<simatrix,scvector_slice,scivector,sparse_cidot,cinterval>(A,v);
2620 return spsl_mv_mult<scmatrix,sivector_slice,scivector,sparse_cidot,cinterval>(A,v);
2631 return fsp_mv_mult<cimatrix,srvector,civector,sparse_cidot>(A,v);
2642 return fsp_mv_mult<cimatrix,sivector,civector,sparse_cidot>(A,v);
2653 return fsp_mv_mult<cimatrix,scvector,civector,sparse_cidot>(A,v);
2664 return fsp_mv_mult<cimatrix,scivector,civector,sparse_cidot>(A,v);
2675 return fsp_mv_mult<rmatrix,scivector,civector,sparse_cidot>(A,v);
2686 return fsp_mv_mult<cmatrix,scivector,civector,sparse_cidot>(A,v);
2697 return fsp_mv_mult<imatrix,scivector,civector,sparse_cidot>(A,v);
2708 return fsp_mv_mult<cmatrix,sivector,civector,sparse_cidot>(A,v);
2719 return fsp_mv_mult<imatrix,scvector,civector,sparse_cidot>(A,v);
2730 return fsp_mv_mult<cimatrix_slice,srvector,civector,sparse_cidot>(A,v);
2741 return fsp_mv_mult<cimatrix_slice,scvector,civector,sparse_cidot>(A,v);
2752 return fsp_mv_mult<cimatrix_slice,sivector,civector,sparse_cidot>(A,v);
2763 return fsp_mv_mult<cimatrix_slice,scivector,civector,sparse_cidot>(A,v);
2774 return fsp_mv_mult<rmatrix_slice,scivector,civector,sparse_cidot>(A,v);
2785 return fsp_mv_mult<cmatrix_slice,scivector,civector,sparse_cidot>(A,v);
2796 return fsp_mv_mult<imatrix_slice,scivector,civector,sparse_cidot>(A,v);
2807 return fsp_mv_mult<cmatrix_slice,sivector,civector,sparse_cidot>(A,v);
2818 return fsp_mv_mult<imatrix_slice,scvector,civector,sparse_cidot>(A,v);
2829 return fsl_mv_mult<cimatrix,srvector_slice,civector,sparse_cidot>(A,v);
2840 return fsl_mv_mult<cimatrix,scvector_slice,civector,sparse_cidot>(A,v);
2851 return fsl_mv_mult<cimatrix,sivector_slice,civector,sparse_cidot>(A,v);
2862 return fsl_mv_mult<cimatrix,scivector_slice,civector,sparse_cidot>(A,v);
2873 return fsl_mv_mult<rmatrix,scivector_slice,civector,sparse_cidot>(A,v);
2884 return fsl_mv_mult<cmatrix,scivector_slice,civector,sparse_cidot>(A,v);
2895 return fsl_mv_mult<imatrix,scivector_slice,civector,sparse_cidot>(A,v);
2906 return fsl_mv_mult<cmatrix,sivector_slice,civector,sparse_cidot>(A,v);
2917 return fsl_mv_mult<imatrix,scvector_slice,civector,sparse_cidot>(A,v);
2928 return fsl_mv_mult<cimatrix_slice,srvector_slice,civector,sparse_cidot>(A,v);
2939 return fsl_mv_mult<cimatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
2950 return fsl_mv_mult<cimatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
2961 return fsl_mv_mult<cimatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2972 return fsl_mv_mult<rmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2983 return fsl_mv_mult<imatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
2994 return fsl_mv_mult<cmatrix_slice,scivector_slice,civector,sparse_cidot>(A,v);
3005 return fsl_mv_mult<cmatrix_slice,sivector_slice,civector,sparse_cidot>(A,v);
3016 return fsl_mv_mult<imatrix_slice,scvector_slice,civector,sparse_cidot>(A,v);
3021 return fsp_mm_add<cimatrix,srmatrix,cimatrix>(A,B);
3026 return fsp_mm_add<cimatrix,scmatrix,cimatrix>(A,B);
3031 return fsp_mm_add<cimatrix,simatrix,cimatrix>(A,B);
3036 return fsp_mm_add<cimatrix,scimatrix,cimatrix>(A,B);
3041 return fsp_mm_add<rmatrix,scimatrix,cimatrix>(A,B);
3046 return fsp_mm_add<cmatrix,scimatrix,cimatrix>(A,B);
3051 return fsp_mm_add<imatrix,scimatrix,cimatrix>(A,B);
3056 return fsp_mm_add<imatrix,scmatrix,cimatrix>(A,B);
3061 return fsp_mm_add<cmatrix,simatrix,cimatrix>(A,B);
3066 return spf_mm_add<scimatrix,rmatrix,cimatrix>(A,B);
3071 return spf_mm_add<scimatrix,cmatrix,cimatrix>(A,B);
3076 return spf_mm_add<scimatrix,imatrix,cimatrix>(A,B);
3081 return spf_mm_add<scimatrix,cimatrix,cimatrix>(A,B);
3086 return spf_mm_add<srmatrix,cimatrix,cimatrix>(A,B);
3091 return spf_mm_add<scmatrix,cimatrix,cimatrix>(A,B);
3096 return spf_mm_add<simatrix,cimatrix,cimatrix>(A,B);
3101 return spf_mm_add<simatrix,cmatrix,cimatrix>(A,B);
3106 return spf_mm_add<scmatrix,imatrix,cimatrix>(A,B);
3111 return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(A,B);
3116 return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(A,B);
3121 return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(A,B);
3126 return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(A,B);
3131 return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(A,B);
3136 return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(A,B);
3141 return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(A,B);
3146 return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(A,B);
3151 return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(A,B);
3156 return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(A,B);
3161 return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(A,B);
3166 return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(A,B);
3171 return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(A,B);
3176 return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(A,B);
3181 return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(A,B);
3186 return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(A,B);
3191 return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(A,B);
3196 return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(A,B);
3201 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3206 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3211 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3216 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3221 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3226 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3231 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3236 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3241 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3246 return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(A,B);
3251 return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(A,B);
3256 return fsp_mm_sub<cimatrix,simatrix,cimatrix>(A,B);
3261 return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(A,B);
3266 return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(A,B);
3271 return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(A,B);
3276 return fsp_mm_sub<imatrix,scimatrix,cimatrix>(A,B);
3281 return fsp_mm_sub<imatrix,scmatrix,cimatrix>(A,B);
3286 return fsp_mm_sub<cmatrix,simatrix,cimatrix>(A,B);
3291 return spf_mm_sub<scimatrix,rmatrix,cimatrix>(A,B);
3296 return spf_mm_sub<scimatrix,cmatrix,cimatrix>(A,B);
3301 return spf_mm_sub<scimatrix,imatrix,cimatrix>(A,B);
3306 return spf_mm_sub<scimatrix,cimatrix,cimatrix>(A,B);
3311 return spf_mm_sub<srmatrix,cimatrix,cimatrix>(A,B);
3316 return spf_mm_sub<scmatrix,cimatrix,cimatrix>(A,B);
3321 return spf_mm_sub<simatrix,cimatrix,cimatrix>(A,B);
3326 return spf_mm_sub<simatrix,cmatrix,cimatrix>(A,B);
3331 return spf_mm_sub<scmatrix,imatrix,cimatrix>(A,B);
3336 return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(A,B);
3341 return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(A,B);
3346 return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(A,B);
3351 return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(A,B);
3356 return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(A,B);
3361 return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(A,B);
3366 return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(A,B);
3371 return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(A,B);
3376 return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(A,B);
3381 return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(A,B);
3386 return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(A,B);
3391 return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(A,B);
3396 return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(A,B);
3401 return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(A,B);
3406 return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(A,B);
3411 return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(A,B);
3416 return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(A,B);
3421 return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(A,B);
3426 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3431 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3436 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3441 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3446 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3451 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3456 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3461 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3466 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3471 return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(A,B);
3476 return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(A,B);
3481 return fsp_mm_hull<cimatrix,simatrix,cimatrix>(A,B);
3486 return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(A,B);
3491 return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(A,B);
3496 return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(A,B);
3501 return fsp_mm_hull<imatrix,scimatrix,cimatrix>(A,B);
3506 return fsp_mm_hull<imatrix,scmatrix,cimatrix>(A,B);
3511 return fsp_mm_hull<cmatrix,simatrix,cimatrix>(A,B);
3516 return spf_mm_hull<scimatrix,rmatrix,cimatrix>(A,B);
3521 return spf_mm_hull<scimatrix,cmatrix,cimatrix>(A,B);
3526 return spf_mm_hull<scimatrix,imatrix,cimatrix>(A,B);
3531 return spf_mm_hull<scimatrix,cimatrix,cimatrix>(A,B);
3536 return spf_mm_hull<srmatrix,cimatrix,cimatrix>(A,B);
3541 return spf_mm_hull<scmatrix,cimatrix,cimatrix>(A,B);
3546 return spf_mm_hull<simatrix,cimatrix,cimatrix>(A,B);
3551 return spf_mm_hull<simatrix,cmatrix,cimatrix>(A,B);
3556 return spf_mm_hull<scmatrix,imatrix,cimatrix>(A,B);
3561 return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(A,B);
3566 return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(A,B);
3571 return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(A,B);
3576 return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(A,B);
3581 return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(A,B);
3586 return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(A,B);
3591 return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(A,B);
3596 return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(A,B);
3601 return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(A,B);
3606 return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(A,B);
3611 return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(A,B);
3616 return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(A,B);
3621 return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(A,B);
3626 return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(A,B);
3631 return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(A,B);
3636 return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(A,B);
3641 return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(A,B);
3646 return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(A,B);
3651 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(A,B);
3656 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(A,B);
3661 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3666 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3671 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(A,B);
3676 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(A,B);
3681 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3686 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(A,B);
3691 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(A,B);
3696 return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(A,B);
3701 return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(A,B);
3706 return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(A,B);
3711 return spf_mm_hull<scmatrix,rmatrix,cimatrix>(A,B);
3716 return spf_mm_hull<srmatrix,cmatrix,cimatrix>(A,B);
3721 return spf_mm_hull<scmatrix,cmatrix,cimatrix>(A,B);
3726 return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(A,B);
3731 return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(A,B);
3736 return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(A,B);
3741 return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(A,B);
3746 return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(A,B);
3751 return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(A,B);
3756 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(A,B);
3761 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(A,B);
3766 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(A,B);
3771 return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(A,B);
3776 return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(A,B);
3781 return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(A,B);
3786 return spf_mm_intersect<scimatrix,imatrix,cimatrix>(A,B);
3791 return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(A,B);
3796 return spf_mm_intersect<simatrix,cimatrix,cimatrix>(A,B);
3801 return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(A,B);
3806 return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(A,B);
3811 return fsp_mm_intersect<imatrix_slice,scimatrix,cimatrix>(A,B);
3816 return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(A,B);
3821 return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(A,B);
3826 return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(A,B);
3831 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(A,B);
3836 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(A,B);
3841 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(A,B);
3846 return sp_m_negative<scimatrix,scimatrix>(M);
3895 return fsp_mm_addassign(*
this,B);
3899 return fsp_mm_addassign(*
this,B);
3903 return fsp_mm_addassign(*
this,B);
3907 return fsp_mm_addassign(*
this,B);
3911 return fsp_mm_addassign(*
this,B);
3915 return fsp_mm_addassign(*
this,B);
3919 return fsp_mm_addassign(*
this,B);
3923 return fsp_mm_addassign(*
this,B);
3927 return fsp_mm_subassign(*
this,B);
3931 return fsp_mm_subassign(*
this,B);
3935 return fsp_mm_subassign(*
this,B);
3939 return fsp_mm_subassign(*
this,B);
3943 return fsp_mm_subassign(*
this,B);
3947 return fsp_mm_subassign(*
this,B);
3951 return fsp_mm_subassign(*
this,B);
3955 return fsp_mm_subassign(*
this,B);
3959 return fsp_mm_hullassign(*
this,B);
3963 return fsp_mm_hullassign(*
this,B);
3967 return fsp_mm_hullassign(*
this,B);
3971 return fsp_mm_hullassign(*
this,B);
3975 return fsp_mm_hullassign(*
this,B);
3979 return fsp_mm_hullassign(*
this,B);
3983 return fsp_mm_hullassign(*
this,B);
3987 return fsp_mm_hullassign(*
this,B);
3991 return fsp_mm_intersectassign(*
this,B);
3995 return fsp_mm_intersectassign(*
this,B);
3999 return fsp_mm_intersectassign(*
this,B);
4003 return fsp_mm_intersectassign(*
this,B);
4007 return fsp_mm_multassign<cimatrix,srmatrix,sparse_cidot,cimatrix>(*
this,B);
4011 return fsp_mm_multassign<cimatrix,scmatrix,sparse_cidot,cimatrix>(*
this,B);
4015 return fsp_mm_multassign<cimatrix,simatrix,sparse_cidot,cimatrix>(*
this,B);
4019 return fsp_mm_multassign<cimatrix,scimatrix,sparse_cidot,cimatrix>(*
this,B);
4023 return fsp_mm_multassign<cimatrix_slice,srmatrix,sparse_cidot,cimatrix>(*
this,B);
4027 return fsp_mm_multassign<cimatrix_slice,scmatrix,sparse_cidot,cimatrix>(*
this,B);
4031 return fsp_mm_multassign<cimatrix_slice,simatrix,sparse_cidot,cimatrix>(*
this,B);
4035 return fsp_mm_multassign<cimatrix_slice,scimatrix,sparse_cidot,cimatrix>(*
this,B);
4040 return spsp_mm_comp(A,B);
4045 return spsp_mm_comp(A,B);
4050 return spsp_mm_comp(A,B);
4055 return spsp_mm_comp(A,B);
4060 return spsp_mm_comp(A,B);
4065 return spsp_mm_comp(A,B);
4070 return spsp_mm_comp(A,B);
4075 return spf_mm_comp(A,B);
4080 return spf_mm_comp(A,B);
4085 return spf_mm_comp(A,B);
4090 return spf_mm_comp(A,B);
4095 return spf_mm_comp(A,B);
4100 return spf_mm_comp(A,B);
4105 return spf_mm_comp(A,B);
4110 return fsp_mm_comp(A,B);
4115 return fsp_mm_comp(A,B);
4120 return fsp_mm_comp(A,B);
4125 return fsp_mm_comp(A,B);
4130 return fsp_mm_comp(A,B);
4135 return fsp_mm_comp(A,B);
4140 return fsp_mm_comp(A,B);
4145 return fsp_mm_comp(A,B);
4150 return fsp_mm_comp(A,B);
4155 return fsp_mm_comp(A,B);
4160 return fsp_mm_comp(A,B);
4165 return fsp_mm_comp(A,B);
4170 return fsp_mm_comp(A,B);
4175 return fsp_mm_comp(A,B);
4180 return spf_mm_comp(A,B);
4185 return spf_mm_comp(A,B);
4190 return spf_mm_comp(A,B);
4195 return spf_mm_comp(A,B);
4200 return spf_mm_comp(A,B);
4205 return spf_mm_comp(A,B);
4210 return spf_mm_comp(A,B);
4215 return !spsp_mm_comp(A,B);
4220 return !spsp_mm_comp(A,B);
4225 return !spsp_mm_comp(A,B);
4230 return !spsp_mm_comp(A,B);
4235 return !spsp_mm_comp(A,B);
4240 return !spsp_mm_comp(A,B);
4245 return !spsp_mm_comp(A,B);
4250 return !spf_mm_comp(A,B);
4255 return !spf_mm_comp(A,B);
4260 return !spf_mm_comp(A,B);
4265 return !spf_mm_comp(A,B);
4270 return !spf_mm_comp(A,B);
4275 return !spf_mm_comp(A,B);
4280 return !spf_mm_comp(A,B);
4285 return !fsp_mm_comp(A,B);
4290 return !fsp_mm_comp(A,B);
4295 return !fsp_mm_comp(A,B);
4300 return !fsp_mm_comp(A,B);
4305 return !fsp_mm_comp(A,B);
4310 return !fsp_mm_comp(A,B);
4315 return !fsp_mm_comp(A,B);
4320 return !fsp_mm_comp(A,B);
4325 return !fsp_mm_comp(A,B);
4330 return !fsp_mm_comp(A,B);
4335 return !fsp_mm_comp(A,B);
4340 return !fsp_mm_comp(A,B);
4345 return !fsp_mm_comp(A,B);
4350 return !fsp_mm_comp(A,B);
4355 return !spf_mm_comp(A,B);
4360 return !spf_mm_comp(A,B);
4365 return !spf_mm_comp(A,B);
4370 return !spf_mm_comp(A,B);
4375 return !spf_mm_comp(A,B);
4380 return !spf_mm_comp(A,B);
4385 return !spf_mm_comp(A,B);
4390 return spsp_mm_less<scimatrix,simatrix,cinterval>(A,B);
4395 return spsp_mm_less<scimatrix,scimatrix,cinterval>(A,B);
4400 return spsp_mm_less<srmatrix,scimatrix,cinterval>(A,B);
4405 return spsp_mm_less<scmatrix,scimatrix,cinterval>(A,B);
4410 return spsp_mm_less<simatrix,scimatrix,cinterval>(A,B);
4415 return spf_mm_less<scimatrix,imatrix,cinterval>(A,B);
4420 return spf_mm_less<scimatrix,cimatrix,cinterval>(A,B);
4425 return spf_mm_less<srmatrix,cimatrix,cinterval>(A,B);
4430 return spf_mm_less<scmatrix,cimatrix,cinterval>(A,B);
4435 return spf_mm_less<simatrix,cimatrix,cinterval>(A,B);
4440 return fsp_mm_less<cimatrix,simatrix,cinterval>(A,B);
4445 return fsp_mm_less<cimatrix,scimatrix,cinterval>(A,B);
4450 return fsp_mm_less<rmatrix,scimatrix,cinterval>(A,B);
4455 return fsp_mm_less<cmatrix,scimatrix,cinterval>(A,B);
4460 return fsp_mm_less<imatrix,scimatrix,cinterval>(A,B);
4465 return fsp_mm_less<cimatrix_slice,simatrix,cinterval>(A,B);
4470 return fsp_mm_less<cimatrix_slice,scimatrix,cinterval>(A,B);
4475 return fsp_mm_less<rmatrix_slice,scimatrix,cinterval>(A,B);
4480 return fsp_mm_less<cmatrix_slice,scimatrix,cinterval>(A,B);
4485 return fsp_mm_less<imatrix_slice,scimatrix,cinterval>(A,B);
4490 return spf_mm_less<scimatrix,imatrix_slice,cinterval>(A,B);
4495 return spf_mm_less<scimatrix,cimatrix_slice,cinterval>(A,B);
4500 return spf_mm_less<srmatrix,cimatrix_slice,cinterval>(A,B);
4505 return spf_mm_less<scmatrix,cimatrix_slice,cinterval>(A,B);
4510 return spf_mm_less<simatrix,cimatrix_slice,cinterval>(A,B);
4515 return spsp_mm_leq<scimatrix,simatrix,cinterval>(A,B);
4520 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(A,B);
4525 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(A,B);
4530 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(A,B);
4535 return spsp_mm_leq<simatrix,scimatrix,cinterval>(A,B);
4540 return spf_mm_leq<scimatrix,imatrix,cinterval>(A,B);
4545 return spf_mm_leq<scimatrix,cimatrix,cinterval>(A,B);
4550 return spf_mm_leq<srmatrix,cimatrix,cinterval>(A,B);
4555 return spf_mm_leq<scmatrix,cimatrix,cinterval>(A,B);
4560 return spf_mm_leq<simatrix,cimatrix,cinterval>(A,B);
4565 return fsp_mm_leq<cimatrix,simatrix,cinterval>(A,B);
4570 return fsp_mm_leq<cimatrix,scimatrix,cinterval>(A,B);
4575 return fsp_mm_leq<rmatrix,scimatrix,cinterval>(A,B);
4580 return fsp_mm_leq<cmatrix,scimatrix,cinterval>(A,B);
4585 return fsp_mm_leq<imatrix,scimatrix,cinterval>(A,B);
4590 return fsp_mm_leq<cimatrix_slice,simatrix,cinterval>(A,B);
4595 return fsp_mm_leq<cimatrix_slice,scimatrix,cinterval>(A,B);
4600 return fsp_mm_leq<rmatrix_slice,scimatrix,cinterval>(A,B);
4605 return fsp_mm_leq<cmatrix_slice,scimatrix,cinterval>(A,B);
4610 return fsp_mm_leq<imatrix_slice,scimatrix,cinterval>(A,B);
4615 return spf_mm_leq<scimatrix,imatrix_slice,cinterval>(A,B);
4620 return spf_mm_leq<scimatrix,cimatrix_slice,cinterval>(A,B);
4625 return spf_mm_leq<srmatrix,cimatrix_slice,cinterval>(A,B);
4630 return spf_mm_leq<scmatrix,cimatrix_slice,cinterval>(A,B);
4635 return spf_mm_leq<simatrix,cimatrix_slice,cinterval>(A,B);
4640 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(A,B);
4645 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(A,B);
4650 return spsp_mm_greater<scimatrix,simatrix,cinterval>(A,B);
4655 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(A,B);
4660 return spsp_mm_greater<simatrix,scimatrix,cinterval>(A,B);
4665 return spf_mm_greater<scimatrix,rmatrix,cinterval>(A,B);
4670 return spf_mm_greater<scimatrix,imatrix,cinterval>(A,B);
4675 return spf_mm_greater<scimatrix,cmatrix,cinterval>(A,B);
4680 return spf_mm_greater<scimatrix,cimatrix,cinterval>(A,B);
4685 return spf_mm_greater<simatrix,cimatrix,cinterval>(A,B);
4690 return fsp_mm_greater<cimatrix,srmatrix,cinterval>(A,B);
4695 return fsp_mm_greater<cimatrix,simatrix,cinterval>(A,B);
4700 return fsp_mm_greater<cimatrix,scmatrix,cinterval>(A,B);
4705 return fsp_mm_greater<cimatrix,scimatrix,cinterval>(A,B);
4710 return fsp_mm_greater<imatrix,scimatrix,cinterval>(A,B);
4715 return fsp_mm_greater<cimatrix_slice,srmatrix,cinterval>(A,B);
4720 return fsp_mm_greater<cimatrix_slice,scmatrix,cinterval>(A,B);
4725 return fsp_mm_greater<cimatrix_slice,simatrix,cinterval>(A,B);
4730 return fsp_mm_greater<cimatrix_slice,scimatrix,cinterval>(A,B);
4735 return fsp_mm_greater<imatrix_slice,scimatrix,cinterval>(A,B);
4740 return spf_mm_greater<scimatrix,rmatrix_slice,cinterval>(A,B);
4745 return spf_mm_greater<scimatrix,imatrix_slice,cinterval>(A,B);
4750 return spf_mm_greater<scimatrix,cmatrix_slice,cinterval>(A,B);
4755 return spf_mm_greater<scimatrix,cimatrix_slice,cinterval>(A,B);
4760 return spf_mm_greater<simatrix,cimatrix_slice,cinterval>(A,B);
4765 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(A,B);
4770 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(A,B);
4775 return spsp_mm_geq<scimatrix,simatrix,cinterval>(A,B);
4780 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(A,B);
4785 return spsp_mm_geq<simatrix,scimatrix,cinterval>(A,B);
4790 return spf_mm_geq<scimatrix,rmatrix,cinterval>(A,B);
4795 return spf_mm_geq<scimatrix,imatrix,cinterval>(A,B);
4800 return spf_mm_geq<scimatrix,cmatrix,cinterval>(A,B);
4805 return spf_mm_geq<scimatrix,cimatrix,cinterval>(A,B);
4810 return spf_mm_geq<simatrix,cimatrix,cinterval>(A,B);
4815 return fsp_mm_geq<cimatrix,srmatrix,cinterval>(A,B);
4820 return fsp_mm_geq<cimatrix,simatrix,cinterval>(A,B);
4825 return fsp_mm_geq<cimatrix,scmatrix,cinterval>(A,B);
4830 return fsp_mm_geq<cimatrix,scimatrix,cinterval>(A,B);
4835 return fsp_mm_geq<imatrix,scimatrix,cinterval>(A,B);
4840 return fsp_mm_geq<cimatrix_slice,srmatrix,cinterval>(A,B);
4845 return fsp_mm_geq<cimatrix_slice,scmatrix,cinterval>(A,B);
4850 return fsp_mm_geq<cimatrix_slice,simatrix,cinterval>(A,B);
4855 return fsp_mm_geq<cimatrix_slice,scimatrix,cinterval>(A,B);
4860 return fsp_mm_geq<imatrix_slice,scimatrix,cinterval>(A,B);
4865 return spf_mm_geq<scimatrix,rmatrix_slice,cinterval>(A,B);
4870 return spf_mm_geq<scimatrix,imatrix_slice,cinterval>(A,B);
4875 return spf_mm_geq<scimatrix,cmatrix_slice,cinterval>(A,B);
4880 return spf_mm_geq<scimatrix,cimatrix_slice,cinterval>(A,B);
4885 return spf_mm_geq<simatrix,cimatrix_slice,cinterval>(A,B);
4899inline std::ostream& operator<<(std::ostream& os,
const scimatrix& A) {
4900 return sp_m_output<scimatrix,cinterval>(os,A);
4909inline std::istream& operator>>(std::istream& is,
scimatrix& A) {
4910 return sp_m_input<scimatrix,cinterval>(is,A);
4933 A.p = std::vector<int>(A.n+1, 0);
4934 A.ind.reserve(A.m + A.n);
4935 A.x.reserve(A.m + A.n);
4937 for(
int i=0 ; i<A.n ; i++) {
4939 for(
int j=Mat.p[sl2l-Mat.lb2+i] ; j<Mat.p[sl2l-Mat.lb2+i+1] ; j++) {
4940 if(Mat.ind[j] >= sl1l-Mat.lb1 && Mat.ind[j] <= sl1u-Mat.lb1) {
4941 A.ind.push_back(Mat.ind[j]-(sl1l-Mat.lb1));
4942 A.x.push_back(Mat.x[j]);
4961 A.p = std::vector<int>(A.n+1, 0);
4962 A.ind.reserve(A.m + A.n);
4963 A.x.reserve(A.m + A.n);
4965 for(
int i=0 ; i<A.n ; i++) {
4967 for(
int j=Mat.p[sl2l-Mat.lb2+i] ; j<Mat.p[sl2l-Mat.lb2+i+1] ; j++) {
4968 if(Mat.ind[j] >= sl1l-Mat.lb1 && Mat.ind[j] <= sl1u-Mat.lb1) {
4969 A.ind.push_back(Mat.ind[j]-(sl1l-Mat.lb1));
4970 A.x.push_back(Mat.x[j]);
4985 return sl_ms_assign<scimatrix_slice, real, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
4990 return sl_ms_assign<scimatrix_slice, interval, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
4995 return sl_ms_assign<scimatrix_slice, complex, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5000 return sl_ms_assign<scimatrix_slice, cinterval, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5005 return slsp_mm_assign<scimatrix_slice, srmatrix, std::vector<cinterval>::iterator>(*
this,C);
5010 return slsp_mm_assign<scimatrix_slice, scmatrix, std::vector<cinterval>::iterator>(*
this,C);
5015 return slsp_mm_assign<scimatrix_slice, simatrix, std::vector<cinterval>::iterator>(*
this,C);
5020 return slsp_mm_assign<scimatrix_slice, scimatrix, std::vector<cinterval>::iterator>(*
this,C);
5025 return slf_mm_assign<scimatrix_slice, rmatrix, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5030 return slf_mm_assign<scimatrix_slice, cmatrix, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5035 return slf_mm_assign<scimatrix_slice, imatrix, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5040 return slf_mm_assign<scimatrix_slice, cimatrix, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5045 return slf_mm_assign<scimatrix_slice, rmatrix_slice, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5050 return slf_mm_assign<scimatrix_slice, cmatrix_slice, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5055 return slf_mm_assign<scimatrix_slice, imatrix_slice, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5060 return slf_mm_assign<scimatrix_slice, cimatrix_slice, std::vector<cinterval>::iterator,
cinterval>(*
this,C);
5525#if(CXSC_INDEX_CHECK)
5526 if(i<A.lb1 || i>A.ub1 || j<A.lb2 || j>A.ub2)
5527 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix_slice::operator()(int, int)"));
5539#if(CXSC_INDEX_CHECK)
5540 if(i<A.lb1 || i>A.ub1 || j<A.lb2 || j>A.ub2)
5541 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix_slice::element(int, int)"));
5583#include "matrix_friend_declarations.inl"
5588 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5592 for(
int j=0 ; j<A.A.n ; j++) {
5593 for(
int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5594 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5601 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5605 for(
int j=0 ; j<A.A.n ; j++) {
5606 for(
int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5607 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5614 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5618 for(
int j=0 ; j<A.A.n ; j++) {
5619 for(
int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5620 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5627 lb1 = A.A.lb1; lb2 = A.A.lb2; ub1 = A.A.ub1; ub2 = A.A.ub2;
5631 for(
int j=0 ; j<A.A.n ; j++) {
5632 for(
int k=A.A.p[j] ; k<A.A.p[j+1] ; k++) {
5633 dat[A.A.ind[k]*A.A.n+j] = A.A.x[k];
5649#if(CXSC_INDEX_CHECK)
5650 if(i<lb1 || j>ub1 || k<lb2 || l>ub2)
5651 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix::operator()(int, int, int, int)"));
5657#if(CXSC_INDEX_CHECK)
5658 if(i<lb1 || j>ub1 || k<lb2 || l>ub2)
5659 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix::operator()(int, int, int, int) const"));
5796 return sp_m_negative<scimatrix,scimatrix>(M.A);
5812 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5823 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5834 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5845 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5856 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5867 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5878 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5889 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5900 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2.A);
5911 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5922 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5933 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5944 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5955 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5966 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5977 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5988 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
5999 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1.A,M2);
6010 return spsp_mm_mult<scimatrix,srmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6021 return spsp_mm_mult<scimatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6032 return spsp_mm_mult<scimatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6043 return spsp_mm_mult<scimatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6054 return spsp_mm_mult<srmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6065 return spsp_mm_mult<scmatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6076 return spsp_mm_mult<simatrix,scimatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6087 return spsp_mm_mult<simatrix,scmatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6098 return spsp_mm_mult<scmatrix,simatrix,scimatrix,sparse_cidot,cinterval>(M1,M2.A);
6109 return spf_mm_mult<scimatrix,rmatrix,cimatrix,sparse_cidot>(M1.A,M2);
6120 return spf_mm_mult<scimatrix,imatrix,cimatrix,sparse_cidot>(M1.A,M2);
6131 return spf_mm_mult<scimatrix,cmatrix,cimatrix,sparse_cidot>(M1.A,M2);
6142 return spf_mm_mult<scimatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6153 return spf_mm_mult<srmatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6164 return spf_mm_mult<simatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6175 return spf_mm_mult<scmatrix,cimatrix,cimatrix,sparse_cidot>(M1.A,M2);
6186 return spf_mm_mult<simatrix,cmatrix,cimatrix,sparse_cidot>(M1.A,M2);
6197 return spf_mm_mult<scmatrix,imatrix,cimatrix,sparse_cidot>(M1.A,M2);
6208 return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6219 return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6230 return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6241 return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6252 return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6263 return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6274 return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6285 return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6296 return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6307 return spf_mm_mult<scimatrix,rmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6318 return spf_mm_mult<scimatrix,cmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6329 return spf_mm_mult<scimatrix,imatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6340 return spf_mm_mult<scimatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6351 return spf_mm_mult<srmatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6362 return spf_mm_mult<simatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6373 return spf_mm_mult<scmatrix,cimatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6384 return spf_mm_mult<simatrix,cmatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6395 return spf_mm_mult<scmatrix,imatrix_slice,cimatrix,sparse_cidot>(M1.A,M2);
6406 return fsp_mm_mult<cimatrix,srmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6417 return fsp_mm_mult<cimatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6428 return fsp_mm_mult<cimatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6439 return fsp_mm_mult<cimatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6450 return fsp_mm_mult<rmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6461 return fsp_mm_mult<imatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6472 return fsp_mm_mult<cmatrix,scimatrix,cimatrix,sparse_cidot>(M1,M2.A);
6483 return fsp_mm_mult<imatrix,scmatrix,cimatrix,sparse_cidot>(M1,M2.A);
6494 return fsp_mm_mult<cmatrix,simatrix,cimatrix,sparse_cidot>(M1,M2.A);
6505 return spsp_mv_mult<scimatrix,srvector,scivector,sparse_cidot,cinterval>(M.A,v);
6516 return spsp_mv_mult<scimatrix,sivector,scivector,sparse_cidot,cinterval>(M.A,v);
6527 return spsp_mv_mult<scimatrix,scvector,scivector,sparse_cidot,cinterval>(M.A,v);
6538 return spsp_mv_mult<scimatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6549 return spsp_mv_mult<srmatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6560 return spsp_mv_mult<simatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6571 return spsp_mv_mult<scmatrix,scivector,scivector,sparse_cidot,cinterval>(M.A,v);
6582 return spsp_mv_mult<simatrix,scvector,scivector,sparse_cidot,cinterval>(M.A,v);
6593 return spsp_mv_mult<scmatrix,sivector,scivector,sparse_cidot,cinterval>(M.A,v);
6604 return spsl_mv_mult<scimatrix,srvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6615 return spsl_mv_mult<scimatrix,sivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6626 return spsl_mv_mult<scimatrix,scvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6637 return spsl_mv_mult<scimatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6648 return spsl_mv_mult<srmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6659 return spsl_mv_mult<scmatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6670 return spsl_mv_mult<simatrix,scivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6681 return spsl_mv_mult<simatrix,scvector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6692 return spsl_mv_mult<scmatrix,sivector_slice,scivector,sparse_cidot,cinterval>(M.A,v);
6703 return spf_mv_mult<scimatrix,rvector,civector,sparse_cidot>(M.A,v);
6714 return spf_mv_mult<scimatrix,ivector,civector,sparse_cidot>(M.A,v);
6725 return spf_mv_mult<scimatrix,cvector,civector,sparse_cidot>(M.A,v);
6736 return spf_mv_mult<scimatrix,civector,civector,sparse_cidot>(M.A,v);
6747 return spf_mv_mult<srmatrix,civector,civector,sparse_cidot>(M.A,v);
6758 return spf_mv_mult<simatrix,civector,civector,sparse_cidot>(M.A,v);
6769 return spf_mv_mult<scmatrix,civector,civector,sparse_cidot>(M.A,v);
6780 return spf_mv_mult<simatrix,cvector,civector,sparse_cidot>(M.A,v);
6791 return spf_mv_mult<scmatrix,ivector,civector,sparse_cidot>(M.A,v);
6802 return spf_mv_mult<scimatrix,rvector_slice,civector,sparse_cidot>(M.A,v);
6813 return spf_mv_mult<scimatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
6824 return spf_mv_mult<scimatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
6835 return spf_mv_mult<scimatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6846 return spf_mv_mult<srmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6857 return spf_mv_mult<scmatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6868 return spf_mv_mult<simatrix,civector_slice,civector,sparse_cidot>(M.A,v);
6879 return spf_mv_mult<simatrix,cvector_slice,civector,sparse_cidot>(M.A,v);
6890 return spf_mv_mult<scmatrix,ivector_slice,civector,sparse_cidot>(M.A,v);
6895 return sp_ms_div<scimatrix,real,scimatrix>(M.A,r);
6900 return sp_ms_div<scimatrix,complex,scimatrix>(M.A,r);
6905 return sp_ms_div<scimatrix,interval,scimatrix>(M.A,r);
6910 return sp_ms_div<scimatrix,cinterval,scimatrix>(M.A,r);
6915 return sp_ms_div<srmatrix,cinterval,scimatrix>(M.A,r);
6920 return sp_ms_div<simatrix,cinterval,scimatrix>(M.A,r);
6925 return sp_ms_div<scmatrix,cinterval,scimatrix>(M.A,r);
6930 return sp_ms_div<simatrix,complex,scimatrix>(M.A,r);
6935 return sp_ms_div<scmatrix,interval,scimatrix>(M.A,r);
6940 return sp_ms_mult<scimatrix,real,scimatrix>(M.A,r);
6945 return sp_ms_mult<scimatrix,complex,scimatrix>(M.A,r);
6950 return sp_ms_mult<scimatrix,interval,scimatrix>(M.A,r);
6955 return sp_ms_mult<scimatrix,cinterval,scimatrix>(M.A,r);
6960 return sp_ms_mult<srmatrix,cinterval,scimatrix>(M.A,r);
6965 return sp_ms_mult<simatrix,cinterval,scimatrix>(M.A,r);
6970 return sp_ms_mult<scmatrix,cinterval,scimatrix>(M.A,r);
6975 return sp_ms_mult<simatrix,complex,scimatrix>(M.A,r);
6980 return sp_ms_mult<scmatrix,interval,scimatrix>(M.A,r);
6985 return sp_sm_mult<real,scimatrix,scimatrix>(r,M.A);
6990 return sp_sm_mult<complex,scimatrix,scimatrix>(r,M.A);
6995 return sp_sm_mult<interval,scimatrix,scimatrix>(r,M.A);
7000 return sp_sm_mult<cinterval,scimatrix,scimatrix>(r,M.A);
7005 return sp_sm_mult<cinterval,srmatrix,scimatrix>(r,M.A);
7010 return sp_sm_mult<cinterval,simatrix,scimatrix>(r,M.A);
7015 return sp_sm_mult<cinterval,scmatrix,scimatrix>(r,M.A);
7020 return sp_sm_mult<complex,simatrix,scimatrix>(r,M.A);
7025 return sp_sm_mult<interval,scmatrix,scimatrix>(r,M.A);
7030 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7035 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7040 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7045 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7050 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7055 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7060 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7065 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7070 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7075 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7080 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7085 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7090 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7095 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7100 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7105 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7110 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7115 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7120 return spsp_mm_add<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7125 return spsp_mm_add<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7130 return spsp_mm_add<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7135 return spsp_mm_add<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7140 return spsp_mm_add<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7145 return spsp_mm_add<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7150 return spsp_mm_add<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7155 return spsp_mm_add<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7160 return spsp_mm_add<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7165 return spf_mm_add<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7170 return spf_mm_add<scimatrix,imatrix,cimatrix>(M1.A,M2);
7175 return spf_mm_add<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7180 return spf_mm_add<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7185 return spf_mm_add<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7190 return spf_mm_add<simatrix,cimatrix,cimatrix>(M1.A,M2);
7195 return spf_mm_add<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7200 return spf_mm_add<simatrix,cmatrix,cimatrix>(M1.A,M2);
7205 return spf_mm_add<scmatrix,imatrix,cimatrix>(M1.A,M2);
7210 return fsp_mm_add<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7215 return fsp_mm_add<cimatrix,simatrix,cimatrix>(M1,M2.A);
7220 return fsp_mm_add<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7225 return fsp_mm_add<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7230 return fsp_mm_add<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7235 return fsp_mm_add<imatrix,scimatrix,cimatrix>(M1,M2.A);
7240 return fsp_mm_add<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7245 return fsp_mm_add<imatrix,scmatrix,cimatrix>(M1,M2.A);
7250 return fsp_mm_add<cmatrix,simatrix,cimatrix>(M1,M2.A);
7255 return spf_mm_add<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7260 return spf_mm_add<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7265 return spf_mm_add<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7270 return spf_mm_add<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7275 return spf_mm_add<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7280 return spf_mm_add<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7285 return spf_mm_add<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7290 return spf_mm_add<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7295 return spf_mm_add<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7300 return fsp_mm_add<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7305 return fsp_mm_add<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7310 return fsp_mm_add<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7315 return fsp_mm_add<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7320 return fsp_mm_add<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7325 return fsp_mm_add<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7330 return fsp_mm_add<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7335 return fsp_mm_add<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7340 return fsp_mm_add<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7345 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7350 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7355 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7360 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7365 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7370 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7375 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7380 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7385 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7390 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7395 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7400 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7405 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7410 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7415 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7420 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7425 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7430 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7435 return spsp_mm_sub<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7440 return spsp_mm_sub<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7445 return spsp_mm_sub<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7450 return spsp_mm_sub<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7455 return spsp_mm_sub<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7460 return spsp_mm_sub<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7465 return spsp_mm_sub<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7470 return spsp_mm_sub<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7475 return spsp_mm_sub<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7480 return spf_mm_sub<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7485 return spf_mm_sub<scimatrix,imatrix,cimatrix>(M1.A,M2);
7490 return spf_mm_sub<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7495 return spf_mm_sub<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7500 return spf_mm_sub<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7505 return spf_mm_sub<simatrix,cimatrix,cimatrix>(M1.A,M2);
7510 return spf_mm_sub<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7515 return spf_mm_sub<simatrix,cmatrix,cimatrix>(M1.A,M2);
7520 return spf_mm_sub<scmatrix,imatrix,cimatrix>(M1.A,M2);
7525 return fsp_mm_sub<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7530 return fsp_mm_sub<cimatrix,simatrix,cimatrix>(M1,M2.A);
7535 return fsp_mm_sub<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7540 return fsp_mm_sub<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7545 return fsp_mm_sub<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7550 return fsp_mm_sub<imatrix,scimatrix,cimatrix>(M1,M2.A);
7555 return fsp_mm_sub<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7560 return fsp_mm_sub<imatrix,scmatrix,cimatrix>(M1,M2.A);
7565 return fsp_mm_sub<cmatrix,simatrix,cimatrix>(M1,M2.A);
7570 return spf_mm_sub<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7575 return spf_mm_sub<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7580 return spf_mm_sub<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7585 return spf_mm_sub<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7590 return spf_mm_sub<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7595 return spf_mm_sub<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7600 return spf_mm_sub<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7605 return spf_mm_sub<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7610 return spf_mm_sub<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7615 return fsp_mm_sub<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7620 return fsp_mm_sub<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7625 return fsp_mm_sub<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7630 return fsp_mm_sub<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7635 return fsp_mm_sub<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7640 return fsp_mm_sub<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7645 return fsp_mm_sub<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7650 return fsp_mm_sub<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7655 return fsp_mm_sub<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7660 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7665 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7670 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7675 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7680 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7685 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7690 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
7695 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
7700 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7705 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7710 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7715 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7720 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7725 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7730 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7735 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
7740 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
7745 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
7750 return spsp_mm_hull<scimatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
7755 return spsp_mm_hull<scimatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7760 return spsp_mm_hull<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7765 return spsp_mm_hull<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7770 return spsp_mm_hull<srmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7775 return spsp_mm_hull<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7780 return spsp_mm_hull<scmatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
7785 return spsp_mm_hull<simatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
7790 return spsp_mm_hull<scmatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
7795 return spf_mm_hull<scimatrix,rmatrix,cimatrix>(M1.A,M2);
7800 return spf_mm_hull<scimatrix,imatrix,cimatrix>(M1.A,M2);
7805 return spf_mm_hull<scimatrix,cmatrix,cimatrix>(M1.A,M2);
7810 return spf_mm_hull<scimatrix,cimatrix,cimatrix>(M1.A,M2);
7815 return spf_mm_hull<srmatrix,cimatrix,cimatrix>(M1.A,M2);
7820 return spf_mm_hull<simatrix,cimatrix,cimatrix>(M1.A,M2);
7825 return spf_mm_hull<scmatrix,cimatrix,cimatrix>(M1.A,M2);
7830 return spf_mm_hull<simatrix,cmatrix,cimatrix>(M1.A,M2);
7835 return spf_mm_hull<scmatrix,imatrix,cimatrix>(M1.A,M2);
7840 return fsp_mm_hull<cimatrix,srmatrix,cimatrix>(M1,M2.A);
7845 return fsp_mm_hull<cimatrix,simatrix,cimatrix>(M1,M2.A);
7850 return fsp_mm_hull<cimatrix,scmatrix,cimatrix>(M1,M2.A);
7855 return fsp_mm_hull<cimatrix,scimatrix,cimatrix>(M1,M2.A);
7860 return fsp_mm_hull<rmatrix,scimatrix,cimatrix>(M1,M2.A);
7865 return fsp_mm_hull<imatrix,scimatrix,cimatrix>(M1,M2.A);
7870 return fsp_mm_hull<cmatrix,scimatrix,cimatrix>(M1,M2.A);
7875 return fsp_mm_hull<imatrix,scmatrix,cimatrix>(M1,M2.A);
7880 return fsp_mm_hull<cmatrix,simatrix,cimatrix>(M1,M2.A);
7885 return spf_mm_hull<scimatrix,rmatrix_slice,cimatrix>(M1.A,M2);
7890 return spf_mm_hull<scimatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7895 return spf_mm_hull<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
7900 return spf_mm_hull<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7905 return spf_mm_hull<srmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7910 return spf_mm_hull<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7915 return spf_mm_hull<scmatrix,cimatrix_slice,cimatrix>(M1.A,M2);
7920 return spf_mm_hull<simatrix,cmatrix_slice,cimatrix>(M1.A,M2);
7925 return spf_mm_hull<scmatrix,imatrix_slice,cimatrix>(M1.A,M2);
7930 return fsp_mm_hull<cimatrix_slice,srmatrix,cimatrix>(M1,M2.A);
7935 return fsp_mm_hull<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
7940 return fsp_mm_hull<cimatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7945 return fsp_mm_hull<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7950 return fsp_mm_hull<rmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7955 return fsp_mm_hull<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7960 return fsp_mm_hull<cmatrix_slice,scimatrix,cimatrix>(M1,M2.A);
7965 return fsp_mm_hull<imatrix_slice,scmatrix,cimatrix>(M1,M2.A);
7970 return fsp_mm_hull<cmatrix_slice,simatrix,cimatrix>(M1,M2.A);
7975 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1.A,M2.A);
7980 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7985 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2.A);
7990 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1.A,M2);
7995 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
8000 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1.A,M2);
8005 return spsp_mm_hull<scmatrix,srmatrix,scimatrix,cinterval>(M1,M2.A);
8010 return spsp_mm_hull<srmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
8015 return spsp_mm_hull<scmatrix,scmatrix,scimatrix,cinterval>(M1,M2.A);
8020 return spf_mm_hull<scmatrix,rmatrix,cimatrix>(M1.A,M2);
8025 return spf_mm_hull<srmatrix,cmatrix,cimatrix>(M1.A,M2);
8030 return spf_mm_hull<scmatrix,cmatrix,cimatrix>(M1.A,M2);
8035 return fsp_mm_hull<cmatrix,srmatrix,cimatrix>(M1,M2.A);
8040 return fsp_mm_hull<rmatrix,scmatrix,cimatrix>(M1,M2.A);
8045 return fsp_mm_hull<cmatrix,scmatrix,cimatrix>(M1,M2.A);
8050 return spf_mm_hull<scmatrix,rmatrix_slice,cimatrix>(M1.A,M2);
8055 return spf_mm_hull<srmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
8060 return spf_mm_hull<scmatrix,cmatrix_slice,cimatrix>(M1.A,M2);
8065 return fsp_mm_hull<cmatrix_slice,srmatrix,cimatrix>(M1,M2.A);
8070 return fsp_mm_hull<rmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
8075 return fsp_mm_hull<cmatrix_slice,scmatrix,cimatrix>(M1,M2.A);
8080 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2.A);
8085 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
8090 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2.A);
8095 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1.A,M2);
8100 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
8105 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1.A,M2);
8110 return spsp_mm_intersect<scimatrix,simatrix,scimatrix,cinterval>(M1,M2.A);
8115 return spsp_mm_intersect<scimatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
8120 return spsp_mm_intersect<simatrix,scimatrix,scimatrix,cinterval>(M1,M2.A);
8125 return spf_mm_intersect<scimatrix,imatrix,cimatrix>(M1.A,M2);
8130 return spf_mm_intersect<scimatrix,cimatrix,cimatrix>(M1.A,M2);
8135 return spf_mm_intersect<simatrix,cimatrix,cimatrix>(M1.A,M2);
8140 return fsp_mm_intersect<cimatrix,simatrix,cimatrix>(M1,M2.A);
8145 return fsp_mm_intersect<cimatrix,scimatrix,cimatrix>(M1,M2.A);
8150 return fsp_mm_intersect<imatrix,scimatrix,cimatrix>(M1,M2.A);
8155 return spf_mm_intersect<scimatrix,imatrix_slice,cimatrix>(M1.A,M2);
8160 return spf_mm_intersect<scimatrix,cimatrix_slice,cimatrix>(M1.A,M2);
8165 return spf_mm_intersect<simatrix,cimatrix_slice,cimatrix>(M1.A,M2);
8170 return fsp_mm_intersect<cimatrix_slice,simatrix,cimatrix>(M1,M2.A);
8175 return fsp_mm_intersect<cimatrix_slice,scimatrix,cimatrix>(M1,M2.A);
8180 return fsp_mm_intersect<imatrix_slice,scimatrix,cimatrix>(M1,M2.A);
8405 return spsp_mm_comp(M1.A,M2.A);
8410 return spsp_mm_comp(M1.A,M2.A);
8415 return spsp_mm_comp(M1.A,M2.A);
8420 return spsp_mm_comp(M1.A,M2.A);
8425 return spsp_mm_comp(M1.A,M2.A);
8430 return spsp_mm_comp(M1.A,M2.A);
8435 return spsp_mm_comp(M1.A,M2.A);
8440 return spsp_mm_comp(M1.A,M2);
8445 return spsp_mm_comp(M1.A,M2);
8450 return spsp_mm_comp(M1.A,M2);
8455 return spsp_mm_comp(M1.A,M2);
8460 return spsp_mm_comp(M1.A,M2);
8465 return spsp_mm_comp(M1.A,M2);
8470 return spsp_mm_comp(M1.A,M2);
8475 return spsp_mm_comp(M1,M2.A);
8480 return spsp_mm_comp(M1,M2.A);
8485 return spsp_mm_comp(M1,M2.A);
8490 return spsp_mm_comp(M1,M2.A);
8495 return spsp_mm_comp(M1,M2.A);
8500 return spsp_mm_comp(M1,M2.A);
8505 return spsp_mm_comp(M1,M2.A);
8510 return spf_mm_comp(M1.A,M2);
8515 return spf_mm_comp(M1.A,M2);
8520 return spf_mm_comp(M1.A,M2);
8525 return spf_mm_comp(M1.A,M2);
8530 return spf_mm_comp(M1.A,M2);
8535 return spf_mm_comp(M1.A,M2);
8540 return spf_mm_comp(M1.A,M2);
8545 return fsp_mm_comp(M1,M2.A);
8550 return fsp_mm_comp(M1,M2.A);
8555 return fsp_mm_comp(M1,M2.A);
8560 return fsp_mm_comp(M1,M2.A);
8565 return fsp_mm_comp(M1,M2.A);
8570 return fsp_mm_comp(M1,M2.A);
8575 return fsp_mm_comp(M1,M2.A);
8580 return fsp_mm_comp(M1,M2.A);
8585 return fsp_mm_comp(M1,M2.A);
8590 return fsp_mm_comp(M1,M2.A);
8595 return fsp_mm_comp(M1,M2.A);
8600 return fsp_mm_comp(M1,M2.A);
8605 return fsp_mm_comp(M1,M2.A);
8610 return fsp_mm_comp(M1,M2.A);
8615 return spf_mm_comp(M1.A,M2);
8620 return spf_mm_comp(M1.A,M2);
8625 return spf_mm_comp(M1.A,M2);
8630 return spf_mm_comp(M1.A,M2);
8635 return spf_mm_comp(M1.A,M2);
8640 return spf_mm_comp(M1.A,M2);
8645 return spf_mm_comp(M1.A,M2);
8650 return !spsp_mm_comp(M1.A,M2.A);
8655 return !spsp_mm_comp(M1.A,M2.A);
8660 return !spsp_mm_comp(M1.A,M2.A);
8665 return !spsp_mm_comp(M1.A,M2.A);
8670 return !spsp_mm_comp(M1.A,M2.A);
8675 return !spsp_mm_comp(M1.A,M2.A);
8680 return !spsp_mm_comp(M1.A,M2.A);
8685 return !spsp_mm_comp(M1.A,M2);
8690 return !spsp_mm_comp(M1.A,M2);
8695 return !spsp_mm_comp(M1.A,M2);
8700 return !spsp_mm_comp(M1.A,M2);
8705 return !spsp_mm_comp(M1.A,M2);
8710 return !spsp_mm_comp(M1.A,M2);
8715 return !spsp_mm_comp(M1.A,M2);
8720 return !spsp_mm_comp(M1,M2.A);
8725 return !spsp_mm_comp(M1,M2.A);
8730 return !spsp_mm_comp(M1,M2.A);
8735 return !spsp_mm_comp(M1,M2.A);
8740 return !spsp_mm_comp(M1,M2.A);
8745 return !spsp_mm_comp(M1,M2.A);
8750 return !spsp_mm_comp(M1,M2.A);
8755 return !spf_mm_comp(M1.A,M2);
8760 return !spf_mm_comp(M1.A,M2);
8765 return !spf_mm_comp(M1.A,M2);
8770 return !spf_mm_comp(M1.A,M2);
8775 return !spf_mm_comp(M1.A,M2);
8780 return !spf_mm_comp(M1.A,M2);
8785 return !spf_mm_comp(M1.A,M2);
8790 return !fsp_mm_comp(M1,M2.A);
8795 return !fsp_mm_comp(M1,M2.A);
8800 return !fsp_mm_comp(M1,M2.A);
8805 return !fsp_mm_comp(M1,M2.A);
8810 return !fsp_mm_comp(M1,M2.A);
8815 return !fsp_mm_comp(M1,M2.A);
8820 return !fsp_mm_comp(M1,M2.A);
8825 return !fsp_mm_comp(M1,M2.A);
8830 return !fsp_mm_comp(M1,M2.A);
8835 return !fsp_mm_comp(M1,M2.A);
8840 return !fsp_mm_comp(M1,M2.A);
8845 return !fsp_mm_comp(M1,M2.A);
8850 return !fsp_mm_comp(M1,M2.A);
8855 return !fsp_mm_comp(M1,M2.A);
8860 return !spf_mm_comp(M1.A,M2);
8865 return !spf_mm_comp(M1.A,M2);
8870 return !spf_mm_comp(M1.A,M2);
8875 return !spf_mm_comp(M1.A,M2);
8880 return !spf_mm_comp(M1.A,M2);
8885 return !spf_mm_comp(M1.A,M2);
8890 return !spf_mm_comp(M1.A,M2);
8895 return spsp_mm_less<scimatrix,simatrix,cinterval>(M1.A,M2.A);
8900 return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
8905 return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1.A,M2.A);
8910 return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1.A,M2.A);
8915 return spsp_mm_less<simatrix,scimatrix,cinterval>(M1.A,M2.A);
8920 return spsp_mm_less<scimatrix,simatrix,cinterval>(M1.A,M2);
8925 return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1.A,M2);
8930 return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1.A,M2);
8935 return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1.A,M2);
8940 return spsp_mm_less<simatrix,scimatrix,cinterval>(M1.A,M2);
8945 return spsp_mm_less<scimatrix,simatrix,cinterval>(M1,M2.A);
8950 return spsp_mm_less<scimatrix,scimatrix,cinterval>(M1,M2.A);
8955 return spsp_mm_less<srmatrix,scimatrix,cinterval>(M1,M2.A);
8960 return spsp_mm_less<scmatrix,scimatrix,cinterval>(M1,M2.A);
8965 return spsp_mm_less<simatrix,scimatrix,cinterval>(M1,M2.A);
8970 return spf_mm_less<scimatrix,imatrix,cinterval>(M1.A,M2);
8975 return spf_mm_less<scimatrix,cimatrix,cinterval>(M1.A,M2);
8980 return spf_mm_less<srmatrix,cimatrix,cinterval>(M1.A,M2);
8985 return spf_mm_less<scmatrix,cimatrix,cinterval>(M1.A,M2);
8990 return spf_mm_less<simatrix,cimatrix,cinterval>(M1.A,M2);
8995 return fsp_mm_less<cimatrix,simatrix,cinterval>(M1,M2.A);
9000 return fsp_mm_less<cimatrix,scimatrix,cinterval>(M1,M2.A);
9005 return fsp_mm_less<rmatrix,scimatrix,cinterval>(M1,M2.A);
9010 return fsp_mm_less<imatrix,scimatrix,cinterval>(M1,M2.A);
9015 return fsp_mm_less<cmatrix,scimatrix,cinterval>(M1,M2.A);
9020 return fsp_mm_less<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9025 return fsp_mm_less<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9030 return fsp_mm_less<rmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9035 return fsp_mm_less<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9040 return fsp_mm_less<cmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9045 return spf_mm_less<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9050 return spf_mm_less<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9055 return spf_mm_less<srmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9060 return spf_mm_less<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9065 return spf_mm_less<scmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9070 return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9075 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9080 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1.A,M2.A);
9085 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1.A,M2.A);
9090 return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9095 return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1.A,M2);
9100 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1.A,M2);
9105 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1.A,M2);
9110 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1.A,M2);
9115 return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1.A,M2);
9120 return spsp_mm_leq<scimatrix,simatrix,cinterval>(M1,M2.A);
9125 return spsp_mm_leq<scimatrix,scimatrix,cinterval>(M1,M2.A);
9130 return spsp_mm_leq<srmatrix,scimatrix,cinterval>(M1,M2.A);
9135 return spsp_mm_leq<scmatrix,scimatrix,cinterval>(M1,M2.A);
9140 return spsp_mm_leq<simatrix,scimatrix,cinterval>(M1,M2.A);
9145 return spf_mm_leq<scimatrix,imatrix,cinterval>(M1.A,M2);
9150 return spf_mm_leq<scimatrix,cimatrix,cinterval>(M1.A,M2);
9155 return spf_mm_leq<srmatrix,cimatrix,cinterval>(M1.A,M2);
9160 return spf_mm_leq<scmatrix,cimatrix,cinterval>(M1.A,M2);
9165 return spf_mm_leq<simatrix,cimatrix,cinterval>(M1.A,M2);
9170 return fsp_mm_leq<cimatrix,simatrix,cinterval>(M1,M2.A);
9175 return fsp_mm_leq<cimatrix,scimatrix,cinterval>(M1,M2.A);
9180 return fsp_mm_leq<rmatrix,scimatrix,cinterval>(M1,M2.A);
9185 return fsp_mm_leq<imatrix,scimatrix,cinterval>(M1,M2.A);
9190 return fsp_mm_leq<cmatrix,scimatrix,cinterval>(M1,M2.A);
9195 return fsp_mm_leq<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9200 return fsp_mm_leq<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9205 return fsp_mm_leq<rmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9210 return fsp_mm_leq<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9215 return fsp_mm_leq<cmatrix_slice,scimatrix,cinterval>(M1,M2.A);
9220 return spf_mm_leq<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9225 return spf_mm_leq<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9230 return spf_mm_leq<srmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9235 return spf_mm_leq<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9240 return spf_mm_leq<scmatrix,cimatrix_slice,cinterval>(M1.A,M2);
9245 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1.A,M2.A);
9250 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1.A,M2.A);
9255 return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9260 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9265 return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9270 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1.A,M2);
9275 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1.A,M2);
9280 return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1.A,M2);
9285 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1.A,M2);
9290 return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1.A,M2);
9295 return spsp_mm_greater<scimatrix,srmatrix,cinterval>(M1,M2.A);
9300 return spsp_mm_greater<scimatrix,scmatrix,cinterval>(M1,M2.A);
9305 return spsp_mm_greater<scimatrix,simatrix,cinterval>(M1,M2.A);
9310 return spsp_mm_greater<scimatrix,scimatrix,cinterval>(M1,M2.A);
9315 return spsp_mm_greater<simatrix,scimatrix,cinterval>(M1,M2.A);
9320 return spf_mm_greater<scimatrix,rmatrix,cinterval>(M1.A,M2);
9325 return spf_mm_greater<scimatrix,cmatrix,cinterval>(M1.A,M2);
9330 return spf_mm_greater<scimatrix,imatrix,cinterval>(M1.A,M2);
9335 return spf_mm_greater<scimatrix,cimatrix,cinterval>(M1.A,M2);
9340 return spf_mm_greater<simatrix,cimatrix,cinterval>(M1.A,M2);
9345 return fsp_mm_greater<cimatrix,srmatrix,cinterval>(M1,M2.A);
9350 return fsp_mm_greater<cimatrix,simatrix,cinterval>(M1,M2.A);
9355 return fsp_mm_greater<cimatrix,scmatrix,cinterval>(M1,M2.A);
9360 return fsp_mm_greater<cimatrix,scimatrix,cinterval>(M1,M2.A);
9365 return fsp_mm_greater<imatrix,scimatrix,cinterval>(M1,M2.A);
9370 return fsp_mm_greater<cimatrix_slice,srmatrix,cinterval>(M1,M2.A);
9375 return fsp_mm_greater<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9380 return fsp_mm_greater<cimatrix_slice,scmatrix,cinterval>(M1,M2.A);
9385 return fsp_mm_greater<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9390 return fsp_mm_greater<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9395 return spf_mm_greater<scimatrix,rmatrix_slice,cinterval>(M1.A,M2);
9400 return spf_mm_greater<scimatrix,cmatrix_slice,cinterval>(M1.A,M2);
9405 return spf_mm_greater<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9410 return spf_mm_greater<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9415 return spf_mm_greater<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9420 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1.A,M2.A);
9425 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1.A,M2.A);
9430 return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1.A,M2.A);
9435 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1.A,M2.A);
9440 return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1.A,M2.A);
9445 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1.A,M2);
9450 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1.A,M2);
9455 return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1.A,M2);
9460 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1.A,M2);
9465 return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1.A,M2);
9470 return spsp_mm_geq<scimatrix,srmatrix,cinterval>(M1,M2.A);
9475 return spsp_mm_geq<scimatrix,scmatrix,cinterval>(M1,M2.A);
9480 return spsp_mm_geq<scimatrix,simatrix,cinterval>(M1,M2.A);
9485 return spsp_mm_geq<scimatrix,scimatrix,cinterval>(M1,M2.A);
9490 return spsp_mm_geq<simatrix,scimatrix,cinterval>(M1,M2.A);
9495 return spf_mm_geq<scimatrix,rmatrix,cinterval>(M1.A,M2);
9500 return spf_mm_geq<scimatrix,cmatrix,cinterval>(M1.A,M2);
9505 return spf_mm_geq<scimatrix,imatrix,cinterval>(M1.A,M2);
9510 return spf_mm_geq<scimatrix,cimatrix,cinterval>(M1.A,M2);
9515 return spf_mm_geq<simatrix,cimatrix,cinterval>(M1.A,M2);
9520 return fsp_mm_geq<cimatrix,srmatrix,cinterval>(M1,M2.A);
9525 return fsp_mm_geq<cimatrix,simatrix,cinterval>(M1,M2.A);
9530 return fsp_mm_geq<cimatrix,scmatrix,cinterval>(M1,M2.A);
9535 return fsp_mm_geq<cimatrix,scimatrix,cinterval>(M1,M2.A);
9540 return fsp_mm_geq<imatrix,scimatrix,cinterval>(M1,M2.A);
9545 return fsp_mm_geq<cimatrix_slice,srmatrix,cinterval>(M1,M2.A);
9550 return fsp_mm_geq<cimatrix_slice,simatrix,cinterval>(M1,M2.A);
9555 return fsp_mm_geq<cimatrix_slice,scmatrix,cinterval>(M1,M2.A);
9560 return fsp_mm_geq<cimatrix_slice,scimatrix,cinterval>(M1,M2.A);
9565 return fsp_mm_geq<imatrix_slice,scimatrix,cinterval>(M1,M2.A);
9570 return spf_mm_geq<scimatrix,rmatrix_slice,cinterval>(M1.A,M2);
9575 return spf_mm_geq<scimatrix,cmatrix_slice,cinterval>(M1.A,M2);
9580 return spf_mm_geq<scimatrix,imatrix_slice,cinterval>(M1.A,M2);
9585 return spf_mm_geq<scimatrix,cimatrix_slice,cinterval>(M1.A,M2);
9590 return spf_mm_geq<simatrix,cimatrix_slice,cinterval>(M1.A,M2);
9595 return sp_m_not(M.A);
9605 return sp_m_output<scimatrix,cinterval>(os, M.A);
9634 scimatrix_subv(
scimatrix& A,
bool r,
int i,
int j,
int k,
int l) : dat(A,i,j,k,l), row(r) {
9635 if(row) index=i;
else index=k;
9638 scimatrix_subv(
const scimatrix& A,
bool r,
int i,
int j,
int k,
int l) : dat(A,i,j,k,l), row(r) {
9639 if(row) index=i;
else index=k;
9650#if(CXSC_INDEX_CHECK)
9651 if(i<dat.A.lb2 || i>dat.A.ub2)
9652 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix_subv::operator[](int)"));
9656#if(CXSC_INDEX_CHECK)
9657 if(i<dat.A.lb1 || i>dat.A.ub1)
9658 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix_subv::operator[](int)"));
9670#if(CXSC_INDEX_CHECK)
9671 if(i<dat.A.lb2 || i>dat.A.ub2)
9672 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix_subv::operator[](int)"));
9674 return dat(index,i);
9676#if(CXSC_INDEX_CHECK)
9677 if(i<dat.A.lb1 || i>dat.A.ub1)
9678 cxscthrow(ELEMENT_NOT_IN_VEC(
"scimatrix_subv::operator[](int)"));
9680 return dat(i,index);
9686 return sv_vs_assign(*
this,v);
9691 return sv_vs_assign(*
this,v);
9696 return sv_vs_assign(*
this,v);
9701 return sv_vs_assign(*
this,v);
9706 return svsp_vv_assign(*
this,v);
9711 return svsp_vv_assign(*
this,v);
9716 return svsp_vv_assign(*
this,v);
9721 return svsp_vv_assign(*
this,v);
9726 return svsl_vv_assign(*
this,v);
9731 return svsl_vv_assign(*
this,v);
9736 return svsl_vv_assign(*
this,v);
9741 return svsl_vv_assign(*
this,v);
9746 return svf_vv_assign(*
this,v);
9751 return svf_vv_assign(*
this,v);
9756 return svf_vv_assign(*
this,v);
9761 return svf_vv_assign(*
this,v);
9766 return svf_vv_assign(*
this,v);
9771 return svf_vv_assign(*
this,v);
9776 return svf_vv_assign(*
this,v);
9781 return svf_vv_assign(*
this,v);
9786 return svsp_vv_assign(*
this,
srvector(v));
9791 return svsp_vv_assign(*
this,
sivector(v));
9796 return svsp_vv_assign(*
this,
scvector(v));
9801 return svsp_vv_assign(*
this,
scivector(v));
9946#include "vector_friend_declarations.inl"
9952 return Lb(S.dat, 2);
9954 return Lb(S.dat, 1);
9960 return Ub(S.dat, 2);
9962 return Ub(S.dat, 1);
9967 return Ub(S)-
Lb(S)+1;
10039 if(v.row) n=v.dat.A.n;
else n=v.dat.A.m;
10047#if(CXSC_INDEX_CHECK)
10048 if(c.col()<lb2 || c.col()>ub2)
10049 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix::operator[](const cxscmatrix_column&)"));
10051 return scimatrix_subv(*
this,
false, lb1, ub1, c.col(), c.col());
10055#if(CXSC_INDEX_CHECK)
10057 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix::operator[](const int)"));
10063#if(CXSC_INDEX_CHECK)
10064 if(c.col()<lb2 || c.col()>ub2)
10065 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix::operator[](const cxscmatrix_column&)"));
10067 return scimatrix_subv(*
this,
false, lb1, ub1, c.col(), c.col());
10071#if(CXSC_INDEX_CHECK)
10073 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix::operator[](const int)"));
10079#if(CXSC_INDEX_CHECK)
10080 if(i<A.lb1 || i>A.ub1)
10081 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix_slice::operator[](const int)"));
10087#if(CXSC_INDEX_CHECK)
10088 if(c.col()<A.lb2 || c.col()>A.ub2)
10089 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix_slice::operator[](const cxscmatrix_column&)"));
10091 return scimatrix_subv(*M,
false, A.lb1, A.ub1, c.col(), c.col());
10095#if(CXSC_INDEX_CHECK)
10096 if(i<A.lb1 || i>A.ub1)
10097 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix_slice::operator[](const int)"));
10103#if(CXSC_INDEX_CHECK)
10104 if(c.col()<A.lb2 || c.col()>A.ub2)
10105 cxscthrow(ROW_OR_COL_NOT_IN_MAT(
"scimatrix_slice::operator[](const cxscmatrix_column&)"));
10107 return scimatrix_subv(*M,
false, A.lb1, A.ub1, c.col(), c.col());
10120 for(
int j=0 ; j<n ; j++) {
10121 for(
int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10123 x.push_back(A.dat.A.x[k]);
10132 for(
unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10133 p.push_back(A.dat.A.ind[k]);
10134 x.push_back(A.dat.A.x[k]);
10149 for(
int j=0 ; j<n ; j++) {
10150 for(
int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10161 for(
unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10162 p.push_back(A.dat.A.ind[k]);
10178 for(
int j=0 ; j<n ; j++) {
10179 for(
int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10190 for(
unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10191 p.push_back(A.dat.A.ind[k]);
10207 for(
int j=0 ; j<n ; j++) {
10208 for(
int k=A.dat.A.p[j] ; k<A.dat.A.p[j+1] ; k++) {
10219 for(
unsigned int k=0 ; k<A.dat.A.ind.size() ; k++) {
10220 p.push_back(A.dat.A.ind[k]);
14271 return sv_v_not(x);
14911#include "sparsematrix.inl"
The Data Type cidotprecision.
The Data Type cimatrix_slice.
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix_slice & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
cimatrix_slice & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
cimatrix_slice & operator=(const cimatrix &m) noexcept
Implementation of standard assigning operator.
cimatrix_slice & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
The Data Type cimatrix_subv.
cimatrix_subv & operator&=(const scivector &rv)
Implementation of intersection and allocation operation.
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
cimatrix_subv & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
cimatrix_subv & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
cimatrix & operator*=(const scimatrix &m1)
Implementation of multiplication and allocation operation.
cimatrix & operator=(const cinterval &r) noexcept
Implementation of standard assigning operator.
cimatrix() noexcept
Constructor of class cimatrix.
cimatrix & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix & operator+=(const scimatrix &m1)
Implementation of addition and allocation operation.
cimatrix & operator-=(const scimatrix &m1)
Implementation of substraction and allocation operation.
The Scalar Type cinterval.
The Data Type civector_slice.
The Data Type cmatrix_slice.
The Data Type cvector_slice.
The Data Type imatrix_slice.
The Scalar Type interval.
The Data Type ivector_slice.
The Data Type rmatrix_slice.
The Data Type rvector_slice.
A slice of a sparse complex interval matrix.
scimatrix_slice & operator=(const srmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator=(const srmatrix &C)
Assing C to the slice.
friend srmatrix SupRe(const scimatrix_slice &)
Returns the real part of the supremum of the slice S.
scimatrix_slice & operator=(const cimatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator-=(const scmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const rmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const cmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const simatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const simatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const simatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
friend srmatrix InfRe(const scimatrix_slice &)
Returns the real part of the infimum of the slice S.
scimatrix_slice & operator+=(const rmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const rmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const scimatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cimatrix &C)
Assing C to the slice.
scimatrix_slice & operator-=(const scimatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const scmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
cinterval & element(const int i, const int j)
Returns a reference to the element (i,j) of the matrix.
scimatrix_slice & operator+=(const imatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
friend int Ub(const scimatrix_slice &, const int)
Returns the upper index bound of the rows (if i==ROW) or columns (if i==COL) of the slice.
scimatrix_slice & operator=(const scmatrix &C)
Assing C to the slice.
scimatrix_slice & operator|=(const cimatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const scimatrix &C)
Assing C to the slice.
scimatrix_slice & operator+=(const scimatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
friend scmatrix Inf(const scimatrix_slice &)
Returns the infimum of the slice S.
scimatrix_slice & operator*=(const imatrix &M)
Assigns the product of the sparse slice and M to the slice.
const cinterval operator()(const int i, const int j) const
Returns a copy of the element (i,j) of the matrix.
friend simatrix Im(const scimatrix_slice &)
Returns the imaginary part of the slice S.
scimatrix_slice & operator*=(const scimatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const cmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const complex &C)
Assing C to all elements of the slice.
scimatrix_slice & operator*=(const cimatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const simatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_subv operator[](const int)
Returns a row of the matrix.
scimatrix_slice & operator/=(const real &r)
Assigns the component wise division of the sparse slice and M to the slice.
friend srmatrix SupIm(const scimatrix_slice &)
Returns the imaginary part of the supremum of the slice S.
scimatrix_slice & operator-=(const cimatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
friend int RowLen(const scimatrix_slice &)
Returns the number columns of the matrix slice.
scimatrix_slice & operator-=(const srmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const imatrix &C)
Assing C to the slice.
scimatrix_slice & operator*=(const imatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const srmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cimatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const imatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator=(const simatrix &C)
Assing C to the slice.
scimatrix_slice & operator=(const rmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator/=(const interval &r)
Assigns the component wise division of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const rmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const rmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const interval &C)
Assing C to all elements of the slice.
scimatrix_slice & operator=(const rmatrix &C)
Assing C to the slice.
scimatrix_slice & operator*=(const simatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const cmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
friend simatrix Re(const scimatrix_slice &)
Returns the real part of the slice S.
scimatrix_slice & operator-=(const rmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const real &C)
Assing C to all elements of the slice.
friend int ColLen(const scimatrix_slice &)
Returns the number of rows of the matrix slice.
scimatrix_slice & operator=(const scmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator+=(const simatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cmatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator=(const imatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator+=(const cmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const cimatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const scmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator/=(const complex &r)
Assigns the component wise division of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const imatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator/=(const cinterval &r)
Assigns the component wise division of the sparse slice and M to the slice.
friend scmatrix Sup(const scimatrix_slice &)
Returns the supremum of the slice S.
scimatrix_slice & operator|=(const scimatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
friend int Lb(const scimatrix_slice &, const int)
Returns the lower index bound of the rows (if i==ROW) or columns (if i==COL) of the slice.
scimatrix_slice & operator-=(const simatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const scmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const rmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const scmatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const imatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const srmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const srmatrix_slice &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const simatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const cmatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const cmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const srmatrix_slice &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const srmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const rmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator+=(const cimatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cinterval &r)
Assigns the component wise product of the sparse slice and r to the slice.
friend std::ostream & operator<<(std::ostream &, const scimatrix_slice &)
Standard output operator for sparse matrix slice.
scimatrix_slice & operator*=(const complex &r)
Assigns the component wise product of the sparse slice and r to the slice.
scimatrix_slice & operator|=(const scmatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const scimatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator*=(const scmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const srmatrix &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const srmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cmatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const cmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const cimatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cmatrix &C)
Assing C to the slice.
scimatrix_slice & operator-=(const imatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const scimatrix &M)
Assigns the product of the sparse slice and M to the slice.
scimatrix_slice & operator=(const simatrix_slice &C)
Assing C to the slice.
scimatrix_slice & operator|=(const cimatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator-=(const scimatrix_slice &M)
Assigns the element wise difference of the sparse slice and M to the slice.
scimatrix_slice & operator|=(const imatrix &M)
Assigns the element wise convex hull of the sparse slice and M to the slice.
scimatrix_slice & operator=(const cinterval &C)
Assing C to all elements of the slice.
scimatrix_slice & operator*=(const interval &r)
Assigns the component wise product of the sparse slice and r to the slice.
friend srmatrix InfIm(const scimatrix_slice &)
Returns the imaginary part of the infimum of the slice S.
scimatrix_slice & operator+=(const scimatrix &M)
Assigns the element wise sum of the sparse slice and M to the slice.
scimatrix_slice & operator*=(const real &r)
Assigns the component wise product of the sparse slice and r to the slice.
scimatrix_slice & operator*=(const scmatrix_slice &M)
Assigns the product of the sparse slice and M to the slice.
Represents a row or column vector of a sparse matrix.
friend srvector InfIm(const scimatrix_subv &)
Returns the imaginary part of the infimum of the subvector.
scimatrix_subv & operator-=(const srvector &)
Assign the difference of the subvector with a vector to the subvector.
friend srvector SupRe(const scimatrix_subv &)
Returns the real part of the supremum of the subvector.
scimatrix_subv & operator=(const rvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const srvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator+=(const srvector &)
Assign the sum of the subvector with a vector to the subvector.
scimatrix_subv & operator=(const sivector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const scivector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const cvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator|=(const srvector &)
Assign the convex hull of the subvector and a vector to the subvector.
scimatrix_subv & operator=(const sivector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const srvector_slice &v)
Assigns a vector to a subvector.
friend int Lb(const scimatrix_subv &)
Returns the lower index bound of the subvector.
scimatrix_subv & operator=(const scimatrix_subv &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const srmatrix_subv &v)
Assigns a vector to a subvector.
friend int Ub(const scimatrix_subv &)
Returns the upper index bound of the subvector.
friend sivector Im(const scimatrix_subv &)
Returns the imaginary part of the subvector.
scimatrix_subv & operator/=(const real &)
Assign the componentwise division of the subvector with a scalar to the subvector.
scimatrix_subv & operator=(const scivector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const cinterval &v)
Assigns v to all elements of the subvector.
friend scvector Inf(const scimatrix_subv &)
Returns the infimum of the subvector.
scimatrix_subv & operator=(const ivector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const real &v)
Assigns v to all elements of the subvector.
friend scivector operator-(const scimatrix_subv &)
Unary negation operator.
friend std::istream & operator>>(std::istream &, scimatrix_subv &)
Standard input operator for subvectors.
scimatrix_subv & operator=(const complex &v)
Assigns v to all elements of the subvector.
scimatrix_subv & operator=(const civector &v)
Assigns a vector to a subvector.
friend int VecLen(const scimatrix_subv &)
Returns the length of the subvector.
friend srvector SupIm(const scimatrix_subv &)
Returns the imaginary part of the supremum of the subvector.
const cinterval operator[](const int i) const
Returns a copy of the i-th element of the subvector.
scimatrix_subv & operator=(const simatrix_subv &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const interval &v)
Assigns v to all elements of the subvector.
scimatrix_subv & operator=(const scmatrix_subv &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const civector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const cvector_slice &v)
Assigns a vector to a subvector.
cinterval & operator[](const int i)
Returns a reference to the i-th element of the subvector.
friend srvector InfRe(const scimatrix_subv &)
Returns the real part of the infimum of the subvector.
scimatrix_subv & operator=(const rvector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator*=(const real &)
Assign the componentwise product of the subvector with a scalar to the subvector.
friend scvector Sup(const scimatrix_subv &)
Returns the supremum of the subvector.
friend sivector Re(const scimatrix_subv &)
Returns the real part of the subvector.
scimatrix_subv & operator=(const scvector &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const ivector_slice &v)
Assigns a vector to a subvector.
scimatrix_subv & operator=(const scvector_slice &v)
Assigns a vector to a subvector.
A sparse complex interval matrix.
scimatrix & operator*=(const imatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator&=(const imatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
friend scimatrix Id(const scimatrix &)
Return a sparse unity matrix of the same dimension as A.
scimatrix & operator*=(const cimatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix(const imatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
friend scimatrix transp(const scimatrix &)
Returns the transpose of A.
scimatrix & operator*=(const rmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator|=(const cimatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix(const simatrix &A)
Creates a sparse interval matrix out of a sparse interval matrix A.
scimatrix(const srmatrix &A)
Creates a sparse interval matrix out of a sparse real matrix A.
scimatrix operator()(const intvector &pervec)
Performs a row permutation using a permutation vector.
scimatrix & operator&=(const cimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator=(const complex &A)
Assigns a complex value to all elements of the matrix (resulting in a dense matrix!...
scimatrix & operator|=(const srmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator&=(const scimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator+=(const srmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const imatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator+=(const scimatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const cmatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix_subv operator[](const cxscmatrix_column &)
Returns a column of the matrix as a sparse subvector object.
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
scimatrix & operator|=(const cimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator-=(const simatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator|=(const rmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
friend scmatrix mid(const scimatrix &)
Returns the componentwise midpoint of the matrix A.
scimatrix & operator*=(const srmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator+=(const cimatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator+=(const imatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const real &A)
Assigns a real value to all elements of the matrix (resulting in a dense matrix!)
std::vector< cinterval > & values()
Returns a reference to the vector containing the stored values (the array)
friend scmatrix Sup(const scimatrix &)
Returns the Supremum of the matrix A.
scimatrix(const int r, const int c)
Creates an empty matrix with r rows and c columns, pre-reserving space for 2*(r+c) elements.
scimatrix & operator|=(const scimatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
friend int RowLen(const scimatrix &)
Returns the number of columns of the matrix.
const std::vector< int > & row_indices() const
Returns a constant reference to the vector containing the row indices (the array)
friend int Lb(const scimatrix &, int)
Returns the lower index bound for the rows or columns of A.
friend srmatrix InfIm(const scimatrix &)
Returns the imaginary part of the infimum of the matrix A.
friend scmatrix diam(const scimatrix &)
Returns the componentwise diameter of the matrix A.
void full(cimatrix &A) const
Creates a full matrix out of the sparse matrix and stores it in A. This should normally be done using...
scimatrix & operator|=(const scmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator+=(const scmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator/=(const interval &r)
Divide all elements of the sparse matrix by r and assign the result to it.
scimatrix & operator|=(const imatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator&=(const cimatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator=(const simatrix &A)
Assign a sparse complex to a sparse interval matrix.
scimatrix & operator-=(const rmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator-=(const cmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator-=(const imatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator-=(const cimatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator/=(const real &r)
Divide all elements of the sparse matrix by r and assign the result to it.
scimatrix(const cimatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
scimatrix & operator-=(const cmatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator+=(const cmatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator*=(const complex &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
scimatrix(const cmatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
scimatrix operator()(const intmatrix &P)
Performs a row permutation using the permutation matrix P. Faster than explicitly computing the produ...
scimatrix & operator|=(const imatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator|=(const cmatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator=(const rmatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator*=(const scimatrix &B)
Multiply the sparse matrix by B and assign the result to it.
friend srmatrix SupRe(const scimatrix &)
Returns the real part of the supremum of the matrix A.
scimatrix(const rmatrix &A)
Creates a sparse matrix out of a dense matrix A. Only the non zero elements of A are stored explicitl...
friend int Ub(const scimatrix &, int)
Returns the upper index bound for the rows or columns of A.
scimatrix & operator+=(const simatrix &B)
Add B to the sparse matrix and assign the result to it.
friend srmatrix CompMat(const scimatrix &)
Returns Ostroswkis comparison matrix for A.
scimatrix & operator*=(const simatrix &B)
Multiply the sparse matrix by B and assign the result to it.
const std::vector< int > & column_pointers() const
Returns a constant reference to the vector containing the column pointers (the array)
friend simatrix Im(const scimatrix &)
Returns the imaginary part of the matrix A.
scimatrix operator()(const intvector &pervec, const intvector &q)
Performs a row and column permutation using two permutation vectors.
friend std::istream & operator>>(std::istream &, scimatrix_slice &)
Standard input operator for sparse matrix slice.
scimatrix & operator+=(const cmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator|=(const cmatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix(const int m, const int n, const int nnz, const int *rows, const int *cols, const cinterval *values, const enum STORAGE_TYPE t=triplet)
Creates a sparse matrix out of three arrays forming a matrix stored in triplet, compressed row or com...
scimatrix & operator=(const cmatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator-=(const cimatrix &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator*=(const rmatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
std::vector< int > & row_indices()
Returns a reference to the vector containing the row indices (the array)
scimatrix(const int r, const int c, const int e)
Creates an empty matrix with r rows and c columns, pre-reserving space for e elements.
scimatrix & operator*=(const scmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator-=(const rmatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
friend int ColLen(const scimatrix &)
Returns the number of rows of the matrix.
friend srmatrix InfRe(const scimatrix &)
Returns the real part of the infimum of the matrix A.
scimatrix & operator&=(const simatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator|=(const rmatrix_slice &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix(const int m, const int n, const int nnz, const intvector &rows, const intvector &cols, const civector &values, const enum STORAGE_TYPE t=triplet)
Creates a sparse matrix out of three vectors (arrays) forming a matrix stored in triplet,...
scimatrix & operator=(const cinterval &A)
Assigns a complex interval value to all elements of the matrix (resulting in a dense matrix!...
scimatrix & operator*=(const cmatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
friend void SetLb(scimatrix &, const int, const int)
Sets the lower index bound of the rows (i==ROW) or columns (i==COL) to j.
scimatrix & operator-=(const scmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
void dropzeros()
Drops explicitly stored zeros from the data structure.
scimatrix(const int ms, const int ns, const cimatrix &A)
Constructor for banded matrices.
std::vector< int > & column_pointers()
Returns a reference to the vector containing the column pointers (the array)
scimatrix & operator/=(const complex &r)
Divide all elements of the sparse matrix by r and assign the result to it.
scimatrix()
Standard constructor, creates an empty matrix of dimension 0x0.
scimatrix & operator=(const imatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator+=(const imatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator+=(const rmatrix &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator=(const rmatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator*=(const real &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
scimatrix & operator=(const cimatrix &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator=(const cimatrix_slice &A)
Assigns a dense matrix to the sparse matrix. Only the non zero entries of the dense matrix are used.
scimatrix & operator-=(const imatrix_slice &B)
Subtract B from the sparse matrix and assign the result to it.
scimatrix & operator*=(const cimatrix &B)
Multiply the sparse matrix by B and assign the result to it.
const cinterval operator()(int i, int j) const
Returns a copy of the element in row i and column j.
scimatrix & operator/=(const cinterval &r)
Divide all elements of the sparse matrix by r and assign the result to it.
friend simatrix Re(const scimatrix &)
Returns the real part of the matrix A.
scimatrix & operator=(const interval &A)
Assigns an interval value to all elements of the matrix (resulting in a dense matrix!...
scimatrix(const scmatrix &A)
Creates a sparse interval matrix out of a sparse complex matrix A.
scimatrix & operator|=(const simatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
cinterval & element(int i, int j)
Returns a reference to the element (i,j) of the matrix.
scimatrix & operator=(const srmatrix &A)
Assign a sparse real to a sparse complex interval matrix.
scimatrix & operator+=(const rmatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator*=(const imatrix_slice &B)
Multiply the sparse matrix by B and assign the result to it.
friend srmatrix SupIm(const scimatrix &)
Returns the imaginary part of the supremum of the matrix A.
const std::vector< cinterval > & values() const
Returns a constant reference to the vector containing the stored values (the array)
scimatrix & operator-=(const scimatrix &B)
Subtract B from the sparse matrix and assign the result to it.
friend void SetUb(scimatrix &, const int, const int)
Sets the upper index bound of the rows (i==ROW) or columns (i==COL) to j.
scimatrix & operator-=(const srmatrix &B)
Subtract B from the sparse matrix and assign the result to it.
friend simatrix abs(const scimatrix &)
Returns the componentwise absolute value of the matrix A.
scimatrix & operator=(const scmatrix &A)
Assign a sparse complex to a sparse complex interval matrix.
scimatrix & operator*=(const cmatrix &B)
Multiply the sparse matrix by B and assign the result to it.
scimatrix & operator&=(const imatrix &B)
Form the convex hull of a sparse matrix and B and assign the result to it.
scimatrix & operator*=(const interval &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
scimatrix & operator+=(const cimatrix_slice &B)
Add B to the sparse matrix and assign the result to it.
scimatrix & operator*=(const cinterval &r)
Multiply all elements of the sparse matrix by r and assign the result to it.
friend scimatrix conj(const scimatrix &)
Returns the conjugate complex of the matrix A.
scimatrix operator()(const intmatrix &P, const intmatrix &Q)
Performs row and column permutations using the two permutation matrices P and Q. Faster than explicit...
friend scmatrix Inf(const scimatrix &)
Returns the Infimum of the matrix A.
real density() const
Returns the density (the number of non-zeros divided by the number of elements) of the matrix.
Helper class for slices of sparse vectors.
A sparse complex interval vector.
scivector()
Default constructor, creates an empty vector of size 0
A slice of a sparse complex matrix.
Represents a row or column vector of a sparse matrix.
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
void dropzeros()
Drops explicitly stored zeros from the data structure.
Helper class for slices of sparse vectors.
A slice of a sparse real interval matrix.
Represents a row or column vector of a sparse matrix.
A sparse interval matrix.
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
void dropzeros()
Drops explicitly stored zeros from the data structure.
Helper class for slices of sparse vectors.
A sparse interval vector.
A slice of a sparse real matrix.
Represents a row or column vector of a sparse matrix.
void dropzeros()
Drops explicitly stored zeros from the data structure.
int get_nnz() const
Returns the number of non-zero entries (including explicitly stored zeros).
Helper class for slices of sparse vectors.
The namespace cxsc, providing all functionality of the class library C-XSC.
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
int ColLen(const cimatrix &)
Returns the column dimension.
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski's comparison matrix.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int RowLen(const cimatrix &)
Returns the row dimension.
STORAGE_TYPE
Enumeration depicting the storage type of a sparse matrix (Triplet storage, Compressed column storage...
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.