dbcomm_c.c

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

                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          BCOskew_MatMult_CaABbC_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  case 1:
    switch ( n ) {
    case 1:
      if (alpha == 1) {
        if (beta == 1) {
          BCOskew_VecMult_CATBC_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          BCOskew_VecMult_CATB_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          BCOskew_VecMult_CATBbC_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          BCOskew_VecMult_CaATBC_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          BCOskew_VecMult_CaATB_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          BCOskew_VecMult_CaATBbC_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          BCOskew_MatMult_CATBC_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          BCOskew_MatMult_CATB_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          BCOskew_MatMult_CATBbC_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          BCOskew_MatMult_CaATBC_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          BCOskew_MatMult_CaATB_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          BCOskew_MatMult_CaATBbC_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end of switch on n */
    break;
  default:
    printf("Invalid argument transa in dbcomm. Use 0 or 1. \n");
    break;
  } /* end switch on transa */
  break;
case 0: case 3: case 5:
  switch ( transa ) {
  case 0:
    switch ( n ) {
    case 1:
      if (alpha == 1) {
        if (beta == 1) {
          BCO_VecMult_CABC_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          BCO_VecMult_CAB_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          BCO_VecMult_CABbC_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          BCO_VecMult_CaABC_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          BCO_VecMult_CaAB_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          BCO_VecMult_CaABbC_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          BCO_MatMult_CABC_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          BCO_MatMult_CAB_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          BCO_MatMult_CABbC_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          BCO_MatMult_CaABC_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          BCO_MatMult_CaAB_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          BCO_MatMult_CaABbC_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, 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) {
          BCO_VecMult_CATBC_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          BCO_VecMult_CATB_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          BCO_VecMult_CATBbC_double(mb, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          BCO_VecMult_CaATBC_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          BCO_VecMult_CaATB_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          BCO_VecMult_CaATBbC_double(mb, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          BCO_MatMult_CATBC_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          BCO_MatMult_CATB_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          BCO_MatMult_CATBbC_double(mb, n, kb, 
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          BCO_MatMult_CaATBC_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          BCO_MatMult_CaATB_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          BCO_MatMult_CaATBbC_double(mb, n, kb, alpha,
                                  val, bindx,
                                  bjndx, bnnz, lb, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  default: 
    printf("Invalid argument transa in dbcomm. Use 0 or 1. \n");
    break;
  } /* end switch on transa */
  break;
default:
    printf("Invalid argument descra[0] in dbcomm. Use 0 - 5. \n");
    break;
}  
  
  
}