int
gsl_sf_complex_psi_e(
const double x,
const double y,
gsl_sf_result * result_re,
gsl_sf_result * result_im
)
{
if(x >= 0.0)
{
gsl_complex z = gsl_complex_rect(x, y);
return psi_complex_rhp(z, result_re, result_im);
}
else
{
/* reflection formula [Abramowitz+Stegun, 6.3.7] */
gsl_complex z = gsl_complex_rect(x, y);
gsl_complex omz = gsl_complex_rect(1.0 - x, -y);
gsl_complex zpi = gsl_complex_mul_real(z, M_PI);
gsl_complex cotzpi = gsl_complex_cot(zpi);
int ret_val = psi_complex_rhp(omz, result_re, result_im);
if(GSL_IS_REAL(GSL_REAL(cotzpi)) && GSL_IS_REAL(GSL_IMAG(cotzpi)))
{
result_re->val -= M_PI * GSL_REAL(cotzpi);
result_im->val -= M_PI * GSL_IMAG(cotzpi);
return ret_val;
}
else
{
GSL_ERROR("singularity", GSL_EDOM);
}
}
}
void expm(gsl_matrix_complex * L, gsl_complex t, gsl_matrix * m)
{
int i,j,s;
gsl_vector_complex *eval = gsl_vector_complex_alloc(4);
gsl_matrix_complex *evec = gsl_matrix_complex_alloc(4, 4);
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(4);
gsl_matrix_complex *evalmat = gsl_matrix_complex_alloc(4, 4);
gsl_matrix_complex *vd = gsl_matrix_complex_alloc(4, 4);
gsl_complex one = gsl_complex_rect(1, 0);
gsl_complex zero = gsl_complex_rect(0, 0);
gsl_matrix_complex *K = gsl_matrix_complex_alloc(4, 4);
gsl_permutation *p = gsl_permutation_alloc(4);
gsl_vector_complex *x = gsl_vector_complex_alloc(4);
gsl_vector_complex_view bp;
gsl_complex z;
gsl_eigen_nonsymmv(m, eval, evec, w);
gsl_eigen_nonsymmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
gsl_eigen_nonsymmv_free(w); // clear workspace
for (i = 0; i < 4; i++)
{
gsl_complex eval_i = gsl_vector_complex_get(eval, i);
gsl_complex expeval = gsl_complex_mul(eval_i,t);
expeval = gsl_complex_exp(expeval);
gsl_matrix_complex_set(evalmat, i, i, expeval);
}
gsl_vector_complex_free(eval); // clear vector for eigenvalues
// v'L'=De'v'
gsl_blas_zgemm(CblasTrans, CblasTrans, one, evalmat, evec, zero, vd);
gsl_matrix_complex_transpose(evec);//transpose v
gsl_matrix_complex_memcpy(K,evec);
for (i = 0; i < 4; i++)
{
bp = gsl_matrix_complex_column(vd, i);
gsl_linalg_complex_LU_decomp(evec, p, &s);
gsl_linalg_complex_LU_solve(evec, p, &bp.vector, x);
for (j = 0; j < 4; j++)
{
z = gsl_vector_complex_get(x, j);
gsl_matrix_complex_set(L,i,j,z); //'through the looking glass' transpose
}
gsl_matrix_complex_memcpy(evec,K);
}
gsl_permutation_free(p);
gsl_vector_complex_free(x);
gsl_matrix_complex_free(vd);
gsl_matrix_complex_free(evec);
gsl_matrix_complex_free(evalmat);
gsl_matrix_complex_free(K);
}
gsl_complex
gsl_linalg_complex_LU_sgndet (gsl_matrix_complex * LU, int signum)
{
size_t i, n = LU->size1;
gsl_complex phase = gsl_complex_rect((double) signum, 0.0);
for (i = 0; i < n; i++)
{
gsl_complex z = gsl_matrix_complex_get (LU, i, i);
double r = gsl_complex_abs(z);
if (r == 0)
{
phase = gsl_complex_rect(0.0, 0.0);
break;
}
else
{
z = gsl_complex_div_real(z, r);
phase = gsl_complex_mul(phase, z);
}
}
return phase;
}
/*
* FUNCTION
* Name: entropy_of_state
* Description: Calculate the Von Neumann entropy of state 'rho'
*
*/
double entropy_of_state ( const gsl_vector* rho )
{
double entr = 0 ;
/* Finding the eigenvalues */
gsl_eigen_herm_workspace* rho_ei = gsl_eigen_herm_alloc(2);
gsl_matrix_complex* dens = gsl_matrix_complex_calloc (2,2);
gsl_matrix_complex_set (dens, 0, 0, gsl_complex_rect(1+VECTOR(rho, 3),0));
gsl_matrix_complex_set (dens,0,1,gsl_complex_rect(VECTOR(rho,1),-VECTOR(rho,2)));
gsl_matrix_complex_set (dens,1,0,gsl_complex_rect(VECTOR(rho,1),VECTOR(rho,2)));
gsl_matrix_complex_set (dens,1,1,gsl_complex_rect(1-VECTOR(rho,3),0));
gsl_matrix_complex_scale (dens, gsl_complex_rect(0.5,0));
gsl_vector* eigenvalues = gsl_vector_calloc(2) ;
gsl_eigen_herm (dens, eigenvalues, rho_ei) ;
/* Calculating entropy */
double norm = gsl_hypot3( VECTOR(rho,1), VECTOR(rho,2), VECTOR(rho,3) ) ;
if ( gsl_fcmp(norm, 1, 1e-9) > 0 )
entr = 0 ;
else
entr = - (VECTOR(eigenvalues,0)*gsl_sf_log(VECTOR(eigenvalues,0)) +
VECTOR(eigenvalues,1)*gsl_sf_log(VECTOR(eigenvalues,1))) ;
return (entr);
} /* ----- end of function entropy_of_state ----- */
void Calculator::setMatrixP(gsl_matrix_complex * m, double p, double q)
{
/*set matrix P (Markov probabilities)*/
gsl_matrix_complex_set(m, 0, 0, gsl_complex_rect (p, 0.0));
gsl_matrix_complex_set(m, 0, 1, gsl_complex_rect (q, 0.0));
gsl_matrix_complex_set(m, 1, 0, gsl_complex_rect (1.0 - p, 0.0));
gsl_matrix_complex_set(m, 1, 1, gsl_complex_rect (1.0 - q, 0.0));
/* DEBUG
printf("P:\n");
gsl_matrix_complex_fprintf (stdout, P, "%g");
*/
}
void
qpb_sun_project(qpb_link *u, int n)
{
gsl_eigen_hermv_workspace *gsl_work = gsl_eigen_hermv_alloc(NC);
gsl_matrix_complex *B = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *A = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *V = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *U = gsl_matrix_complex_alloc(NC, NC);
gsl_matrix_complex *D = gsl_matrix_complex_alloc(NC, NC);
gsl_vector *S = gsl_vector_alloc(NC);
gsl_permutation *perm = gsl_permutation_alloc(NC);
for(int k=0; k<n; k++){
qpb_complex *a = (qpb_complex *)(u + k);
for(int i=0; i<NC; i++)
for(int j=0; j<NC; j++)
gsl_matrix_complex_set(A, i, j, gsl_complex_rect(a[j + i*NC].re, a[j + i*NC].im));
gsl_matrix_complex_memcpy(U, A);
int sgn;
gsl_linalg_complex_LU_decomp(U, perm, &sgn);
gsl_complex det_A = gsl_linalg_complex_LU_det(U, sgn);
qpb_double phi = gsl_complex_arg(det_A);
gsl_complex one = gsl_complex_rect(1., 0.);
gsl_complex zero = gsl_complex_rect(0., 0.);
gsl_matrix_complex_memcpy(U, A);
svd(U, V, S);
get_theta_matrix(D, S, phi);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, one, U, D, zero, B);
gsl_blas_zgemm(CblasNoTrans, CblasConjTrans, one, B, V, zero, A);
for(int i=0; i<NC; i++)
for(int j=0; j<NC; j++){
a[j + i*NC].re = GSL_REAL(gsl_matrix_complex_get(A, i, j));
a[j + i*NC].im = GSL_IMAG(gsl_matrix_complex_get(A, i, j));
}
}
gsl_matrix_complex_free(A);
gsl_matrix_complex_free(B);
gsl_matrix_complex_free(V);
gsl_matrix_complex_free(U);
gsl_matrix_complex_free(D);
gsl_permutation_free(perm);
gsl_vector_free(S);
gsl_eigen_hermv_free(gsl_work);
return;
}
void define_contour_V(const Params *params,
double t,
Contour *contour)
{
memset(contour, 0, sizeof(*contour));
double Pr = params->Pr;
double Pi = params->Pi;
double peps = params->peps;
contour->npoints = 4;
if (t < 0.5)
{
contour->points[0] = gsl_complex_rect(-Pr, Pi*2*t);
contour->points[1] = gsl_complex_rect(-peps, params->m - peps);
contour->points[2] = gsl_complex_rect(+peps, params->m - peps);
contour->points[3] = gsl_complex_rect(+Pr, Pi*2*t);
}
else
{
contour->points[0] = gsl_complex_rect(-Pr+(2*t - 1.0)*(Pr-peps), Pi);
contour->points[1] = gsl_complex_rect(-peps, params->m - peps);
contour->points[2] = gsl_complex_rect(+peps, params->m - peps);
contour->points[3] = gsl_complex_rect(+Pr-(2*t - 1.0)*(Pr-peps), Pi);
}
}
int incmat(gsl_matrix_complex * ILa, double na, double cphia)
{
gsl_complex zb[8];
zb[0] = gsl_complex_rect(0.5,0);
zb[1] = gsl_complex_rect(1/(2*na*cphia),0);
zb[2] = gsl_complex_rect(0.5,0);
zb[3] = gsl_complex_rect(-1/(2*na*cphia),0);
zb[4] = gsl_complex_rect(1/(2*cphia),0);
zb[5] = gsl_complex_rect(1/(2*na),0);
zb[6] = gsl_complex_rect(-1/(2*cphia),0);
zb[7] = gsl_complex_rect(1/(2*na),0);
gsl_matrix_complex_set_zero(ILa);
gsl_matrix_complex_set(ILa,0,2,zb[0]);
gsl_matrix_complex_set(ILa,0,3,zb[1]);
gsl_matrix_complex_set(ILa,1,2,zb[2]);
gsl_matrix_complex_set(ILa,1,3,zb[3]);
gsl_matrix_complex_set(ILa,2,0,zb[4]);
gsl_matrix_complex_set(ILa,2,1,zb[5]);
gsl_matrix_complex_set(ILa,3,0,zb[6]);
gsl_matrix_complex_set(ILa,3,1,zb[7]);
return 1;
}
void gtmiso(gsl_matrix_complex * Tiso, gsl_complex eiso, double k0, double eta, double diso)
{
double eta2 = pow(eta,2);
gsl_complex rb = gsl_complex_rect(eta2,0);
gsl_complex za = gsl_complex_sub_real(eiso,eta2);
gsl_complex qiso = gsl_complex_sqrt(za);
gsl_complex zb = gsl_complex_mul_real(qiso,k0);
gsl_complex zc = gsl_complex_mul_real(zb,diso);
gsl_complex zd = gsl_complex_div(rb,eiso);
gsl_complex carg = gsl_complex_cos(zc);
gsl_complex sarg = gsl_complex_sin(zc);
gsl_complex i = gsl_complex_rect(0,1);
gsl_complex one = gsl_complex_rect(1,0);
gsl_matrix_complex_set_zero(Tiso);
gsl_matrix_complex_set(Tiso,0,0,carg);
gsl_matrix_complex_set(Tiso,1,1,carg);
gsl_matrix_complex_set(Tiso,2,2,carg);
gsl_matrix_complex_set(Tiso,3,3,carg);
gsl_complex zd1 = gsl_complex_sub(one,zd);
gsl_complex zd2 = eiso;
gsl_complex zd3 = one;
gsl_complex zd4 = gsl_complex_sub_real(eiso,eta2);
gsl_complex zmult1 = gsl_complex_mul(zd1,i);
gsl_complex zmult2 = gsl_complex_mul(zd2,i);
gsl_complex zmult3 = gsl_complex_mul(zd3,i);
gsl_complex zmult4 = gsl_complex_mul(zd4,i);
gsl_complex zdiv1 = gsl_complex_div(zmult1,qiso);
gsl_complex zdiv2 = gsl_complex_div(zmult2,qiso);
gsl_complex zdiv3 = gsl_complex_div(zmult3,qiso);
gsl_complex zdiv4 = gsl_complex_div(zmult4,qiso);
gsl_complex zmult5 = gsl_complex_mul(zdiv1,sarg);
gsl_complex zmult6 = gsl_complex_mul(zdiv2,sarg);
gsl_complex zmult7 = gsl_complex_mul(zdiv3,sarg);
gsl_complex zmult8 = gsl_complex_mul(zdiv4,sarg);
gsl_matrix_complex_set(Tiso,0,1,zmult5);
gsl_matrix_complex_set(Tiso,1,0,zmult6);
gsl_matrix_complex_set(Tiso,2,3,zmult7);
gsl_matrix_complex_set(Tiso,3,2,zmult8);
}
std::unique_ptr<gsl_matrix_complex,void (*)(gsl_matrix_complex*)> Const::GetTransformationMatrix(size_t dim) const{
if(dim>SQUIDS_MAX_HILBERT_DIM)
throw std::runtime_error("Const::GetTransformationMatrix: dimension must be less than " SQUIDS_MAX_HILBERT_DIM_STR);
gsl_matrix_complex* U = gsl_matrix_complex_alloc(dim,dim);
gsl_matrix_complex* R = gsl_matrix_complex_alloc(dim,dim);
gsl_matrix_complex* dummy = gsl_matrix_complex_alloc(dim,dim);
gsl_matrix_complex_set_identity(U);
gsl_matrix_complex_set_identity(R);
gsl_matrix_complex_set_zero(dummy);
const auto unit=gsl_complex_rect(1,0);
const auto zero=gsl_complex_rect(0,0);
auto to_gsl=[](const std::complex<double>& c)->gsl_complex{
return(gsl_complex_rect(c.real(),c.imag()));
};
//construct each subspace rotation and accumulate the product
for(size_t j=1; j<dim; j++){
for(size_t i=0; i<j; i++){
//set up the subspace rotation
double theta=GetMixingAngle(i,j);
double delta=GetPhase(i,j);
double c=cos(theta);
auto cp=sin(theta)*std::exp(std::complex<double>(0,-delta));
auto cpc=-std::conj(cp);
gsl_matrix_complex_set(R,i,i,to_gsl(c));
gsl_matrix_complex_set(R,i,j,to_gsl(cp));
gsl_matrix_complex_set(R,j,i,to_gsl(cpc));
gsl_matrix_complex_set(R,j,j,to_gsl(c));
//multiply this rotation onto the product from the left
gsl_blas_zgemm(CblasNoTrans,CblasNoTrans,unit,R,U,zero,dummy);
std::swap(U,dummy);
//clean up the rotation matrix for next iteration
gsl_matrix_complex_set(R,i,i,unit);
gsl_matrix_complex_set(R,i,j,zero);
gsl_matrix_complex_set(R,j,i,zero);
gsl_matrix_complex_set(R,j,j,unit);
}
}
//clean up temporary matrices
gsl_matrix_complex_free(R);
gsl_matrix_complex_free(dummy);
return std::unique_ptr<gsl_matrix_complex,void (*)(gsl_matrix_complex*)>(U,gsl_matrix_complex_free);
}
void CPMPChan::Run() {
/// fetch data objects
gsl_vector_complex invec = vin1.GetDataObj();
gsl_matrix_complex cmat = min2.GetDataObj();
//
//
gsl_vector_complex *tmp = gsl_vector_complex_alloc(N());
//
//
// extract the user channel matrix
//
//
for (int i=0; i<N(); i++) {
gsl_complex h = gsl_matrix_complex_get(&cmat,Cd(),(N()-i)%N());
for (int j=0; j<N(); j++) {
gsl_matrix_complex_set(user_chan,j,(j+i) % N(),h);
}
}
// cout << "User " << Cd() << " channel:" << endl;
// gsl_matrix_complex_show(user_chan);
//
//
// compute the output vector
//
//
gsl_blas_zgemv(CblasNoTrans,
gsl_complex_rect(1.0,0),
user_chan,
&invec,
gsl_complex_rect(0,0),
tmp);
// cout << "User " << Cd() << " trasmitted vector:" << endl;
// gsl_vector_complex_fprintf(stdout,&invec,"%f");
// cout << "User " << Cd() << " received vector:" << endl;
// gsl_vector_complex_fprintf(stdout,tmp,"%f");
//////// production of data
vout1.DeliverDataObj( *tmp );
}
int extmat(gsl_matrix_complex * Lf, double nf, gsl_complex cphif)
{
gsl_matrix_complex_set_zero(Lf);
gsl_complex znf = gsl_complex_rect(nf,0);
gsl_complex zk = gsl_complex_mul(znf,cphif);
gsl_complex one = gsl_complex_rect(1,0);
gsl_matrix_complex_set(Lf,0,2,cphif);
gsl_matrix_complex_set(Lf,1,2,znf);
gsl_matrix_complex_set(Lf,2,0,one);
gsl_matrix_complex_set(Lf,3,0,zk);
return 1;
}
static int _equalf(CMATRIX *a, double f)
{
bool result;
if (COMPLEX(a))
{
if (f == 0.0)
return gsl_matrix_complex_isnull(CMAT(a));
gsl_matrix_complex *m = gsl_matrix_complex_alloc(WIDTH(a), HEIGHT(a));
gsl_matrix_complex_set_identity(m);
gsl_matrix_complex_scale(m, gsl_complex_rect(f, 0));
result = gsl_matrix_complex_equal(CMAT(a), m);
gsl_matrix_complex_free(m);
}
else
{
if (f == 0.0)
return gsl_matrix_isnull(MAT(a));
gsl_matrix *m = gsl_matrix_alloc(WIDTH(a), HEIGHT(a));
gsl_matrix_set_identity(m);
gsl_matrix_scale(m, f);
result = gsl_matrix_equal(MAT(a), m);
gsl_matrix_free(m);
}
return result;
}
void define_contour_II(const Params *params,
double d,
Contour *contour)
{
memset(contour, 0, sizeof(*contour));
double Pr = params->Pr;
double Pi = params->Pi;
contour->npoints = 4;
contour->points[0] = gsl_complex_rect(-Pr, d);
contour->points[1] = gsl_complex_rect(-Pr, Pi);
contour->points[2] = gsl_complex_rect(+Pr, Pi);
contour->points[3] = gsl_complex_rect(+Pr, d);
contour->skip[1] = 1;
}
gsl_complex theta20(gsl_complex q, gsl_complex q14)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.0,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = q2;
gsl_complex qpower = gsl_complex_rect(1.0,0.0);
while ((gsl_complex_abs(qpower) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
accum = gsl_complex_add(accum, qpower);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(gsl_complex_mul(q14,accum),2.0);
}
gsl_complex theta40(gsl_complex q)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.5,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = gsl_complex_negative(gsl_complex_mul(q,q2));
gsl_complex qpower = gsl_complex_negative(q);
while ((gsl_complex_abs(qpower) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
accum = gsl_complex_add(accum, qpower);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(accum,2.0);
}
static CVECTOR *VECTOR_convert_to_complex(CVECTOR *_object)
{
CVECTOR *v = VECTOR_create(SIZE(THIS), TRUE, FALSE);
int i;
for (i = 0; i < SIZE(THIS); i++)
gsl_vector_complex_set((gsl_vector_complex *)v->vector, i, gsl_complex_rect(gsl_vector_get(VEC(THIS), i), 0));
return v;
}
void Calculator::setMatrixPs(gsl_matrix_complex * m, double p, double q)
{
double S1, S2;
/*set matrix Ps (stationary probabilities)*/
S1 = q / (1.0 - p + q);
S2 = (1.0 - p) / (1.0 - p + q);
gsl_matrix_complex_set(m, 0, 0, gsl_complex_rect (S1, 0.0));
gsl_matrix_complex_set(m, 0, 1, gsl_complex_rect (0.0, 0.0));
gsl_matrix_complex_set(m, 1, 0, gsl_complex_rect (0.0, 0.0));
gsl_matrix_complex_set(m, 1, 1, gsl_complex_rect (S2, 0.0));
m_N = m_L / (m_L1 * S1 + m_L2 * S2);
/* DEBUG
printf("Ps:\n");
gsl_matrix_complex_fprintf (stdout, Ps, "%g");
*/
}
static CVECTOR *_mulf(CVECTOR *a, double f, bool invert)
{
CVECTOR *v = VECTOR_make(a);
if (COMPLEX(v))
gsl_vector_complex_scale(CVEC(v), gsl_complex_rect(f, 0));
else
gsl_vector_scale(VEC(v), f);
return v;
}
gsl_complex theta1(gsl_complex z, gsl_complex q, gsl_complex q14)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.0,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = gsl_complex_negative(q2);
gsl_complex qpower = gsl_complex_rect(1.0,0.0);
gsl_complex term = gsl_complex_rect(1.0,0.0);
while ((gsl_complex_abs(term) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
term = gsl_complex_mul(qpower, gsl_complex_sin(gsl_complex_mul_real(z,2*n+1)));
accum = gsl_complex_add(accum, term);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(gsl_complex_mul(q14,accum),2.0);
}
gsl_complex theta3(gsl_complex z, gsl_complex q)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.5,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = gsl_complex_mul(q,q2);
gsl_complex qpower = q;
gsl_complex term = gsl_complex_rect(1.0,0.0);
while ((gsl_complex_abs(qpower) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
term = gsl_complex_mul(qpower, gsl_complex_cos(gsl_complex_mul_real(z,2*(n+1))));
accum = gsl_complex_add(accum, term);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(accum,2.0);
}
int
lls_complex_regularize(const double lambda, gsl_matrix_complex *AHA)
{
int s;
gsl_vector_complex_view d = gsl_matrix_complex_diagonal(AHA);
gsl_complex val = gsl_complex_rect(lambda * lambda, 0.0);
s = gsl_vector_complex_add_constant(&d.vector, val);
return s;
} /* lls_complex_regularize() */
static gsl_complex cop(double r, double theta, double phi,
void *op_params, spwf_func func, void *wf_params)
{
cop_params *params = op_params;
gsl_complex ret = gsl_complex_rect(0,0);
int i;
for(i=0; i < params->n; i++){
ret = gsl_complex_add(ret,
params->funcs[i](r, theta, phi, params->params[i], func, wf_params));
}
return ret;
}
void gsl_matrix_complex_change_basis_UCMU(gsl_matrix_complex* U, gsl_matrix_complex* M){
unsigned int numneu = U->size1;
gsl_matrix_complex *U1 = gsl_matrix_complex_alloc(numneu,numneu);
gsl_matrix_complex *U2 = gsl_matrix_complex_alloc(numneu,numneu);
gsl_matrix_complex_memcpy(U1,U);
gsl_matrix_complex_memcpy(U2,U);
gsl_matrix_complex *T1 = gsl_matrix_complex_alloc(numneu,numneu);
// doing : U M U^dagger
gsl_blas_zgemm(CblasNoTrans,CblasNoTrans,
gsl_complex_rect(1.0,0.0),M,
U1,gsl_complex_rect(0.0,0.0),T1);
gsl_blas_zgemm(CblasConjTrans,CblasNoTrans,
gsl_complex_rect(1.0,0.0),U2,
T1,gsl_complex_rect(0.0,0.0),M);
// now H_current is in the interaction basis of the mass basis
gsl_matrix_complex_free(U1);
gsl_matrix_complex_free(U2);
gsl_matrix_complex_free(T1);
}
gsl_complex
gsl_linalg_complex_LU_det (gsl_matrix_complex * LU, int signum)
{
size_t i, n = LU->size1;
gsl_complex det = gsl_complex_rect((double) signum, 0.0);
for (i = 0; i < n; i++)
{
gsl_complex zi = gsl_matrix_complex_get (LU, i, i);
det = gsl_complex_mul (det, zi);
}
return det;
}
/*
computes the svd of a complex matrix. Missing in gsl.
*/
int
svd(gsl_matrix_complex *A, gsl_matrix_complex *V, gsl_vector *S)
{
int n = A->size1;
gsl_eigen_hermv_workspace *gsl_work = gsl_eigen_hermv_alloc(n);
gsl_matrix_complex *Asq = gsl_matrix_complex_alloc(n, n);
gsl_complex zero = gsl_complex_rect(0., 0.);
gsl_complex one = gsl_complex_rect(1., 0.);
gsl_vector *e = gsl_vector_alloc(n);
gsl_matrix_complex *U = gsl_matrix_complex_alloc(n, n);
gsl_blas_zgemm(CblasNoTrans, CblasConjTrans, one, A, A, zero, Asq);
gsl_eigen_hermv(Asq, e, U, gsl_work);
gsl_eigen_hermv_sort(e, U, GSL_EIGEN_SORT_VAL_DESC);
gsl_blas_zgemm(CblasConjTrans, CblasNoTrans, one, A, A, zero, Asq);
gsl_eigen_hermv(Asq, e, V, gsl_work);
gsl_eigen_hermv_sort(e, V, GSL_EIGEN_SORT_VAL_DESC);
gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, one, A, V, zero, Asq);
gsl_blas_zgemm(CblasConjTrans, CblasNoTrans, one, U, Asq, zero, A);
for(int i=0; i<n; i++){
gsl_complex x = gsl_matrix_complex_get(A, i, i);
double phase = gsl_complex_arg(gsl_complex_mul_real(x, 1./sqrt(e->data[i])));
gsl_vector_complex_view U_col = gsl_matrix_complex_column(U, i);
gsl_vector_complex_scale(&U_col.vector, gsl_complex_polar(1., phase));
gsl_vector_set(S, i, sqrt(gsl_vector_get(e, i)));
}
gsl_matrix_complex_memcpy(A, U);
gsl_vector_free(e);
gsl_matrix_complex_free(U);
gsl_matrix_complex_free(Asq);
gsl_eigen_hermv_free(gsl_work);
return 0;
}
gsl_complex pspace(double x=0.00){
//La funcion de onda en el espacio p
// x aqui es un momento
//heredamos todo de coherentstate
gsl_complex result;
result=gsl_complex_rect(0.00,0.000);
for(int i=0; i<totals; i++){
result=
gsl_complex_add(result,
gsl_complex_mul(componente[i].pspace(x),pesos[i]));
};
return result;
};
void VECTOR_ensure_complex(CVECTOR *_object)
{
gsl_vector_complex *v;
int size = SIZE(THIS);
int i;
if (COMPLEX(THIS))
return;
v = gsl_vector_complex_alloc(size);
for (i = 0; i < size; i++)
gsl_vector_complex_set(v, i, gsl_complex_rect(gsl_vector_get(VEC(THIS), i), 0));
gsl_vector_free(VEC(THIS));
THIS->vector = v;
THIS->complex = TRUE;
}
gsl_complex integrate_contour(Params *params,
const Contour *contour)
{
gsl_complex result = gsl_complex_rect(0.0, 0.0);
if (contour->npoints < 2)
return result;
for (unsigned i = 0; i < contour->npoints - 1; ++i)
{
if (contour->skip[i])
continue;
result = gsl_complex_add(result,
integrate_line_segment(params, contour->points[i], contour->points[i+1]));
}
return result;
}
static void MATRIX_ensure_complex(CMATRIX *_object)
{
gsl_matrix_complex *v;
int w = WIDTH(THIS);
int h = HEIGHT(THIS);
int i, j;
if (COMPLEX(THIS))
return;
v = gsl_matrix_complex_alloc(h, w);
for (i = 0; i < h; i++)
for (j = 0; j < w; j++)
gsl_matrix_complex_set(v, i, j, gsl_complex_rect(gsl_matrix_get(MAT(THIS), i, j), 0));
gsl_matrix_free(MAT(THIS));
THIS->matrix = v;
THIS->complex = TRUE;
}
