dcoomm_c.c

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

                                  val, indx, jndx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          COOskew_MatMult_CaABbC_double(m, n, k, alpha,
                                  val, indx, jndx, nnz, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  case 1:  /* For transpose, interchange row and column indices to get proper sign */
    switch (n) {
    case 1: /* Vec Mult */
      if (alpha == 1) {
        if (beta == 1) {
          COOskew_VecMult_CABC_double(k, m, 
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          COOskew_VecMult_CAB_double(k, m, 
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          COOskew_VecMult_CABbC_double(k, m, 
                                  val, jndx, indx, nnz, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          COOskew_VecMult_CaABC_double(k, m, alpha,
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          COOskew_VecMult_CaAB_double(k, m, alpha,
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          COOskew_VecMult_CaABbC_double(k, m, alpha,
                                  val, jndx, indx, nnz, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default: /* Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          COOskew_MatMult_CABC_double(k, n, m, 
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          COOskew_MatMult_CAB_double(k, n, m, 
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          COOskew_MatMult_CABbC_double(k, n, m, 
                                  val, jndx, indx, nnz, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          COOskew_MatMult_CaABC_double(k, n, m, alpha,
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          COOskew_MatMult_CaAB_double(k, n, m, alpha,
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          COOskew_MatMult_CaABbC_double(k, n, m, alpha,
                                  val, jndx, indx, nnz, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  default: 
    printf("Invalid argument transa in dcoomm. Use 0 or 1. \n");
    break;
  } /* end switch on n*/
  break;
case 0: case 3: case 5:
  switch (transa) {
  case 0:
    switch (n) {
    case 1: /* Vec Mult */
      if (alpha == 1) {
        if (beta == 1) {
          COO_VecMult_CABC_double(m, k, 
                                  val, indx, jndx, nnz, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          COO_VecMult_CAB_double(m, k, 
                                  val, indx, jndx, nnz, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          COO_VecMult_CABbC_double(m, k, 
                                  val, indx, jndx, nnz, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          COO_VecMult_CaABC_double(m, k, alpha,
                                  val, indx, jndx, nnz, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          COO_VecMult_CaAB_double(m, k, alpha,
                                  val, indx, jndx, nnz, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          COO_VecMult_CaABbC_double(m, k, alpha,
                                  val, indx, jndx, nnz, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default: /* Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          COO_MatMult_CABC_double(m, n, k, 
                                  val, indx, jndx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          COO_MatMult_CAB_double(m, n, k, 
                                  val, indx, jndx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          COO_MatMult_CABbC_double(m, n, k, 
                                  val, indx, jndx, nnz, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          COO_MatMult_CaABC_double(m, n, k, alpha,
                                  val, indx, jndx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          COO_MatMult_CaAB_double(m, n, k, alpha,
                                  val, indx, jndx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          COO_MatMult_CaABbC_double(m, n, k, alpha,
                                  val, indx, jndx, nnz, 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) {
          COO_VecMult_CABC_double(k, m, 
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          COO_VecMult_CAB_double(k, m, 
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          COO_VecMult_CABbC_double(k, m, 
                                  val, jndx, indx, nnz, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          COO_VecMult_CaABC_double(k, m, alpha,
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          COO_VecMult_CaAB_double(k, m, alpha,
                                  val, jndx, indx, nnz, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          COO_VecMult_CaABbC_double(k, m, alpha,
                                  val, jndx, indx, nnz, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default: /* Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          COO_MatMult_CABC_double(k, n, m, 
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          COO_MatMult_CAB_double(k, n, m, 
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          COO_MatMult_CABbC_double(k, n, m, 
                                  val, jndx, indx, nnz, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          COO_MatMult_CaABC_double(k, n, m, alpha,
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          COO_MatMult_CaAB_double(k, n, m, alpha,
                                  val, jndx, indx, nnz, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          COO_MatMult_CaABbC_double(k, n, m, alpha,
                                  val, jndx, indx, nnz, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  default: 
    printf("Invalid argument transa in dcoomm. Use 0 or 1. \n");
    break;
  } /* end switch on transa */
  break;
default:
  printf("Invalid argument descar[0] in dcoomm. Use 0-5. \n");
  break;
} /* end switch on descra[0] */

  
}