dcsrmm_c.c

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

                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSRskew_VecMult_CaABC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSRskew_VecMult_CaAB_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSRskew_VecMult_CaABbC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:
      if (alpha == 1) {
        if (beta == 1) {
          CSRskew_MatMult_CABC_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSRskew_MatMult_CAB_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSRskew_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) {
          CSRskew_MatMult_CaABC_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSRskew_MatMult_CaAB_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSRskew_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 CSCskew to get proper sign */

    switch ( n ) {
    case 1:
      if (alpha == 1) {
        if (beta == 1) {
          CSCskew_VecMult_CABC_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSCskew_VecMult_CAB_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          CSCskew_VecMult_CABbC_double(k, m, 
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSCskew_VecMult_CaABC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSCskew_VecMult_CaAB_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSCskew_VecMult_CaABbC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSCskew_MatMult_CABC_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSCskew_MatMult_CAB_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSCskew_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) {
          CSCskew_MatMult_CaABC_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSCskew_MatMult_CaAB_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSCskew_MatMult_CaABbC_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end of switch on n */
  } /* end of switch on transa */
  break;
case 0: case 3: case 5:
  switch ( transa ) {
  case 0:
    switch ( n ) {
    case 1:
      if (alpha == 1) {
        if (beta == 1) {
          CSR_VecMult_CABC_double(m, k, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSR_VecMult_CAB_double(m, k, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          CSR_VecMult_CABbC_double(m, k, 
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSR_VecMult_CaABC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSR_VecMult_CaAB_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSR_VecMult_CaABbC_double(m, k, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSR_MatMult_CABC_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSR_MatMult_CAB_double(m, n, k, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSR_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) {
          CSR_MatMult_CaABC_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSR_MatMult_CaAB_double(m, n, k, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSR_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:  /* operate with transpose */
    switch ( n ) {
    case 1:
      if (alpha == 1) {
        if (beta == 1) {
          CSC_VecMult_CABC_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSC_VecMult_CAB_double(k, m, 
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          CSC_VecMult_CABbC_double(k, m, 
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          CSC_VecMult_CaABC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          CSC_VecMult_CaAB_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          CSC_VecMult_CaABbC_double(k, m, alpha,
                                  val, indx, pntrb, pntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          CSC_MatMult_CABC_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSC_MatMult_CAB_double(k, n, m, 
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSC_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) {
          CSC_MatMult_CaABC_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          CSC_MatMult_CaAB_double(k, n, m, alpha,
                                  val, indx, pntrb, pntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          CSC_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 dcsrmm. Use 0 or 1. \n");
    break;
  } /* end switch on transa */
  break;
default:
    printf("Invalid argument descra[0] in dcsrmm. Use 0 - 5. \n");
    break;
}  
  
  
}