dcscsm_c.c

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

                                     b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_MatTriangSlvLD_CABmC_double(m, n,  val, indx, pntrb, pntre, b, 
                                     ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_MatTriangSlvLD_CDABmC_double(m, n,  dv, val, indx, pntrb, pntre, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_MatTriangSlvLD_CADBmC_double(m, n,  dv, val, indx, pntrb, pntre, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_MatTriangSlvLD_CAB_double(m, n,  val, indx, pntrb, pntre, b, 
                                     ldb, c, ldc, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_MatTriangSlvLD_CDAB_double(m, n,  dv, val, indx, pntrb, pntre, 
                                     b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_MatTriangSlvLD_CADB_double(m, n,  dv, val, indx, pntrb, pntre, 
                                     b, ldb, c, ldc, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                CSC_MatTriangSlvLD_CABbC_double(m, n,  val, indx, pntrb, pntre, b, 
                                     ldb, beta, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_MatTriangSlvLD_CDABbC_double(m, n,  dv, val, indx, pntrb, pntre, 
                                     b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_MatTriangSlvLD_CADBbC_double(m, n,  dv, val, indx, pntrb, pntre, 
                                     b, ldb, beta, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         } else {   /* alpha is general nonzero */
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_MatTriangSlvLD_CaABC_double(m, n,  alpha, val, indx, pntrb, 
                                     pntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_MatTriangSlvLD_CaDABC_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_MatTriangSlvLD_CaADBC_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_MatTriangSlvLD_CaABmC_double(m, n,  alpha, val, indx, pntrb, 
                                     pntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_MatTriangSlvLD_CaDABmC_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_MatTriangSlvLD_CaADBmC_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_MatTriangSlvLD_CaAB_double(m, n,  alpha, val, indx, pntrb, 
                                     pntre, b, ldb, c, ldc, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_MatTriangSlvLD_CaDAB_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_MatTriangSlvLD_CaADB_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, c, ldc, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                CSC_MatTriangSlvLD_CaABbC_double(m, n,  alpha, val, indx, pntrb, 
                                     pntre, b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_MatTriangSlvLD_CaDABbC_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, beta, c, ldc, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_MatTriangSlvLD_CaADBbC_double(m, n,  dv, alpha, val, indx, 
                                     pntrb, pntre, b, ldb, beta, c, ldc, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         }
         break;
       } /* end switch on n */
       break;
    case 11:  /* Lower triangular, Unit diagonal */
       switch (n) {
       case 1: /* Vec Mult */
         if (alpha == 1) {
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CABC_double(m,  val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CDABC_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CADBC_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CABmC_double(m,  val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CDABmC_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CADBmC_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CAB_double(m,  val, indx, pntrb, pntre, b, 
                                     c, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CDAB_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CADB_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     c, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else  { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CABbC_double(m,  val, indx, pntrb, pntre, b, 
                                     beta, c, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CDABbC_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     beta, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CADBbC_double(m,  dv, val, indx, pntrb, pntre, b, 
                                     beta, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           }
         } else { /* alpha is general nonzero */
           if (beta == 1) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CaABC_double(m,  alpha, val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CaDABC_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CaADBC_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#if (0)
           } else if (beta == -1) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CaABmC_double(m,  alpha, val, indx, pntrb, pntre, b, 
                                     c, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CaDABmC_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CaADBmC_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, c, work, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
#endif
           } else if (beta == 0) {
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CaAB_double(m,  alpha, val, indx, pntrb, pntre, b, 
                                     c, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CaDAB_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CaADB_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, c, ind_base);
                break;
             default:
                printf("Invalid argument unitd in dcscsm. Use 1-3. \n");
                break;
             } /* end switch on unitd */
           } else { /*  beta is general nonzero */
             switch (unitd) {
             case 1: /* No scaling */
                CSC_VecTriangSlvLU_CaABbC_double(m,  alpha, val, indx, pntrb, pntre, 
                                     b, beta, c, work, ind_base);
                break;
             case 2: /* Left scaling */
                CSC_VecTriangSlvLU_CaDABbC_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, beta, c, work, ind_base);
                break;
             case 3: /* Right scaling */
                CSC_VecTriangSlvLU_CaADBbC_double(m,  dv, alpha, val, indx, pntrb, 
                                     pntre, b, beta, c, work, ind_base);
                break;