Fast Auxiliary Space Preconditioning 2.7.7 Aug/28/2022
Loading...
Searching...
No Matches
BlaSparseUtil.c
Go to the documentation of this file.
1
21#include <math.h>
22#include <time.h>
23
24#include "fasp.h"
25#include "fasp_functs.h"
26
27/*---------------------------------*/
28/*-- Public Functions --*/
29/*---------------------------------*/
52void fasp_sparse_abybms_ (INT *ia,
53 INT *ja,
54 INT *ib,
55 INT *jb,
56 INT *nap,
57 INT *map,
58 INT *mbp,
59 INT *ic,
60 INT *jc)
61{
62 /* FORM ic when jc is null and both when jc is not null for
63 the ic and jc are for c=a*b, a and b sparse */
64 /* na = number of rows of a */
65 /* mb = number of columns of b */
66 unsigned int jcform=0;
67 INT na,mb,icpp,iastrt,ibstrt,iaend,ibend,i,j,k,jia,jib;
68 INT *icp;
69 if (jc) jcform=1;
70 na=*nap;
71 mb=*mbp;
72 icpp = 1;
73 icp=(INT *) calloc(mb,sizeof(INT));
74
75 for (i = 0; i < mb; ++i) icp[i] = 0;
76
77 for (i = 0; i < na; ++i) {
78 ic[i] = icpp;
79 iastrt = ia[i]-1;
80 iaend = ia[i+1]-1;
81 if (iaend > iastrt) {
82 for (jia = iastrt; jia < iaend; ++jia) {
83 j = ja[jia]-1;
84 ibstrt = ib[j]-1;
85 ibend = ib[j+1]-1;
86 if (ibend > ibstrt) {
87 for (jib = ibstrt; jib< ibend; ++jib) {
88 k = jb[jib]-1;
89 if (icp[k] != i+1) {
90 if (jcform) jc[icpp-1] = k+1;
91 ++icpp;
92 icp[k] = i+1;
93 } //if
94 } //for
95 } //if
96 } //for
97 } //if
98 } //for (i...
99 ic[na] = icpp;
100
101 if (icp) free(icp);
102
103 return;
104}
105
127void fasp_sparse_abyb_ (INT *ia,
128 INT *ja,
129 REAL *a,
130 INT *ib,
131 INT *jb,
132 REAL *b,
133 INT *nap,
134 INT *map,
135 INT *mbp,
136 INT *ic,
137 INT *jc,
138 REAL *c)
139{
140 INT na,mb,iastrt,ibstrt,iaend,ibend,icstrt,icend,i,j,k,ji,jia,jib;
141 REAL *x;
142 REAL x0;
143 /*
144 C--------------------------------------------------------------------
145 C... C = A*B
146 C--------------------------------------------------------------------
147 */
148 na=*nap;
149 mb=*mbp;
150 x=(REAL *)calloc(mb,sizeof(REAL));
151 for (i = 0; i < na; ++i) {
152 icstrt = ic[i]-1;
153 icend = ic[i+1]-1;
154 if (icend > icstrt) {
155 for (ji = icstrt;ji < icend;++ji) {
156 k=jc[ji]-1;
157 x[k] = 0e+0;
158 }
159 iastrt = ia[i]-1;
160 iaend = ia[i+1]-1;
161 if (iaend > iastrt) {
162 for (jia = iastrt; jia < iaend ; ++jia) {
163 j = ja[jia]-1;
164 x0 = a[jia];
165 ibstrt = ib[j]-1;
166 ibend = ib[j+1]-1;
167 if (ibend > ibstrt) {
168 for (jib = ibstrt; jib < ibend; ++jib) {
169 k = jb[jib]-1;
170 x[k] += x0*b[jib];
171 }
172 } // end if
173 } // end for
174 }
175 for (ji = icstrt; ji < icend; ++ji) {
176 k=jc[ji]-1;
177 c[ji]=x[k];
178 } // end for
179 } // end if
180 }//end do
181 if (x) free(x);
182 return;
183}
184
197void fasp_sparse_iit_ (INT *ia,
198 INT *ja,
199 INT *na,
200 INT *ma,
201 INT *iat,
202 INT *jat)
203{
204 /*C====================================================================*/
205 INT i,j,jp,n,m,mh,nh,iaa,iab,k;
206 /*
207 C--------------------------------------------------------------------
208 C... Transposition of a graph (or the matrix) symbolically.
209 C...
210 C... Input:
211 C... IA, JA - given graph (or matrix).
212 C... N - number of rows of the matrix.
213 C... M - number of columns of the matrix.
214 C...
215 C... Output:
216 C... IAT, JAT - transposed graph (or matrix).
217 C...
218 C... Note:
219 C... N+1 is the dimension of IA.
220 C... M+1 is the dimension of IAT.
221 C--------------------------------------------------------------------
222 */
223 n=*na;
224 m=*ma;
225 mh = m + 1;
226 nh = n + 1;
227 for (i = 1; i < mh; ++i) {
228 iat[i] = 0;
229 }
230 iab = ia[nh-1] - 1;
231 for (i = 1; i <= iab; ++i) {
232 j = ja[i-1] + 2;
233 if (j <= mh)
234 iat[j-1] = iat[j-1] + 1;
235 }
236 iat[0] = 1;
237 iat[1] = 1;
238 if (m != 1) {
239 for (i= 2; i< mh; ++i) {
240 iat[i] = iat[i] + iat[i-1];
241 }
242 }
243 for (i = 1; i <= n; ++i) {
244 iaa = ia[i-1];
245 iab = ia[i] - 1;
246 if (iab >= iaa) {
247 for (jp = iaa; jp <= iab; ++jp) {
248 j = ja[jp-1] + 1;
249 k = iat[j-1];
250 jat[k-1] = i;
251 iat[j-1] = k + 1;
252 }
253 }
254 }
255 return;
256}
257
273void fasp_sparse_aat_ (INT *ia,
274 INT *ja,
275 REAL *a,
276 INT *na,
277 INT *ma,
278 INT *iat,
279 INT *jat,
280 REAL *at)
281{
282 /*C====================================================================*/
283 INT i,j,jp,n,m,mh,nh,iaa,iab,k;
284 /*
285 C--------------------------------------------------------------------
286 C... Transposition of a matrix.
287 C...
288 C... Input:
289 C... IA, JA - given graph (or matrix).
290 C... N - number of rows of the matrix.
291 C... M - number of columns of the matrix.
292 C...
293 C... Output:
294 C... IAT, JAT, AT - transposed matrix
295 C...
296 C... Note:
297 C... N+1 is the dimension of IA.
298 C... M+1 is the dimension of IAT.
299 C--------------------------------------------------------------------
300 */
301 n=*na;
302 m=*ma;
303 mh = m + 1;
304 nh = n + 1;
305
306 for (i = 1; i < mh; ++i) {
307 iat[i] = 0;
308 }
309 iab = ia[nh-1] - 1; /* Size of ja */
310 for (i = 1;i<=iab; ++i) {
311 j = ja[i-1] + 2;
312 if (j <= mh) {
313 iat[j-1] = iat[j-1] + 1;
314 }
315 }
316 iat[0] = 1;
317 iat[1] = 1;
318 if (m != 1) {
319 for (i= 2; i< mh; ++i) {
320 iat[i] = iat[i] + iat[i-1];
321 }
322 }
323
324 for (i=1; i<=n; ++i) {
325 iaa = ia[i-1];
326 iab = ia[i] - 1;
327 if (iab >= iaa) {
328 for (jp = iaa; jp <= iab; ++jp) {
329 j = ja[jp-1] + 1;
330 k = iat[j-1];
331 jat[k-1] = i;
332 at[k-1] = a[jp-1];
333 iat[j-1] = k + 1;
334 }
335 }
336 }
337
338 return;
339}
340
359void fasp_sparse_aplbms_ (INT *ia,
360 INT *ja,
361 INT *ib,
362 INT *jb,
363 INT *nab,
364 INT *mab,
365 INT *ic,
366 INT *jc)
367{
368 unsigned int jcform=0;
369 INT icpp,i1,i,j,jp,n,m,iastrt,iaend,ibstrt,ibend;
370 INT *icp;
371 /*
372 c... addition of two general sparse matricies (symbolic part) :
373 c= a + b.
374 */
375 if (jc) jcform=1;
376 n=*nab;
377 m=*mab;
378 icp=(INT *) calloc(m,sizeof(INT));
379 for (i=0; i< m; ++i) icp[i] = 0;
380 icpp = 1;
381 for (i=0; i< n; ++i) {
382 ic[i] = icpp;
383 i1=i+1;
384 iastrt = ia[i]-1;
385 iaend = ia[i1]-1;
386 if (iaend > iastrt) {
387 for (jp = iastrt; jp < iaend; ++jp) {
388 j = ja[jp];
389 if (jcform) jc[icpp-1] = j;
390 ++icpp;
391 icp[j-1] = i1;
392 }
393 }
394 ibstrt = ib[i] - 1;
395 ibend = ib[i1] - 1;
396 if (ibend > ibstrt) {
397 for (jp = ibstrt; jp < ibend; ++jp) {
398 j = jb[jp];
399 if (icp[j-1] != i1) {
400 if (jcform) jc[icpp-1] = j;
401 ++icpp;
402 }
403 }
404 }
405 } // // loop i=0; i< n
406 ic[n] = icpp;
407 if (icp) free(icp);
408 return;
409}
410
431void fasp_sparse_aplusb_ (INT *ia,
432 INT *ja,
433 REAL *a,
434 INT *ib,
435 INT *jb,
436 REAL *b,
437 INT *nab,
438 INT *mab,
439 INT *ic,
440 INT *jc,
441 REAL *c)
442{
443 INT n,m,icpp,i1,i,j,iastrt,iaend,ibstrt,ibend,icstrt,icend;
444 REAL *x;
445 /*
446 c... addition of two general sparse matricies (numerical part) :
447 c= a + b
448 */
449 n=*nab;
450 m=*mab;
451 x=(REAL *)calloc(m,sizeof(REAL));
452 for (i=0;i<n;++i) {
453 i1=i+1;
454 icstrt = ic[i]-1;
455 icend = ic[i1]-1;
456 if (icend > icstrt) {
457 for (icpp = icstrt;icpp<icend;++icpp) {
458 j=jc[icpp]-1;
459 x[j] = 0e+00;
460 }
461 iastrt = ia[i]-1;
462 iaend = ia[i1]-1;
463 if (iaend > iastrt) {
464 for (icpp = iastrt;icpp<iaend;++icpp) {
465 j=ja[icpp]-1;
466 x[j] = a[icpp];
467 }
468 }
469 ibstrt = ib[i]-1;
470 ibend = ib[i1]-1;
471 if (ibend > ibstrt) {
472 for (icpp = ibstrt;icpp<ibend;++icpp) {
473 j = jb[icpp]-1;
474 x[j] = x[j] + b[icpp];
475 }
476 }
477 for (icpp = icstrt;icpp<icend;++icpp) {
478 j=jc[icpp]-1;
479 c[icpp] = x[j];
480 }
481 } // if (icstrt > icend)...
482 } // loop i=0; i< n
483 if (x) free(x);
484 return;
485}
486
515void fasp_sparse_rapms_ (INT *ir,
516 INT *jr,
517 INT *ia,
518 INT *ja,
519 INT *ip,
520 INT *jp,
521 INT *nin,
522 INT *ncin,
523 INT *iac,
524 INT *jac,
525 INT *maxrout)
526{
527 INT i,jk,jak,jpk,ic,jc,nc,icp1,ira,irb,ipa,ipb;
528 INT maxri,maxr,iaa,iab,iacp,if1,jf1,jacform=0;
529 INT *ix;
530
531 nc = *ncin;
532 ix=(INT *) calloc(nc,sizeof(INT));
533 if (jac) jacform=1;
534 maxr = 0;
535 for (i =0;i<nc; ++i) {
536 ix[i]=0;
537 ira=ir[i];
538 irb=ir[i+1];
539 maxri=irb-ira;
540 if (maxr < maxri) maxr=maxri;
541 }
542 iac[0] = 1;
543 iacp = iac[0]-1;
544 for (ic = 0;ic<nc;ic++) {
545 ira=ir[ic]-1;
546 icp1=ic+1;
547 irb=ir[icp1]-1;
548 for (jk = ira;jk<irb;jk++) {
549 if1 = jr[jk]-1;
550 iaa = ia[if1]-1;
551 iab = ia[if1+1]-1;
552 for (jak = iaa;jak < iab;jak++) {
553 jf1 = ja[jak]-1;
554 ipa = ip[jf1]-1;
555 ipb = ip[jf1+1]-1;
556 for (jpk = ipa;jpk < ipb;jpk++) {
557 jc = jp[jpk]-1;
558 if (ix[jc] != icp1) {
559 ix[jc]=icp1;
560 if (jacform) jac[iacp] = jc+1;
561 iacp++;
562 }
563 }
564 }
565 }
566 iac[icp1] = iacp+1;
567 }
568 *maxrout=maxr;
569 if (ix) free(ix);
570 return;
571}
572
596void fasp_sparse_wtams_ (INT *jw,
597 INT *ia,
598 INT *ja,
599 INT *nwp,
600 INT *map,
601 INT *jv,
602 INT *nvp,
603 INT *icp)
604{
605 INT nw,nv,iastrt,iaend,j,k,jiw,jia;
606 if (*nwp<=0) {*nvp=0; return;}
607 nw=*nwp;
608 nv = 0;
609 for (jiw = 0;jiw < nw; ++jiw) {
610 j = jw[jiw]-1;
611 iastrt = ia[j]-1;
612 iaend = ia[j+1]-1;
613 if (iaend > iastrt) {
614 for (jia = iastrt ;jia< iaend;jia++) {
615 k = ja[jia]-1;
616 if (!icp[k]) {
617 jv[nv] = k+1;
618 nv++;
619 icp[k] = nv;
620 }
621 }
622 }
623 }
624 *nvp=nv;
625 return;
626}
627
648void fasp_sparse_wta_ (INT *jw,
649 REAL *w,
650 INT *ia,
651 INT *ja,
652 REAL *a,
653 INT *nwp,
654 INT *map,
655 INT *jv,
656 REAL *v,
657 INT *nvp)
658{
659 INT nw,nv,iastrt,iaend,j,k,ji,jiw,jia;
660 REAL v0;
661
662 if (*nwp<=0) {*nvp=-1; return;}
663 nw=*nwp;
664 nv=*nvp;
665 for (ji = 0;ji < nv;++ji) {
666 k=jv[ji]-1;
667 v[k] = 0e+0;
668 }
669 for (jiw = 0;jiw<nw; ++jiw) {
670 j = jw[jiw]-1;
671 v0 = w[jiw];
672 iastrt = ia[j]-1;
673 iaend = ia[j+1]-1;
674 if (iaend > iastrt) {
675 for (jia = iastrt;jia < iaend;jia++) {
676 k = ja[jia]-1;
677 v[k] += v0*a[jia];
678 }
679 } // end if
680 } // end for
681 return;
682}
683
699void fasp_sparse_ytxbig_ (INT *jy,
700 REAL *y,
701 INT *nyp,
702 REAL *x,
703 REAL *s)
704{
705 INT i,ii;
706 *s=0e+00;
707 if (*nyp > 0) {
708 for (i = 0;i< *nyp; ++i) {
709 ii = jy[i]-1;
710 *s += y[i]*x[ii];
711 }
712 }
713 return;
714}
715
733void fasp_sparse_ytx_ (INT *jy,
734 REAL *y,
735 INT *jx,
736 REAL *x,
737 INT *nyp,
738 INT *nxp,
739 INT *icp,
740 REAL *s)
741{// not tested
742 INT i,j,i0,ii;
743 *s=0e+00;
744 if ((*nyp > 0) && (*nxp > 0)) {
745 for (i = 0;i< *nyp; ++i) {
746 j = jy[i]-1;
747 i0=icp[j];
748 if (i0) {
749 ii=jx[i0]-1;
750 *s += y[i]*x[ii];
751 }
752 }
753 }
754 return;
755}
756
787void fasp_sparse_rapcmp_ (INT *ir,
788 INT *jr,
789 REAL *r,
790 INT *ia,
791 INT *ja,
792 REAL *a,
793 INT *ipt,
794 INT *jpt,
795 REAL *pt,
796 INT *nin,
797 INT *ncin,
798 INT *iac,
799 INT *jac,
800 REAL *ac,
801 INT *idummy)
802{
803 INT i,j,k,n,nc,nv,nw,nptjc,iacst,iacen,ic,jc,is,js,jkc,iastrt,iaend,ji,jia;
804 REAL aij,v0;
805 INT *icp=NULL, *jv=NULL,*jris=NULL, *jptjs=NULL;
806 REAL *v=NULL, *ris=NULL, *ptjs=NULL;
807 n=*nin;
808 nc=*ncin;
809
810 v = (REAL *) calloc(n,sizeof(REAL));
811 icp = (INT *) calloc(n,sizeof(INT));
812 jv = (INT *) calloc(n,sizeof(INT));
813 if (!(icp && v && jv)) {
814 fprintf(stderr,"### ERROR: Could not allocate memory!\n");
815 fasp_chkerr(ERROR_ALLOC_MEM, __FUNCTION__);
816 }
817 for (i=0;i<n;++i) {
818 icp[i] = 0;
819 jv[i] = 0;
820 v[i]=0e+00;
821 }
822 for (ic = 0;ic<nc;ic++) {
823 nw = ir[ic+1]-ir[ic];
824 if (nw<=0) continue;
825 is = ir[ic]-1;
826 jris=jr+is;
827 // wtams_(jris,ia, ja, &nw,&n,jv, &nv, icp);
828 // void wtams_(INT *jw,INT *ia, INT *ja, INT *nwp,INT *map,
829 // INT *jv, INT *nvp, INT *icp)
830 // INT nw,ma,nv,iastrt,iaend,i,j,k,ji,jia;
831 nv = 0;
832 for (ji = 0;ji < nw; ++ji) {
833 j = *(jris+ji)-1;
834 iastrt = ia[j]-1;
835 iaend = ia[j+1]-1;
836 if (iaend > iastrt) {
837 for (jia = iastrt ;jia< iaend;jia++) {
838 k = ja[jia]-1;
839 if (!icp[k]) {
840 *(jv+nv) = k+1;
841 nv++;
842 icp[k] = nv;
843 } //end if
844 } //end for
845 } //end if
846 } //end for loop for forming the nonz struct of (r_i)^t*A
847 ris=r+is;
848 // wta_(jris, ris,ia, ja, a,&nw, &n, jv, v, &nv);
849 for (ji = 0;ji < nv;++ji) {
850 k=jv[ji]-1;
851 v[k] = 0e+0;
852 }
853 for (ji = 0;ji<nw ; ++ji) {
854 j = *(jris+ji)-1;
855 v0 = *(ris+ji);
856 iastrt = ia[j]-1;
857 iaend = ia[j+1]-1;
858 if (iaend > iastrt) {
859 for (jia = iastrt;jia < iaend;jia++) {
860 k = ja[jia]-1;
861 v[k] += v0*a[jia];
862 }
863 } // end if
864 } //end for loop for calculating the product (r_i)^t*A
865 iacst=iac[ic]-1;
866 iacen=iac[ic+1]-1;
867 for (jkc = iacst; jkc<iacen;jkc++) {
868 jc = jac[jkc]-1;
869 nptjc = ipt[jc+1]-ipt[jc];
870 js = ipt[jc]-1;
871 jptjs = jpt+js;
872 ptjs = pt+js;
873 // ytxbig_(jptjs,ptjs,&nptjc,v,&aij);
874 aij=0e+00;
875 if (nptjc > 0) {
876 for (i = 0;i< nptjc; ++i) {
877 j = *(jptjs+i)-1;
878 aij += (*(ptjs+i))*(*(v+j));
879 } //end for
880 } //end if
881 ac[jkc] = aij;
882 } //end for
883 // set nos the values of v and icp back to 0;
884 for (i=0; i < nv; ++i) {
885 j=jv[i]-1;
886 icp[j]=0;
887 v[j]=0e+00;
888 } //end for
889 } //end for
890
891 if (v) free(v);
892 if (icp) free(icp);
893 if (jv) free(jv);
894
895 return;
896}
897
907ivector fasp_sparse_mis (dCSRmat *A)
908{
909 // information of A
910 INT n = A->row;
911 INT *IA = A->IA;
912 INT *JA = A->JA;
913
914 // local variables
915 INT i,j;
916 INT row_begin, row_end;
917 INT count=0;
918 INT *flag;
919 flag = (INT *)fasp_mem_calloc(n, sizeof(INT));
920 //for (i=0;i<n;i++) flag[i]=0;
921 memset(flag, 0, sizeof(INT)*n);
922
923 // work space
924 INT *work = (INT*)fasp_mem_calloc(n,sizeof(INT));
925
926 // return vector
927 ivector MIS;
928
929 // main loop
930 for (i=0;i<n;i++) {
931 if (flag[i] == 0) {
932 flag[i] = 1;
933 row_begin = IA[i] - 1; row_end = IA[i+1] - 1;
934 for (j = row_begin; j<row_end; j++) {
935 if (flag[JA[j]-1] > 0) {
936 flag[i] = -1;
937 break;
938 }
939 }
940 if (flag[i]) {
941 work[count] = i; count++;
942 for (j = row_begin; j<row_end; j++) {
943 flag[JA[j]-1] = -1;
944 }
945 }
946 } // end if
947 }// end for
948
949 // form MIS
950 MIS.row = count;
951 work = (INT *)fasp_mem_realloc(work, count*sizeof(INT));
952 MIS.val = work;
953
954 // clean
955 fasp_mem_free(flag); flag = NULL;
956
957 //return
958 return MIS;
959}
960
961/*---------------------------------*/
962/*-- End of File --*/
963/*---------------------------------*/
fasp_mem_free
void fasp_mem_free(void *mem)
Free up previous allocated memory body and set pointer to NULL.
Definition: AuxMemory.c:152
fasp_mem_realloc
void * fasp_mem_realloc(void *oldmem, const LONGLONG tsize)
Reallocate, initiate, and check memory.
Definition: AuxMemory.c:113
fasp_mem_calloc
void * fasp_mem_calloc(const unsigned int size, const unsigned int type)
Allocate, initiate, and check memory.
Definition: AuxMemory.c:65
fasp_chkerr
void fasp_chkerr(const SHORT status, const char *fctname)
Check error status and print out error messages before quit.
Definition: AuxMessage.c:213
fasp_sparse_rapms_
void fasp_sparse_rapms_(INT *ir, INT *jr, INT *ia, INT *ja, INT *ip, INT *jp, INT *nin, INT *ncin, INT *iac, INT *jac, INT *maxrout)
Calculates the nonzero structure of R*A*P, if jac is not null. If jac is null only finds num of nonze...
Definition: BlaSparseUtil.c:515
fasp_sparse_wta_
void fasp_sparse_wta_(INT *jw, REAL *w, INT *ia, INT *ja, REAL *a, INT *nwp, INT *map, INT *jv, REAL *v, INT *nvp)
Calculate v^t = w^t A, where w is a sparse vector and A is sparse matrix. v is an array of dimension ...
Definition: BlaSparseUtil.c:648
fasp_sparse_wtams_
void fasp_sparse_wtams_(INT *jw, INT *ia, INT *ja, INT *nwp, INT *map, INT *jv, INT *nvp, INT *icp)
Finds the nonzeroes in the result of v^t = w^t A, where w is a sparse vector and A is sparse matrix....
Definition: BlaSparseUtil.c:596
fasp_sparse_abyb_
void fasp_sparse_abyb_(INT *ia, INT *ja, REAL *a, INT *ib, INT *jb, REAL *b, INT *nap, INT *map, INT *mbp, INT *ic, INT *jc, REAL *c)
Multiplication of two sparse matrices.
Definition: BlaSparseUtil.c:127
fasp_sparse_aplusb_
void fasp_sparse_aplusb_(INT *ia, INT *ja, REAL *a, INT *ib, INT *jb, REAL *b, INT *nab, INT *mab, INT *ic, INT *jc, REAL *c)
Addition of two sparse matrices.
Definition: BlaSparseUtil.c:431
fasp_sparse_ytxbig_
void fasp_sparse_ytxbig_(INT *jy, REAL *y, INT *nyp, REAL *x, REAL *s)
Calculates s = y^t x. y-sparse, x - no.
Definition: BlaSparseUtil.c:699
fasp_sparse_aat_
void fasp_sparse_aat_(INT *ia, INT *ja, REAL *a, INT *na, INT *ma, INT *iat, INT *jat, REAL *at)
Transpose a boolean matrix (only given by ia, ja)
Definition: BlaSparseUtil.c:273
fasp_sparse_mis
ivector fasp_sparse_mis(dCSRmat *A)
Get the maximal independet set of a CSR matrix.
Definition: BlaSparseUtil.c:907
fasp_sparse_abybms_
void fasp_sparse_abybms_(INT *ia, INT *ja, INT *ib, INT *jb, INT *nap, INT *map, INT *mbp, INT *ic, INT *jc)
Multiplication of two sparse matrices: calculating the nonzero structure of the result if jc is not n...
Definition: BlaSparseUtil.c:52
fasp_sparse_iit_
void fasp_sparse_iit_(INT *ia, INT *ja, INT *na, INT *ma, INT *iat, INT *jat)
Transpose a boolean matrix (only given by ia, ja)
Definition: BlaSparseUtil.c:197
fasp_sparse_ytx_
void fasp_sparse_ytx_(INT *jy, REAL *y, INT *jx, REAL *x, INT *nyp, INT *nxp, INT *icp, REAL *s)
Calculates s = y^t x. y is sparse, x is sparse.
Definition: BlaSparseUtil.c:733
fasp_sparse_rapcmp_
void fasp_sparse_rapcmp_(INT *ir, INT *jr, REAL *r, INT *ia, INT *ja, REAL *a, INT *ipt, INT *jpt, REAL *pt, INT *nin, INT *ncin, INT *iac, INT *jac, REAL *ac, INT *idummy)
Calculates R*A*P after the nonzero structure of the result is known. iac,jac,ac have to be allocated ...
Definition: BlaSparseUtil.c:787
fasp_sparse_aplbms_
void fasp_sparse_aplbms_(INT *ia, INT *ja, INT *ib, INT *jb, INT *nab, INT *mab, INT *ic, INT *jc)
Addition of two sparse matrices: calculating the nonzero structure of the result if jc is not null....
Definition: BlaSparseUtil.c:359
fasp.h
Main header file for the FASP project.
REAL
#define REAL
Definition: fasp.h:75
INT
#define INT
Definition: fasp.h:72
ERROR_ALLOC_MEM
#define ERROR_ALLOC_MEM
Definition: fasp_const.h:30
dCSRmat
Sparse matrix of REAL type in CSR format.
Definition: fasp.h:151
dCSRmat::row
INT row
row number of matrix A, m
Definition: fasp.h:154
dCSRmat::IA
INT * IA
integer array of row pointers, the size is m+1
Definition: fasp.h:163
dCSRmat::JA
INT * JA
integer array of column indexes, the size is nnz
Definition: fasp.h:166
ivector
Vector with n entries of INT type.
Definition: fasp.h:368
ivector::row
INT row
number of rows
Definition: fasp.h:371
ivector::val
INT * val
actual vector entries
Definition: fasp.h:374