自学教程：C++ vec_copy函数代码示例

void SMat<CoeffRing>::column2by2(size_t c1,                                 size_t c2,                                 elem a1,                                 elem a2,                                 elem b1,                                 elem b2)/* column(c1) <- a1 * column(c1) + a2 * column(c2),   column(c2) <- b1 * column(c1) + b2 * column(c2)*/{  // Make first column: v1 = a1*c1+a2*c2  sparsevec *v1 = vec_copy(columns_[c1]);  sparsevec *v2 = vec_copy(columns_[c2]);  vec_scale(v1, a1);  vec_scale(v2, a2);  vec_add_to(v1, v2);  // Second column: w1 = b1*c1 + b2*c2  sparsevec *w1 = columns_[c1];  sparsevec *w2 = columns_[c2];  vec_scale(w1, b1);  vec_scale(w2, b2);  vec_add_to(w1, w2);  // Set the matrices:  columns_[c1] = v1;  columns_[c2] = w1;}

// draw a line from a to bvoid POV3DisplayDevice::line(float *a, float*b) {  int i, j, test;  float dirvec[3], unitdirvec[3];  float from[3], to[3], tmp1[3], tmp2[3];  if (lineStyle == ::SOLIDLINE) {    // transform the world coordinates    (transMat.top()).multpoint3d(a, from);    (transMat.top()).multpoint3d(b, to);//    write_materials();    // Draw the line    fprintf(outfile, "VMD_line(<%.4f,%.4f,%.4f>,<%.4f,%.4f,%.4f>,",            from[0], from[1], -from[2], to[0], to[1], -to[2]);    fprintf(outfile, "rgbt<%.3f,%.3f,%.3f,%.3f>)/n",      matData[colorIndex][0], matData[colorIndex][1], matData[colorIndex][2],      1 - mat_opacity);  }   else if (lineStyle == ::DASHEDLINE) {    // transform the world coordinates    (transMat.top()).multpoint3d(a, tmp1);    (transMat.top()).multpoint3d(b, tmp2);    // how to create a dashed line    vec_sub(dirvec, tmp2, tmp1);  // vector from a to b    vec_copy(unitdirvec, dirvec);    vec_normalize(unitdirvec);    // unit vector from a to b    test = 1;    i = 0;    while (test == 1) {      for (j=0; j<3; j++) {        from[j] = (float) (tmp1[j] + (2*i)*DASH_LENGTH*unitdirvec[j]);        to[j] =   (float) (tmp1[j] + (2*i + 1)*DASH_LENGTH*unitdirvec[j]);      }      if (fabsf(tmp1[0] - to[0]) >= fabsf(dirvec[0])) {        vec_copy(to, tmp2);        test = 0;      }//      write_materials();      // Draw the line      fprintf(outfile, "VMD_line(<%.4f,%.4f,%.4f>,<%.4f,%.4f,%.4f>,",              from[0], from[1], -from[2], to[0], to[1], -to[2]);      fprintf(outfile, "rgbt<%.3f,%.3f,%.3f,%.3f>)/n",        matData[colorIndex][0], matData[colorIndex][1], matData[colorIndex][2],        1 - mat_opacity);      i++;    }  }   else {    msgErr << "POV3DisplayDevice: Unknown line style " << lineStyle << sendmsg;  }}

static void get_camera(vector eye, vector at, vector up){	vector x, y, z;	get_camera_frame(x, y, z);	vec_copy(at, center);	vec_copy(eye, center);	vec_mad(eye, focal_len, z);	vec_copy(up, y);}

void orthonormal_basis(const float b[9], float e[9]) {  float ob[3*3];  vec_copy(ob+0, b+0);  vec_copy(e+0, ob+0);  vec_normalize(e+0);  vec_triad(ob+3, b+3, -dot_prod(e+0, b+3), e+0);  vec_copy(e+3, ob+3);  vec_normalize(e+3);  vec_triad(ob+6,  b+6, -dot_prod(e+0, b+6), e+0);  vec_triad(ob+6, ob+6, -dot_prod(e+3, b+6), e+3);  vec_copy(e+6, ob+6);  vec_normalize(e+6);}

int MoleculeGraphics::add_line(const float *x1, const float *x2, int style, int width) {  ShapeClass s(LINE, 8, next_id);  float *data = s.data;  vec_copy(data+0, x1);  vec_copy(data+3, x2);  data[6] = float(style) + 0.1f;  data[7] = float(width) + 0.1f;  if (next_index < num_elements())    shapes[next_index] = s;  else    shapes.append(s);  return added();}

// draw a line (cylinder) from a to bvoid TachyonDisplayDevice::line(float *a, float*b) {  int i, j, test;  float dirvec[3], unitdirvec[3];  float from[3], to[3], tmp1[3], tmp2[3];      if (lineStyle == ::SOLIDLINE) {    // transform the world coordinates    (transMat.top()).multpoint3d(a, from);    (transMat.top()).multpoint3d(b, to);        // draw the cylinder    fprintf(outfile, "FCylinder/n"); // flat-ended cylinder    fprintf(outfile, "  Base %g %g %g/n", from[0], from[1], -from[2]);     fprintf(outfile, "  Apex %g %g %g/n", to[0], to[1], -to[2]);    fprintf(outfile, "  Rad %g /n", float(lineWidth)*DEFAULT_RADIUS);    write_cindexmaterial(colorIndex, materialIndex);  } else if (lineStyle == ::DASHEDLINE) {     // transform the world coordinates    (transMat.top()).multpoint3d(a, tmp1);    (transMat.top()).multpoint3d(b, tmp2);    // how to create a dashed line    vec_sub(dirvec, tmp2, tmp1);  // vector from a to b    vec_copy(unitdirvec, dirvec);    vec_normalize(unitdirvec);    // unit vector from a to b    test = 1;    i = 0;    while (test == 1) {      for (j=0; j<3; j++) {        from[j] = (float) (tmp1[j] + (2*i    )*DASH_LENGTH*unitdirvec[j]);          to[j] = (float) (tmp1[j] + (2*i + 1)*DASH_LENGTH*unitdirvec[j]);      }      if (fabsf(tmp1[0] - to[0]) >= fabsf(dirvec[0])) {        vec_copy(to, tmp2);        test = 0;      }          // draw the cylinder      fprintf(outfile, "FCylinder/n"); // flat-ended cylinder      fprintf(outfile, "  Base %g %g %g/n", from[0], from[1], -from[2]);       fprintf(outfile, "  Apex %g %g %g/n", to[0], to[1], -to[2]);      fprintf(outfile, "  Rad %g /n", float(lineWidth)*DEFAULT_RADIUS);      write_cindexmaterial(colorIndex, materialIndex);      i++;    }  } else {    msgErr << "TachyonDisplayDevice: Unknown line style "            << lineStyle << sendmsg;  }}

// draw a line from a to bvoid MayaDisplayDevice::line(float *a, float*b) {  int i, j, test;  float dirvec[3], unitdirvec[3];  float from[3], to[3], tmp1[3], tmp2[3];     if (lineStyle == ::SOLIDLINE) {    // transform the world coordinates    (transMat.top()).multpoint3d(a, from);    (transMat.top()).multpoint3d(b, to);    // draw the solid line    fprintf(outfile, "// XXX lines not supported yet/n");    fprintf(outfile, "// v %5f %5f %5f/n", from[0], from[1], -from[2]);    fprintf(outfile, "// v %5f %5f %5f/n", to[0], to[1], -to[2]);    fprintf(outfile, "// l -1 -2/n");  } else if (lineStyle == ::DASHEDLINE) {     // transform the world coordinates    (transMat.top()).multpoint3d(a, tmp1);    (transMat.top()).multpoint3d(b, tmp2);    // how to create a dashed line    vec_sub(dirvec, tmp2, tmp1);  // vector from a to b    vec_copy(unitdirvec, dirvec);    vec_normalize(unitdirvec);    // unit vector from a to b    test = 1;    i = 0;    while (test == 1) {      for (j=0; j<3; j++) {        from[j] = (float) (tmp1[j] + (2*i    )*DASH_LENGTH*unitdirvec[j]);          to[j] = (float) (tmp1[j] + (2*i + 1)*DASH_LENGTH*unitdirvec[j]);      }      if (fabsf(tmp1[0] - to[0]) >= fabsf(dirvec[0])) {        vec_copy(to, tmp2);        test = 0;      }      // draw the solid line dash      fprintf(outfile, "// XXX lines not supported yet/n");      fprintf(outfile, "// v %5f %5f %5f/n", from[0], from[1], -from[2]);      fprintf(outfile, "// v %5f %5f %5f/n", to[0], to[1], -to[2]);      fprintf(outfile, "// l -1 -2/n");      i++;    }  } else {    msgErr << "MayaDisplayDevice: Unknown line style "           << lineStyle << sendmsg;  }}

void SMat<CoeffRing>::vec_column_op(sparsevec *&v, const elem &a, sparsevec *w) const    // v := v + a*w{  sparsevec *w1 = vec_copy(w);  vec_scale(w1, a);  vec_add_to(v, w1);}

void CDanBattleSys::AutoMoveDanMember(){	int				userIdx;	int				zoneIdx;	typedef std::list<int>		TEAM_LIST;	typedef TEAM_LIST::iterator	TEAM_ITOR;	TEAM_ITOR	iLoop;	for (int TeamCount = 0; TeamCount < 2; TeamCount ++)	{			for (iLoop=m_BattleTeam[TeamCount].begin();iLoop!=m_BattleTeam[TeamCount].end();iLoop++)		{			userIdx=(*iLoop);									vec_copy( g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL +TeamCount].TargetPos, g_pc[userIdx].position );			zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, g_pc[userIdx].idx, g_pc[userIdx].worldIdx, g_pc[userIdx].zoneIdx, g_pc[userIdx].position);			g_pc[userIdx].zoneIdx = zoneIdx;						GTH_SendPCEventMessage_Respawn( &g_pc[userIdx] );			GTH_SendMessage_SyncItemObject( &g_pc[userIdx] );												}	}}

GRAPH *CopyGraph(GRAPH *graph){    GRAPH *ret;    struct _keyed *k;    struct dveclist *link, *newlink;    ret = NewGraph();    bcopy(graph, ret, sizeof(GRAPH)); /* va: compatible pointer types */    ret->graphid = RunningId - 1;   /* restore id */    /* copy keyed */    for (ret->keyed = NULL, k = graph->keyed; k; k = k->next)        SaveText(ret, k->text, k->x, k->y);    /* copy dvecs */    ret->plotdata = NULL;    for (link = graph->plotdata; link; link = link->next) {        newlink = TMALLOC(struct dveclist, 1);        newlink->next = ret->plotdata;        newlink->vector = vec_copy(link->vector);        /* vec_copy doesn't set v_color or v_linestyle */        newlink->vector->v_color = link->vector->v_color;        newlink->vector->v_linestyle = link->vector->v_linestyle;        newlink->vector->v_flags |= VF_PERMANENT;        ret->plotdata = newlink;    }    ret->commandline = copy(graph->commandline);    ret->plotname = copy(graph->plotname);    return (ret);}

/* add_particle() inserts a particle at a given position to the end of the  * frame, along with associated targets. *  * Arguments: * frame *frm - the frame to store the particle. * vec3d pos - position of inserted particle in the global coordinates. * int cand_inds[][MAX_CANDS] - indices of candidate targets for association *    with this particle. */void add_particle(frame *frm, vec3d pos, int cand_inds[][MAX_CANDS]) {    int num_parts, cam, _ix;    P *ref_path_inf;    corres *ref_corres;    target **ref_targets;        num_parts = frm->num_parts;    ref_path_inf = &(frm->path_info[num_parts]);    vec_copy(ref_path_inf->x, pos);    reset_links(ref_path_inf);        ref_corres = &(frm->correspond[num_parts]);    ref_targets = frm->targets;    for (cam = 0; cam < frm->num_cams; cam++) {        ref_corres->p[cam] = CORRES_NONE;                /* We always take the 1st candidate, apparently. Why did we fetch 4? */        if(cand_inds[cam][0] != PT_UNUSED) {            _ix = cand_inds[cam][0];            ref_targets[cam][_ix].tnr = num_parts;            ref_corres->p[cam] = _ix;            ref_corres->nr = num_parts;        }    }    frm->num_parts++;}

// draw a pointvoid X3DDisplayDevice::point(float * xyz) {  float txyz[3];  // transform the coordinates  (transMat.top()).multpoint3d(xyz, txyz);  // ugly and wasteful, but it will work  fprintf(outfile, "<Shape>/n");  fprintf(outfile, "  ");  // Emit the point material properties  fprintf(outfile, "<Appearance><Material ");  fprintf(outfile, "ambientIntensity='%g' ", mat_ambient);  fprintf(outfile, "diffuseColor='0 0 0' ");  const float *rgb = matData[colorIndex];  fprintf(outfile, "emissiveColor='%g %g %g' ",          mat_diffuse * rgb[0], mat_diffuse * rgb[1], mat_diffuse * rgb[2]);  fprintf(outfile, "/>");  fprintf(outfile, "</Appearance>/n");  fprintf(outfile, "  <PointSet>/n");  fprintf(outfile, "    <Coordinate point='%g %g %g'/>/n",          txyz[0], txyz[1], txyz[2]);    float col[3];  vec_copy(col, matData[colorIndex]);  fprintf(outfile, "    <Color color='%g %g %g'/>/n",           col[0], col[1], col[2]);  fprintf(outfile, "  </PointSet>/n");  fprintf(outfile, "</Shape>/n");}

void hotcold_gradient_lerp(float pucker_sum, float *rgb) {  vec_zero(rgb); // set default color to black  // hot to cold color map  // Red (1, 0, 0) -> Yellow (1, 1, 0) -> Green (0, 1, 0) -> Cyan (0, 1, 1) -> blue (0, 0, 1)  float     red[3] = {1.0f, 0.0f, 0.0f};  float  yellow[3] = {1.0f, 1.0f, 0.0f};  float yellow2[3] = {0.8f, 1.0f, 0.0f};  float   green[3] = {0.0f, 1.0f, 0.0f};  float  green2[3] = {0.6f, 1.0f, 0.0f};  float    cyan[3] = {0.0f, 1.0f, 1.0f};  float   cyan2[3] = {0.0f, 1.0f, 0.8f};  float    blue[3] = {0.0f, 0.0f, 1.0f};  if (pucker_sum < 0.25f) {    lerp_color_range(rgb, pucker_sum, 0.00f, 0.25f, red, yellow);  } else if (pucker_sum < 0.45f) {    vec_copy(rgb, yellow);  } else if (pucker_sum < 0.55f) {    lerp_color_range(rgb, pucker_sum, 0.45f, 0.55f, yellow, green2);  } else if (pucker_sum < 0.75f) {    lerp_color_range(rgb, pucker_sum, 0.55f, 0.75f, green, cyan2);  } else {    lerp_color_range(rgb, pucker_sum, 0.75f, 1.00f, cyan, blue);  }  clamp_color(rgb); // clamp color values to legal range}

// Calculates the position at point t along the spline with co-efficients// A, B, C and D.// spline(t) = ((A * t + B) * t + C) * t + Dvoid ribbon_spline(float *pos, const float * const A, const float * const B,                   const float * const C, const float * const D, const float t) {  vec_copy(pos,D);  vec_scaled_add(pos,t,C);  vec_scaled_add(pos,t*t,B);  vec_scaled_add(pos,t*t*t,A);}

VrArrayPtrCF32 BlasComplexSingle::transpose(VrArrayPtrCF32 A) {	 VrArrayPtrCF32 B;	 int dims[2];	 if(VR_GET_DIMS_CF32(A)[0]==1 || VR_GET_DIMS_CF32(A)[1]==1) {	 	      B=vec_copy(VR_GET_NDIMS_CF32(A),A);	      dim_type temp= VR_GET_DIMS_CF32(B)[0];	      VR_GET_DIMS_CF32(B)[0] =VR_GET_DIMS_CF32(B)[1];	      VR_GET_DIMS_CF32(B)[1] = temp;	      return B;	 }	 dims[1]=VR_GET_DIMS_CF32(A)[0];	 dims[0]=VR_GET_DIMS_CF32(A)[1];	 B= vrAllocArrayF32CM(2,0,dims);	 int row= VR_GET_DIMS_CF32(A)[0];	 int col= VR_GET_DIMS_CF32(A)[1];	 float complex *out =VR_GET_DATA_CF32(B);	 float complex *in =VR_GET_DATA_CF32(A);	 for(int i=0;i<row;i++){	   for(int j=0;j<col;j++) {	   	     out[i*col+j] = conj(in[j*row +i]);	  }	  	 }	return B;}

folge_pfolge_copy( folge_p f) {	folge_p  back;	int  k, size;	vec_p  start, lang;	start = vec_copy( f->start );	lang = vec_copy( f->lang );	size = vec_size( lang );	back = folge_new( start, lang );	for(k=0;k<size;k++) {		back->glied[k] = f->glied[k];	}	return back;}

void CHelperManager_Encoder::PC_SetSummonsInfo(	playerCharacter_t *pHelper, char *name, int worldIdx, vec3_t position){	strcpy(pHelper->summonsInfo.summoner, name);	pHelper->summonsInfo.worldIdx = worldIdx;	vec_copy(position, pHelper->summonsInfo.position);	}

static voidgr_start_internal(struct dvec *dv, bool copyvec){    struct dveclist *link;    /* Do something special with poles and zeros.  Poles are 'x's, and     * zeros are 'o's.  */    if (dv->v_type == SV_POLE) {        dv->v_linestyle = 'x';        return;    } else if (dv->v_type == SV_ZERO) {        dv->v_linestyle = 'o';        return;    }    /* Find a (hopefully) new line style and color. */    if (currentgraph->plottype == PLOT_POINT) {        if (pointchars[cur.linestyle - 1])            cur.linestyle++;        else            cur.linestyle = 2;    } else if ((cur.linestyle > 0) && (++cur.linestyle == dispdev->numlinestyles)) {        cur.linestyle = 2;    }    if ((cur.color > 0) && (++cur.color == dispdev->numcolors))        cur.color = (((currentgraph->grid.gridtype == GRID_SMITH ||                      currentgraph->grid.gridtype == GRID_SMITHGRID) &&                     (dispdev->numcolors > 3)) ? 4 : 2);    if (currentgraph->plottype == PLOT_POINT)        dv->v_linestyle = pointchars[cur.linestyle - 2];    else        dv->v_linestyle = cur.linestyle;    dv->v_color = cur.color;    /* save the data so we can refresh */    link = TMALLOC(struct dveclist, 1);    link->next = currentgraph->plotdata;    if (copyvec) {        link->vector = vec_copy(dv);        /* vec_copy doesn't set v_color or v_linestyle */        link->vector->v_color = dv->v_color;        link->vector->v_linestyle = dv->v_linestyle;        link->vector->v_flags |= VF_PERMANENT;    } else {        link->vector = dv;    }    currentgraph->plotdata = link;    /* Put the legend entry on the screen. */    drawlegend(currentgraph, cur.plotno, dv);    cur.plotno++;}

END_TESTSTART_TEST(test_vec_copy){    vec3d src = {1., 2., 3.}, dst;    vec_copy(dst, src);    fail_unless(vec_cmp(dst, src));}

VrArrayPtrCF64 BlasComplexDouble::mat_ldiv(int matrix_order ,VrArrayPtrCF64 A, VrArrayPtrCF64 B) {    VrArrayPtrCF64 C = vec_copy(VR_GET_NDIMS_CF64(B),B);   VrArrayPtrCF64 D = vec_copy(VR_GET_NDIMS_CF64(A),A);   double complex* data= VR_GET_DATA_CF64(D);   double complex * out_data=VR_GET_DATA_CF64(C);   long int lda=(long int)VR_GET_DIMS_CF64(D)[0];   long int ldb= (long int)VR_GET_DIMS_CF64(C)[0];   long int n=(long int )VR_GET_DIMS_CF64(D)[1];   long int nrhs= (long int )VR_GET_DIMS_CF64(C)[1];  int  *IPIV=(int*)VR_MALLOC(sizeof(int)*n);  long int info=0;   // dgesv_(&n,&nrhs,data,&lda,IPIV,out_data,&ldb,&info);    info= LAPACKE_zgesv(LAPACK_COL_MAJOR,n,nrhs,data,lda,IPIV,out_data,ldb);   return C; }

folgen_vektor_pfolgen_vektor_projekt(folgen_vektor_p f,folgen_vektor_p g) {	folgen_vektor_p  back;	int  k, size_g, test, dim, d, i;	vec_p  grad, r, n_f, n_g, start, lang, vec_1;	ASSERT( f->grad->dim == g->grad->dim );	dim = f->grad->dim;	vec_1 = vec_one( dim );	n_g = vec_add( g->grad, vec_1 );	n_f = vec_add( f->grad, vec_1 );	size_g = vec_size( n_g );	grad = vec_copy( g->grad );	back = folgen_vektor_new( grad );	for(k=0;k<size_g;k++) {		r = entry_one2d( k, n_g );		test = 0;		for(d=0;d<dim;d++) {			if( r->array[d] > f->grad->array[d] ) {				test = test + 1;			}		}		if(test == 0) {			i = entry_d2one( r, n_f );			folge_del( back->vektor[k] );			back->vektor[k] = folge_projekt( f->vektor[i], g->vektor[k] );		}		else {			folge_del( back->vektor[k] );			start = vec_copy( g->vektor[k]->start );			lang = vec_copy( g->vektor[k]->lang );			back->vektor[k] = folge_new( start, lang );		}		vec_del( r );	}	vec_del( vec_1 );	vec_del( n_g );	vec_del( n_f );	return back;}

VrArrayPtrCF32 BlasComplexSingle::elem_mult(VrArrayPtrCF32 A, VrArrayPtrCF32 B) {  if ( !checkdims<VrArrayCF32>(A,B) ) {    std::cout<<"dimensions do not match. /n Exiting. "<<std::endl;    exit(0);  }  VrArrayPtrCF32 C = vec_copy(VR_GET_NDIMS_CF32(A),A);  for (int i = 0; i < getNumElem(VR_GET_DIMS_CF32(A),VR_GET_NDIMS_CF32(A)); i++) {    VR_GET_DATA_CF32(C)[i] *= VR_GET_DATA_CF32(B)[i];  }  return C;}

VrArrayPtrCF32 BlasComplexSingle::scal_mult(int ndims,VrArrayPtrCF32 X,float complex alpha) {        int N=1;        for(int i=0;i<ndims;i++){                N*=VR_GET_DIMS_CF32(X)[i];        }	VrArrayPtrCF32 Y;//=(VrArrayPtrCF32)mxMalloc(sizeof(VrArrayPtrCF32));	Y=vec_copy(ndims,X);	//mxDuplicateArray(X);        cblas_cscal(N,reinterpret_cast<float*>(&alpha),(float*)VR_GET_DATA_CF32(Y),1);	return Y;}

VrArrayPtrCF64 BlasComplexDouble::scal_mult(int ndims,VrArrayPtrCF64 X,double complex alpha){        int N=1;        for(int i=0;i<ndims;i++){                N*=VR_GET_DIMS_CF64(X)[i];        }	//mexPrintf("%d",N);	double alph[] = {1,0};	VrArrayPtrCF64 Y=vec_copy(ndims,X);    cblas_zscal(N,(alph),(double*)VR_GET_DATA_CF64(Y),1);	return Y;}

VrArrayPtrCF32 BlasComplexSingle::vec_sub(int ndims, VrArrayPtrCF32 X, VrArrayPtrCF32 Y , const float complex alpha, const int incX, const int incY) {        VrArrayPtrCF32 X1 =vec_copy(VR_GET_NDIMS_CF32(X),X);        /*if(cimag(alpha)!=1){                VrArrayPtrCF32 X1=vrAllocArrayF32CM(ndims,0,(int*)VR_GET_DIMS_CF32(X));                X1=BlasComplexSingle::scal_mult(ndims,X,alpha);        }*/	//float arr[]={-1,0};  	float complex arr = -1 ;         return vec_add(ndims, Y,X1, arr);}

VrArrayPtrCF32 BlasComplexSingle::mat_ldiv(int matrix_order, VrArrayPtrCF32 A, VrArrayPtrCF32 B) {VrArrayPtrCF32 C = vec_copy(VR_GET_NDIMS_CF32(B),B);   VrArrayPtrCF32 D = vec_copy(VR_GET_NDIMS_CF32(A),A);   float complex * data= VR_GET_DATA_CF32(D);   float complex * out_data=VR_GET_DATA_CF32(C);   long int lda=(long int)VR_GET_DIMS_CF32(D)[0];   long int ldb= (long int)VR_GET_DIMS_CF32(C)[0];   long int n=(long int )VR_GET_DIMS_CF32(D)[1];   long int nrhs= (long int )VR_GET_DIMS_CF32(C)[1];  int  *IPIV=(int*)VR_MALLOC(sizeof(int)*n);  long int info=0;      info= LAPACKE_cgesv(LAPACK_COL_MAJOR,n,nrhs,data,lda,IPIV,out_data,ldb);           return C;  }

void set_destination(double *v){	int i;	double dif[MAX_DIM];	vec_copy(origin, position);	vec_copy(destination, v);	tim = 0.0;	delta_t = feedrate_begin;	dist = vec_dist(position, v);	if(dist == 0.0) {		vec_clear(incvec);		for(i = 0; i < MAX_DIM; i++)			amp[i] = amplitude_dc;		return;	}	vec_diff(dif, v, origin);	for(i = 0; i < MAX_DIM; i++)		incvec[i] = dif[i] / dist;	calc_amplitude();}