dvbrmm_c.c

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

      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          VBRskew_MatMult_CaABC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          VBRskew_MatMult_CaAB_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          VBRskew_MatMult_CaABbC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, 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) {
          VBRskew_VecMult_CATBC_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          VBRskew_VecMult_CATB_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          VBRskew_VecMult_CATBbC_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          VBRskew_VecMult_CaATBC_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          VBRskew_VecMult_CaATB_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          VBRskew_VecMult_CaATBbC_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          VBRskew_MatMult_CATBC_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          VBRskew_MatMult_CATB_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          VBRskew_MatMult_CATBbC_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          VBRskew_MatMult_CaATBC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          VBRskew_MatMult_CaATB_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          VBRskew_MatMult_CaATBbC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end of switch on n */
    break;
  default:
    printf("Invalid argument transa in dvbrmm. 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) {
          VBR_VecMult_CABC_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          VBR_VecMult_CAB_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          VBR_VecMult_CABbC_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          VBR_VecMult_CaABC_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          VBR_VecMult_CaAB_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          VBR_VecMult_CaABbC_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          VBR_MatMult_CABC_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          VBR_MatMult_CAB_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          VBR_MatMult_CABbC_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          VBR_MatMult_CaABC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          VBR_MatMult_CaAB_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          VBR_MatMult_CaABbC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, 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) {
          VBR_VecMult_CATBC_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          VBR_VecMult_CATB_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else  { /*  beta is general nonzero */
          VBR_VecMult_CATBbC_double(mb, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, beta,
                                  c, ind_base);
        }
      } else { /* alpha is general nonzero */
        if (beta == 1) {
          VBR_VecMult_CaATBC_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else if (beta == 0) {
          VBR_VecMult_CaATB_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, 
                                  c, ind_base);
        } else { /*  beta is general nonzero */
          VBR_VecMult_CaATBbC_double(mb, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, beta,
                                  c, ind_base);
        }
      }
      break;
    default:  /* n is greater than 1 -- doing Mat Mult */
      if (alpha == 1) {
        if (beta == 1) {
          VBR_MatMult_CATBC_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          VBR_MatMult_CATB_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          VBR_MatMult_CATBbC_double(mb, n, kb, 
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      } else {   /* alpha is general nonzero */
        if (beta == 1) {
          VBR_MatMult_CaATBC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else if (beta == 0) {
          VBR_MatMult_CaATB_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, 
                                  c, ldc, ind_base);
        } else { /*  beta is general nonzero */
          VBR_MatMult_CaATBbC_double(mb, n, kb, alpha,
                                  val, indx, bindx, rpntr, cpntr,
                                  bpntrb, bpntre, b, ldb, beta,
                                  c, ldc, ind_base);
        }
      }
      break;
    } /* end switch on n */
    break;
  default: 
    printf("Invalid argument transa in dvbrmm. Use 0 or 1. \n");
    break;
  } /* end switch on transa */
  break;
default:
    printf("Invalid argument descra[0] in dvbrmm. Use 0 - 5. \n");
    break;
}  
  
  
}