C++ dcopy函数代码示例

void Tri::PutFace(double *from, int fac){
  if(from)
    switch(fac){
    case 0:
      dcopy(qa, from, 1, h[0], 1);
      break;
    case 1:
      dcopy(qb, from, 1, h[0]+qa-1, qa);
      break;
    case 2:
      dcopy(qb, from, 1, h[0], qa);
      break;
    default:
      error_msg(GetFace -- unknown face);
      break;
    }
  else
    switch(fac){
    case 0:
      dzero(qa, h[0], 1);
      break;
    case 1:
      dzero(qb, h[0]+qa-1, qa);
      break;
    case 2:
      dzero(qb, h[0], qa);
      break;
    default:
      error_msg(GetFace -- unknown face);
      break;
    }
}

void PackMatrixV(double *a, int n, double *b, int bwidth, char trip){
  register int i;

  if(n>2*bwidth){ /* banded symmetric lower triangular form */
    double *s;

    if(trip == 'l'){
      for(i = 0,s=b; i < n-bwidth; ++i,s+=bwidth)
  dcopy(bwidth,a+i*n+i,1,s,1);

      for(i = n-bwidth; i < n; ++i,s+=bwidth)
  dcopy(n-i,a+i*n+i,1,s,1);
    }
    else
      error_msg(banded upper form not set up in PackMatrixV);
  }
  else{
    register int j;
    if(trip == 'l'){
      /* symmetric lower triangular form */
      for(i=0, j=0; i < n; j+=n-i++)
  dcopy(n-i, a+i*n+i, 1, b+j, 1);
    }
    else{
      /* symmetric upper triangular form */
      for(i=0, j=0; i < n; j+= ++i)
  dcopy(i+1, a+i*n, 1, b+j, 1);
    }
  }
}

void set_order(int Je)
{
	tmp_order = Je;
	dcopy(3, Alpha_SS[Je-1], 1, Alpha_Int, 1);
	dcopy(3,  Beta_SS[Je-1], 1,  Beta_Int, 1);
	Gamma_Int =  Gamma_SS[Je-1];
}

void collectAfterPre(Vector u, const Vector v)
{
  int source, dest;
  if (u->comm_rank == 0) {
    int len=u->len-1;
    dcopy(&len, v->data, &v->stride, u->data+1, &u->stride);
  } else if (u->comm_rank == u->comm_size-1) {
    int len=v->len-1;
    dcopy(&len, v->data+1, &v->stride, u->data+1, &u->stride);
  } else
    copyVector(u, v);

  // west
  double recv;
  MPI_Cart_shift(*u->comm, 0,   -1, &source, &dest);
  MPI_Sendrecv(v->data,        1, MPI_DOUBLE, dest,   0,
               u->data, 1, MPI_DOUBLE, source, 0, *u->comm, MPI_STATUS_IGNORE);
  if (source > -1)
    u->data[u->len-2] += u->data[0];

  // east
  MPI_Cart_shift(*u->comm,  0,   1, &source, &dest);
  MPI_Sendrecv(v->data+v->len-1, 1, MPI_DOUBLE, dest,   1,
               u->data,          1, MPI_DOUBLE, source, 1, *u->comm, MPI_STATUS_IGNORE);
  if (source > -1)
    u->data[1] += u->data[0];

  u->data[0] = u->data[u->len-1] = 0.0;
}

Grid::Grid(Grid *Orig){
  int i;
  domainname = strdup(Orig->domainname);
  domainfile = Orig->domainfile;
  totverts   = Orig->totverts;

  xcoords = dvector(0, totverts-1);
  ycoords = dvector(0, totverts-1);
  zcoords = dvector(0, totverts-1);

  dcopy(totverts, Orig->xcoords, 1, xcoords, 1);
  dcopy(totverts, Orig->ycoords, 1, ycoords, 1);
  dcopy(totverts, Orig->zcoords, 1, zcoords, 1);

  nel = Orig->nel;
  nverts = ivector(0, nel-1);
  icopy(nel, Orig->nverts, 1, nverts, 1);

  vertids = imatrix(0, nel-1, 0, Max_Nverts-1);
  icopy(nel*Max_Nverts, Orig->vertids[0], 1, vertids[0], 1);

  elmtids = ivector(0, nel-1);
  icopy(nel, Orig->elmtids, 1, elmtids, 1);

  vertexmap = imatrix(0, nel-1, 0, Max_Nverts-1);
  icopy(nel*Max_Nverts, Orig->vertexmap[0], 1, vertexmap[0], 1);
}

void mtx_copy( Tmtx_ptr from, Tmtx_ptr to )
{
#ifdef DEBUG
	// check that the matrix we are copying from is initialised
	ASSERT_MSG( from->init, "mtx_copy() : attempt to copy from uninitialised matrix" );
#endif
	
	// initialise the target matrix
	if( to->init )
		mtx_free( to );
	mtx_init( to, from->nrows, from->ncols );
	
	// copy the data
	dcopy( from->nrows*from->ncols, from->dat, 1, to->dat, 1 );
	if( from->tau )
	{
		if( to->nrows>to->ncols )
		{
			to->tau = (double*)malloc( to->nrows*sizeof(double) );
			dcopy( from->nrows, from->tau, 1, to->tau, 1 );
		}
		else
		{
			to->tau = (double*)malloc( to->ncols*sizeof(double) );
			dcopy( from->ncols, from->tau, 1, to->tau, 1 );
		}
	}
}

void set_order_CNAB_adj(int Je)
{
	dcopy(3, Alpha_CNAB[Je-1], 1, Alpha_Int, 1);
	dcopy(3,  Beta_CNAB_adj[Je-1], 1,  Beta_Int, 1);
	Gamma_Int =  Gamma_CNAB[Je-1];
	if(Je == 3)
	{
		fprintf(stderr,"Need to set up appropriate adjoint weight for Je=3\n");
		exit(1);
	}
}

void offload_dGetVector(int n, double *x, int incx, double *y, int incy){
/*
 *  copy x at device to y at host
 *  incx is the index increment of x, incy is the index increment of y
 *  n elements are copied
 *  algorithm works for negative values of incx and incy, but gives undefined behavior
 */
//  assert(n >= 0);
  
    // copy x to DBUFFER, offload transfer out to DBUFFER, copy to y
    offload_Sync();
    int incB = 1;
    int start = 0;
    int end = start + BUFFERSIZE - 1;
        end = MIN(end, n - 1);
    int length = MIN(end - start + 1, BUFFERSIZE);
    int tlength;
    double *ystart = y + start*incy;
    double *tystart;
    intptr_t xptr = (intptr_t)x;

    offload_Sync();
    #pragma offload target(mic:MYDEVICE) out(DBUFFER:length(length) alloc_if(0) free_if(0)) \
                                         in(xptr,incx,length,incx,incB)
    {
        double *xstart = ((double*)xptr) + start*incx;
        dcopy(&length, xstart, &incx, DBUFFER, &incB);
    }
    start = end + 1;
    for(; start < n; start = end + 1){ 
        end = start + BUFFERSIZE - 1;
        end = MIN(end, n - 1);
        tlength = length; 
        length = MIN(end - start + 1, BUFFERSIZE);
        tystart = ystart;
        ystart = y + start*incy;
        #pragma offload target(mic:MYDEVICE) nocopy(DBUFFER:alloc_if(0) free_if(0)) \
                                             in(xptr,incx,length,incx,incB) signal(&WAIT)
        {
            double *xstart = ((double*)xptr) + start*incx;
            dcopy(&length, xstart, &incx, DBUFFER, &incB);
        }
        dcopy(&tlength, DBUFFER, &incB, tystart, &incy);
        #pragma offload_transfer target(mic:MYDEVICE) out(DBUFFER:length(length) alloc_if(0) free_if(0)) wait(&WAIT)
    }
    dcopy(&length, DBUFFER, &incB, ystart, &incy);
    SYNC = true;
}

/* compute the slope vector dy for the transient equation
 * dy + cy = p. useful in the transient solver
 */
void slope_fn_block(block_model_t *model, double *y, double *p, double *dy)
{
	/* shortcuts	*/
	int n = model->n_nodes;
	double **c = model->c;

	/* for our equation, dy = p - cy */
	#if (MATHACCEL == MA_INTEL || MATHACCEL == MA_APPLE)
	/* dy = p	*/
	cblas_dcopy(n, p, 1, dy, 1);
	/* dy = dy - c*y = p - c*y */
	cblas_dgemv(CblasRowMajor, CblasNoTrans, n, n, -1, c[0],
				n, y, 1, 1, dy, 1);
	#elif (MATHACCEL == MA_AMD || MATHACCEL == MA_SUN)
	/* dy = p	*/
	dcopy(n, p, 1, dy, 1);
	/* dy = dy - c*y = p - c*y */
	dgemv('T', n, n, -1, c[0], n, y, 1, 1, dy, 1);
	#else
	int i;
	double *t = dvector(n);
	matvectmult(t, c, y, n);
	for (i = 0; i < n; i++)
		dy[i] = p[i]-t[i];
	free_dvector(t);
	#endif
}

void Quad::fillvec(Mode *v, double *f){
  register int i;

  for(i = 0; i < qb; ++i)
    dcopy(qa,v->a,1,f+i*qa,1);
  for(i = 0; i < qa; ++i)
    dvmul(qb,v->b,1,f+i,qa,f+i,qa);
}

void dtransp(long m, long n, double *in, double *out)
{
  long i,j;
  j = 1;
  for (i=0; i<m; i++) {
    dcopy(&n, &in[i], &m, &out[i*n], &j);
  }
}

void collectMatrix(Matrix u)
{
#ifdef HAVE_MPI
  int source, dest;
  // south
  MPI_Cart_shift(*u->as_vec->comm, 1, -1, &source, &dest);
  MPI_Sendrecv(u->data[1]+1, u->rows-2, MPI_DOUBLE, dest, 0,
               u->data[u->cols-1]+1, u->rows-2, MPI_DOUBLE, source, 0,
               *u->as_vec->comm, MPI_STATUS_IGNORE);

  // north
  MPI_Cart_shift(*u->as_vec->comm, 1, 1, &source, &dest);
  MPI_Sendrecv(u->data[u->cols-2]+1, u->rows-2, MPI_DOUBLE, dest, 1,
               u->data[0]+1, u->rows-2, MPI_DOUBLE, source, 1,
               *u->as_vec->comm, MPI_STATUS_IGNORE);

  Vector sendBuf = createVector(u->cols-2);
  Vector recvBuf = createVector(u->cols-2);

  // west
  MPI_Cart_shift(*u->as_vec->comm, 0, -1, &source, &dest);
  if (dest != MPI_PROC_NULL)
    copyVectorDispl(sendBuf, u->row[1], u->cols-2, 1);
  MPI_Sendrecv(sendBuf->data, sendBuf->len, MPI_DOUBLE, dest, 2,
               recvBuf->data, recvBuf->len, MPI_DOUBLE, source, 2,
               *u->as_vec->comm, MPI_STATUS_IGNORE);
  if (source != MPI_PROC_NULL)
    dcopy(&recvBuf->len, recvBuf->data, &recvBuf->stride,
          u->row[u->rows-1]->data+u->rows, &u->rows);

  // east
  MPI_Cart_shift(*u->as_vec->comm, 0, 1, &source, &dest);
  if (dest != MPI_PROC_NULL)
    copyVectorDispl(sendBuf, u->row[u->rows-2], u->cols-2, 1);
  MPI_Sendrecv(sendBuf->data, sendBuf->len, MPI_DOUBLE, dest, 2,
               recvBuf->data, recvBuf->len, MPI_DOUBLE, source, 2,
               *u->as_vec->comm, MPI_STATUS_IGNORE);
  if (source != MPI_PROC_NULL)
    dcopy(&recvBuf->len, recvBuf->data, &recvBuf->stride,
          u->row[0]->data+u->rows, &u->rows);

  freeVector(sendBuf);
  freeVector(recvBuf);
#endif
}

bool rDenseMatrix::copyFrom(rDenseMatrix& other)
{
  if (this == &other) {
    return _SUCCESS;
  }
  int length;
  switch(other.De_Di) {
  case 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;
    if (de_ele==NULL) {
      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 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;
}

/* Assumes column-major */
void Matrix_RemoveRow(PT_Matrix pA, ptrdiff_t row)
{
/*  ASSERT(pA->rows > 0)*/

	dcopy(&(Matrix_Cols(pA)),
	       &(C_SEL(pA,Matrix_Rows(pA)-1,0)), &(pA->rows_alloc),
	       &(C_SEL(pA,row,0)), &(pA->rows_alloc));
	pA->rows = pA->rows - 1;
}

void    KNITRO_EXPORT  KTR_dcopy (const int             n,
                                  const double * const  x,
                                  const int             incx,
                                        double * const  y,
                                  const int             incy)
{
    dcopy (n, x, incx, y, incy);
    return;
}