dcscmm_c.c

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

                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSCskew_VecMult_CaABC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSCskew_VecMult_CaAB_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSCskew_VecMult_CaABbC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default: /* Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSCskew_MatMult_CABC_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSCskew_MatMult_CAB_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSCskew_MatMult_CABbC_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          CSCskew_MatMult_CaABC_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSCskew_MatMult_CaAB_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSCskew_MatMult_CaABbC_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  case 1:    /* call CSR to get proper sign  */
    switch (n) {
    case 1:  /* Vec Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSRskew_VecMult_CABC_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSRskew_VecMult_CAB_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          CSRskew_VecMult_CABbC_double(k, m, 
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSRskew_VecMult_CaABC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSRskew_VecMult_CaAB_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSRskew_VecMult_CaABbC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default: /* Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSRskew_MatMult_CABC_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSRskew_MatMult_CAB_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSRskew_MatMult_CABbC_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          CSRskew_MatMult_CaABC_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSRskew_MatMult_CaAB_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSRskew_MatMult_CaABbC_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
  } /* end switch on transa */
  break;
case 0: case 3: case 5:
  switch (transa) {
  case 0:
    switch (n) {
    case 1: /* Vec Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSC_VecMult_CABC_double(m, k, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSC_VecMult_CAB_double(m, k, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          CSC_VecMult_CABbC_double(m, k, 
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSC_VecMult_CaABC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSC_VecMult_CaAB_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSC_VecMult_CaABbC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default: /* Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSC_MatMult_CABC_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSC_MatMult_CAB_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSC_MatMult_CABbC_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          CSC_MatMult_CaABC_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSC_MatMult_CaAB_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSC_MatMult_CaABbC_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  case 1: 
    switch (n) {
    case 1: /* Vec Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSR_VecMult_CABC_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSR_VecMult_CAB_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          CSR_VecMult_CABbC_double(k, m, 
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSR_VecMult_CaABC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSR_VecMult_CaAB_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSR_VecMult_CaABbC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default: /* Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSR_MatMult_CABC_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSR_MatMult_CAB_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSR_MatMult_CABbC_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          CSR_MatMult_CaABC_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSR_MatMult_CaAB_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSR_MatMult_CaABbC_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  default: 
    printf("Invalid argument transa in dcscmm. Use 0 or 1. \n");
    break;
  } /* end switch on transa */
  break;
default:
  printf("Invalid argument descar[0] in dcscmm. Use 0-5. \n");
  break;
} /* end switch on descra[0] */

  
}