dvbrsm_c.c

用于求解大型稀疏线性方程组Ax=b的数值计算库.

           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                VBR_MatTriangSlvLU_CATBbC_double(mb, n,  val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     ldb, beta, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_MatTriangSlvLU_CDATBbC_double(mb, n,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, 
                                     b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_MatTriangSlvLU_CATDBbC_double(mb, n,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, 
                                     b, ldb, beta, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         } else {   /* alpha is general nonzero */
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_MatTriangSlvLU_CaATBC_double(mb, n,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_MatTriangSlvLU_CaDATBC_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_MatTriangSlvLU_CaATDBC_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_MatTriangSlvLU_CaATBmC_double(mb, n,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_MatTriangSlvLU_CaDATBmC_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_MatTriangSlvLU_CaATDBmC_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_MatTriangSlvLU_CaATB_double(mb, n,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, ldb, c, ldc, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_MatTriangSlvLU_CaDATB_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_MatTriangSlvLU_CaATDB_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, c, ldc, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                VBR_MatTriangSlvLU_CaATBbC_double(mb, n,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_MatTriangSlvLU_CaDATBbC_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_MatTriangSlvLU_CaATDBbC_double(mb, n,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                  
                                        bpntrb, bpntre, b, ldb, beta, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         }
         break;
       } /* end switch on n */
       break;
    case 2:  /* Upper triangular, Unit diagonal */
       switch (n) {
       case 1: /* Vec Mult */
         if (alpha == 1) {
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CATBC_double(mb,  val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CDATBC_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_VecTriangSlvUU_CATDBC_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CATBmC_double(mb,  val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CDATBmC_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_VecTriangSlvUU_CATDBmC_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CATB_double(mb,  val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CDATB_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_VecTriangSlvUU_CATDB_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else  { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CATBbC_double(mb,  val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     beta, c, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CDATBbC_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     beta, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_VecTriangSlvUU_CATDBbC_double(mb,  dv, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     beta, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         } else { /* alpha is general nonzero */
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CaATBC_double(mb,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CaDATBC_double(mb,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_VecTriangSlvUU_CaATDBC_double(mb,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CaATBmC_double(mb,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CaDATBmC_double(mb,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_VecTriangSlvUU_CaATDBmC_double(mb,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CaATB_double(mb,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, b, 
                                     c, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CaDATB_double(mb,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                VBR_VecTriangSlvUU_CaATDB_double(mb,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, 
                                     bpntre, b, c, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dvbrsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                VBR_VecTriangSlvUU_CaATBbC_double(mb,  alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb, bpntre, 
                                     b, beta, c, work, ind_base);
                break;
             case 2: /* Left scaling */
                VBR_VecTriangSlvUU_CaDATBbC_double(mb,  dv, alpha, val, indx, bindx, rpntr, cpntr,
                                     bpntrb,