dbscsm_c.c

来自「用于求解大型稀疏线性方程组Ax=b的数值计算库.」· C语言 代码 · 共 1,470 行 · 第 1/5 页

             switch (unitd) {
             case 1: /* No scaling */
                BSC_VecTriangSlvUU_CaABC_double(mb,  alpha, val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_VecTriangSlvUU_CaDABC_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_VecTriangSlvUU_CaADBC_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_VecTriangSlvUU_CaABmC_double(mb,  alpha, val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_VecTriangSlvUU_CaDABmC_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_VecTriangSlvUU_CaADBmC_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_VecTriangSlvUU_CaAB_double(mb,  alpha, val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     c, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_VecTriangSlvUU_CaDAB_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_VecTriangSlvUU_CaADB_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, c, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                BSC_VecTriangSlvUU_CaABbC_double(mb,  alpha, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, beta, c, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_VecTriangSlvUU_CaDABbC_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, beta, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_VecTriangSlvUU_CaADBbC_double(mb,  dv, alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, beta, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         }
         break;
       default: /* Mat Mult */
         if (alpha == 1) {
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CABC_double(mb, n,  val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CDABC_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CADBC_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CABmC_double(mb, n,  val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CDABmC_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CADBmC_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CAB_double(mb, n,  val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     ldb, c, ldc, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CDAB_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CADB_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, c, ldc, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CABbC_double(mb, n,  val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     ldb, beta, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CDABbC_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CADBbC_double(mb, n,  dv, val, bindx,
                                     bpntrb, bpntre, lb, 
                                     b, ldb, beta, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         } else {   /* alpha is general nonzero */
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CaABC_double(mb, n,  alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CaDABC_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CaADBC_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CaABmC_double(mb, n,  alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CaDABmC_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CaADBmC_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CaAB_double(mb, n,  alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, ldb, c, ldc, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CaDAB_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CaADB_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, c, ldc, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                BSC_MatTriangSlvUU_CaABbC_double(mb, n,  alpha, val, bindx,
                                     bpntrb, 
                                     bpntre, lb, b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_MatTriangSlvUU_CaDABbC_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                BSC_MatTriangSlvUU_CaADBbC_double(mb, n,  dv, alpha, val, bindx,
                                  
                                        bpntrb, bpntre, lb, b, ldb, beta, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dbscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         }
         break;
       } /* end switch on n */
       break;
     default: /*  Invalid descra[1] */
       printf("Check value of descra[1] (descra(2) in Fortran.\n");
       printf("Valid values of descra[1] (descra(2)) are 1 and 2.\n");
       break;
     } /* end switch on descra[1] */
     break;
  case 1:
    switch  ( descra[1] ) {
    case 1:  /* Lower triangular, Unit diagonal */
       switch (n) {
       case 1: /* Vec Mult */
         if (alpha == 1) {
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                BSC_VecTriangSlvLU_CATBC_double(mb,  val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                BSC_VecTriangSlvLU_CDATBC_double(mb,  dv, val, bindx,
                                     bpntrb, bpntre, lb, b, 
                                     c, work, ind_base);
                break;
             case 3: /* Right scaling */