Esempio n. 1
0
void rSparseMatrix::setIdentity(double scalar)
{
  if (nRow != nCol) {
    rError("rSparseMatrix:: Identity matrix must be square matrix");
  }
  int length,step,index=0;
  switch(Sp_De_Di) {
  case SPARSE:
    if (nCol > NonZeroNumber) {
      rError("rSparseMatrix:: cannot store over NonZeroNumber");
      // the number of Diagonal elements equals nCol.
    }
    NonZeroCount  = nCol;
    NonZeroEffect = nCol;
    for (index=0; index< NonZeroCount; ++index) {
      row_index[index]    = index;
      column_index[index] = index;
      sp_ele[index]       = scalar;
    }
    break;
  case DENSE:
    length = nRow*nCol;
    catlas_dset(length,DZERO,de_ele,IONE);
    step = nCol+1;
    catlas_dset(nCol,scalar,de_ele,step);
    // only diagonal elements are the value of scalar.
    break;
  case DIAGONAL:
    catlas_dset(nCol,scalar,di_ele,IONE);
    break;
  }
}
Esempio n. 2
0
void rDenseMatrix::
initialize(int nRow, int nCol,
	   rDenseMatrix::rDeMat_De_Di De_Di)
{
  // rMessage("rDenseMatrix::initialize");

  rDenseMatrix();
  if (nRow<=0 || nCol<=0) {
    rError("rDenseMatrix:: Dimensions are nonpositive");
  }
  int old_length = this->nRow*this->nCol;
  if (this->De_Di==DIAGONAL) {
    old_length = this->nRow;
  }
  this->nRow  = nRow;
  this->nCol  = nCol;
  this->De_Di = De_Di;

  int length;
  switch(De_Di) {
  case DENSE:
    length = nRow*nCol;
    if (de_ele && old_length!=length) {
      delete[] de_ele;
      de_ele = NULL;
    }
    if (de_ele==NULL) {
      rNewCheck();
      de_ele = new double[length];
      if (de_ele==NULL) {
	rError("rDenseMatrix:: memory exhausted");
      }
    }
    catlas_dset(length,DZERO,de_ele,IONE);
    break;
  case DIAGONAL:
    if (nRow!=nCol) {
      rError("rDenseMatrix:: Diagonal must be Square matrix");
    }
    if (di_ele && old_length!=nRow) {
      delete[] di_ele;
      di_ele = NULL;
    }
    if (di_ele==NULL) {
      rNewCheck();
      di_ele = new double[nCol];
      if (di_ele==NULL) {
	rError("rDenseMatrix:: memory exhausted");
      }
    }
    catlas_dset(nCol,DZERO,di_ele,IONE);
    break;
  }
}
Esempio n. 3
0
void setA(double *du, double *dc, double *dl, int m, int n, double mu) {
  catlas_dset(m-1, -mu, du, 1);
  catlas_dset(m, (1+2*mu), dc, 1);
  catlas_dset(m-1, -mu, dl, 1);

  dc[0] = 1;
  du[0] = 0;
  
  dc[m-1] = 1;
  dl[m-2] = -1;
}
Esempio n. 4
0
void rDenseMatrix::setZero()
{
  int length;
  switch(De_Di) {
  case DENSE:
    length = nRow*nCol;
    catlas_dset(length,DZERO,de_ele,IONE);
    break;
  case DIAGONAL:
    catlas_dset(nCol,DZERO,di_ele,IONE);
    break;
  }
}
Esempio n. 5
0
void rDenseMatrix::setIdentity(double scalar)
{
  if (nRow != nCol) {
    rError("rSparseMatrix:: Identity matrix must be square matrix");
  }
  int length,step;
  switch(De_Di) {
  case DENSE:
    length = nRow*nCol;
    catlas_dset(length,DZERO,de_ele,IONE);
    step = nCol+1;
    catlas_dset(nCol,scalar,de_ele,step);
    break;
  case DIAGONAL:
    catlas_dset(nCol,scalar,di_ele,IONE);
    break;
  }
}
Esempio n. 6
0
void rSparseMatrix::setZero()
{
  int length;
  switch(Sp_De_Di) {
  case SPARSE:
    NonZeroCount  = 0;
    NonZeroEffect = 0;
    // No element is stored.
    break;
  case DENSE:
    length = nRow*nCol;
    catlas_dset(length,DZERO,de_ele,IONE);
    break;
  case DIAGONAL:
    catlas_dset(nCol,DZERO,di_ele,IONE);
    break;
  }
}
Esempio n. 7
0
void rVector::initialize(double value)
{
  if (nDim<=0) {
    rError("rVector:: nDim is nonpositive");
  }
  if (ele==NULL) {
    rNewCheck();
    ele = new double[nDim];
    if (ele==NULL) {
      rError("rVector:: memory exhausted");
    }
  }
  catlas_dset(nDim,value,ele,IONE);
}
Esempio n. 8
0
void rSparseMatrix::changeToDense(bool forceChange)
{
  if (Sp_De_Di!=SPARSE) {
    return;
  }
  // if (false)
  // rMessage(" NonZeroCount " << NonZeroCount);
  // rMessage(" nRow*nCol*0.2 " << nRow*nCol*0.2);
  if (forceChange == false && NonZeroCount < (nRow*nCol) * 0.20) {
    // if the number of elements are less than 20 percent,
    // we don't change to Dense.
    return;
  }
  // rMessage("change");
  Sp_De_Di = DENSE;
  de_ele = NULL;
  int length = nRow*nCol;
  rNewCheck();
  de_ele = new double[length];
  if (de_ele==NULL) {
    rError("rSparseMatrix:: memory exhausted");
  }
  catlas_dset(length,DZERO,de_ele,IONE);
  // all elements are set 0.
  for (int index=0; index<NonZeroCount; ++index) {
    int        i = row_index[index];
    int        j = column_index[index];
    double value = sp_ele[index];
    if (i==j) {
      de_ele[i+nCol*j] = value;
    } else {
      de_ele[i+nCol*j] = de_ele[j+nCol*i] = value;
    }
  }
  NonZeroCount = NonZeroNumber = NonZeroEffect = length;

  if (row_index != NULL) {
		 delete[] row_index;
  }
  if (column_index != NULL) {
		 delete[] column_index;
  }
  if (sp_ele != NULL) {
		 delete[] sp_ele;
  }
  row_index = NULL;
  column_index = NULL;
  sp_ele = NULL;
}
Esempio n. 9
0
void rVector::initialize(int nDim,double value)
{
  // rMessage("rVector initialize");
  if (ele && this->nDim!=nDim) {
    if (ele) {
      delete[] ele;
      ele = NULL;
    }
    if (nDim<=0) {
      rError("rVector:: nDim is nonpositive");
    }
  }
  this->nDim = nDim;
  if (ele==NULL) {
    ele = NULL;
    rNewCheck();
    ele = new double[nDim];
    if (ele==NULL) {
      rError("rVector:: memory exhausted");
    }
  }
  catlas_dset(nDim,value,ele,IONE);
}
Esempio n. 10
0
JNIEXPORT void JNICALL Java_uncomplicate_neanderthal_CBLAS_dset
(JNIEnv *env, jclass clazz, jint N, jdouble alpha, jobject X, jint offsetX, jint incX) {

    double *cX = (double *) (*env)->GetDirectBufferAddress(env, X);
    catlas_dset(N, alpha, cX + offsetX, incX);
};
Esempio n. 11
0
bool rDenseMatrix::copyFrom(rSparseMatrix& other)
{
  int length,index=0;
  switch(other.Sp_De_Di) {
  case rSparseMatrix::SPARSE:
    De_Di = DENSE;
    if (de_ele) {
      delete[] de_ele;
    }
    de_ele = NULL;
    nRow = other.nRow;
    nCol = other.nCol;
    rNewCheck();
    de_ele = new double[nRow*nCol];
    if (de_ele==NULL) {
      rError("rDenseMatrix:: memory exhausted");
    }
    length = nRow*nCol;
    catlas_dset(length,DZERO,de_ele,IONE);
    for (index = 0; index<other.NonZeroCount; ++index) {
      int i = other.row_index[index];
      int j = other.column_index[index];
      double value = other.sp_ele[index];
      de_ele[i+nCol*j] = de_ele[j+nCol*i] = value;
    }
    break;
  case rSparseMatrix::DENSE:
    De_Di = DENSE;
    if (de_ele && (other.nRow!=nRow || other.nCol!=nCol)) {
      delete[] de_ele;
      de_ele = NULL;
    }
    nRow = other.nRow;
    nCol = other.nCol;
    rNewCheck();
    de_ele = new double[nRow*nCol];
    if (de_ele==NULL) {
      rError("rDenseMatrix:: memory exhausted");
    }
    length = nRow*nCol;
    dcopy(&length,other.de_ele,&IONE,de_ele,&IONE);
    break;
  case rSparseMatrix::DIAGONAL:
    De_Di = DIAGONAL;
    if (di_ele && (other.nRow!=nRow || other.nCol!=nCol)) {
      delete[] di_ele;
      di_ele = NULL;
    }
    nRow = other.nRow;
    nCol = other.nCol;
    if (di_ele==NULL) {
      rNewCheck();
      di_ele = new double[nCol];
      if (di_ele==NULL) {
	rError("rDenseMatrix:: memory exhausted");
      }
    }
    dcopy(&nCol,other.di_ele,&IONE,di_ele,&IONE);
    break;
  }
  return _SUCCESS;
}
Esempio n. 12
0
void rSparseMatrix::
initialize(int nRow, int nCol,
	   rSparseMatrix::rSpMat_Sp_De_Di Sp_De_Di,
	   int NonZeroNumber)
{
  // rMessage("rSparseMatrix initialize");

  rSparseMatrix();
  if (nRow<=0 || nCol<=0) {
    rError("rSparseMatrix:: Dimensions are nonpositive");
  }
  this->nRow          = nRow;
  this->nCol          = nCol;
  this->Sp_De_Di      = Sp_De_Di;

  int length;
	row_index = NULL;
	column_index = NULL;
	sp_ele = NULL;
  switch(Sp_De_Di) {
  case SPARSE:
    this->NonZeroNumber  = NonZeroNumber;
    this->NonZeroCount   = 0;
    this->NonZeroEffect  = 0;
    if (NonZeroNumber > 0) {
      rNewCheck();
      row_index    = new int[NonZeroNumber];
      rNewCheck();
      column_index = new int[NonZeroNumber];
      rNewCheck();
      sp_ele       = new double[NonZeroNumber];
      if (row_index==NULL || column_index==NULL
	  || sp_ele==NULL) {
	rError("rSparseMatrix:: memory exhausted");
      }
    }
    break;
  case DENSE:
    this->NonZeroNumber = nRow*nCol;
    this->NonZeroCount  = nRow*nCol;
    this->NonZeroEffect = nRow*nCol;
    rNewCheck();
    de_ele = new double[NonZeroNumber];
    if (de_ele==NULL) {
      rError("rSparseMatrix:: memory exhausted");
    }
    length = nRow*nCol;
    catlas_dset(length,DZERO,de_ele,IONE);
    // all elements are 0.
    break;
  case DIAGONAL:
    if (nRow!=nCol) {
      rError("rSparseMatrix:: Diagonal must be Square matrix");
    }
    this->NonZeroNumber = nCol;
    this->NonZeroCount  = nCol;
    this->NonZeroEffect = nCol;
    if (di_ele==NULL) {
      rNewCheck();
      di_ele = new double[NonZeroNumber];
      if (di_ele==NULL) {
	rError("rSparseMatrix:: memory exhausted");
      }
    }
    catlas_dset(nCol,DZERO,di_ele,IONE);
    // all elements are 0.

    break;
  }
}
Esempio n. 13
0
void SGVector<float64_t>::set_const(float64_t const_elem)
{
	catlas_dset(vlen, const_elem, vector, 1);
}
Esempio n. 14
0
/*
 * Force boundary conditions
 */
void forceBoundaryConditions(double *U, int m, int n, double x) {
  catlas_dset((R+1), x, U, 1);
  catlas_dset((R+1), x, &U[R*(R+1)], 1);
  catlas_dset((R+1), x, U, (R+1));
  catlas_dset((R+1), x, &U[R], (R+1));
}
Esempio n. 15
0
void SGVector<float64_t>::set_const(float64_t const_elem)
{
	assert_on_cpu();
	catlas_dset(vlen, const_elem, vector, 1);
}