/* In: tau (lattice parameter) Out: g2 -> g[0] g3 -> g[1] */ void compute_invariants(gsl_complex tau, gsl_complex *g) { gsl_complex q, q14; gsl_complex t2,t3,t24,t34; gsl_complex g3_term1, g3_term2; gsl_complex g2, g3; q = gsl_complex_exp(gsl_complex_mul_imag(tau,M_PI)); q14 = gsl_complex_exp(gsl_complex_mul_imag(tau,M_PI_4)); t2=theta20(q,q14); t3=theta30(q); t24 = pow4(t2); t34 = pow4(t3); g2 = gsl_complex_mul_real(gsl_complex_sub(gsl_complex_add(gsl_complex_mul(t24,t24),gsl_complex_mul(t34,t34)),gsl_complex_mul(t24,t34)),_CONST_43PI4); g3_term1 = gsl_complex_add(gsl_complex_mul(t24,gsl_complex_mul(t24,t24)),gsl_complex_mul(t34,gsl_complex_mul(t34,t34))); g3_term2 = gsl_complex_mul(gsl_complex_add(t24,t34),gsl_complex_mul(t24,t34)); g3 = gsl_complex_sub( gsl_complex_mul_real(g3_term1, _CONST_827PI6), gsl_complex_mul_real(g3_term2, _CONST_49PI6) ); g[0] = g2; g[1] = g3; }
/* psi(z) for large |z| in the right half-plane; [Abramowitz + Stegun, 6.3.18] */ static gsl_complex psi_complex_asymp(gsl_complex z) { /* coefficients in the asymptotic expansion for large z; * let w = z^(-2) and write the expression in the form * * ln(z) - 1/(2z) - 1/12 w (1 + c1 w + c2 w + c3 w + ... ) */ static const double c1 = -0.1; static const double c2 = 1.0/21.0; static const double c3 = -0.05; gsl_complex zi = gsl_complex_inverse(z); gsl_complex w = gsl_complex_mul(zi, zi); gsl_complex cs; /* Horner method evaluation of term in parentheses */ gsl_complex sum; sum = gsl_complex_mul_real(w, c3/c2); sum = gsl_complex_add_real(sum, 1.0); sum = gsl_complex_mul_real(sum, c2/c1); sum = gsl_complex_mul(sum, w); sum = gsl_complex_add_real(sum, 1.0); sum = gsl_complex_mul_real(sum, c1); sum = gsl_complex_mul(sum, w); sum = gsl_complex_add_real(sum, 1.0); /* correction added to log(z) */ cs = gsl_complex_mul(sum, w); cs = gsl_complex_mul_real(cs, -1.0/12.0); cs = gsl_complex_add(cs, gsl_complex_mul_real(zi, -0.5)); return gsl_complex_add(gsl_complex_log(z), cs); }
void DAESolver::set_jacobian_matrix(Real const a_step_interval) { const Real alphah(alpha_ / a_step_interval); const Real betah(beta_ / a_step_interval); const Real gammah(gamma_ / a_step_interval); gsl_complex comp1, comp2; for (RealVector::size_type i(0); i < the_system_size_; i++) { for (RealVector::size_type j(0); j < the_system_size_; j++) { const Real a_partial_derivative(the_jacobian_[i][j]); gsl_matrix_set(the_jacobian_matrix1_, i, j, a_partial_derivative); GSL_SET_COMPLEX(&comp1, a_partial_derivative, 0); gsl_matrix_complex_set(the_jacobian_matrix2_, i, j, comp1); } } for (Integer c(0); c < the_function_differential_size_; ++c) { const Real a_partial_derivative( gsl_matrix_get(the_jacobian_matrix1_, c, c)); gsl_matrix_set(the_jacobian_matrix1_, c, c, gammah + a_partial_derivative); comp1 = gsl_matrix_complex_get(the_jacobian_matrix2_, c, c); GSL_SET_COMPLEX(&comp2, alphah, betah); gsl_matrix_complex_set(the_jacobian_matrix2_, c, c, gsl_complex_add(comp1, comp2)); } decomp_jacobian_matrix(); }
gsl_complex vectorc::operator*(const vectorc& vec) const { gsl_complex result; for (int i=0; i<size_m; i++) gsl_complex_add(result, gsl_complex_mul(gsl_vector_complex_get(v_m, i), gsl_vector_complex_get(vec.v_m, i))); return result; }
/* ------------------------------------------------------ */ gsl_complex gsl_complex_arctan2 (gsl_complex a, gsl_complex b) { gsl_complex z, p; if(GSL_REAL(b) != 0.0) { z = gsl_complex_arctan(gsl_complex_div(a, b)); if(GSL_REAL(b) < 0.0){ GSL_SET_COMPLEX (&p, M_PI, 0); if(GSL_REAL(a) >= 0.0) z = gsl_complex_add(z, p); else z = gsl_complex_sub(z, p); } } else { if(GSL_REAL(a) >= 0.0) { GSL_SET_COMPLEX (&z, M_PI/2.0, 0.0); } else { GSL_SET_COMPLEX (&z, -M_PI/2.0, 0.0); } } return z; }
complex_spinor complex_spinor::operator+(const complex_spinor & complex_spinor_param)const{ gsl_complex aux_UP; gsl_complex aux_DOWN; GSL_SET_COMPLEX(&aux_UP, 0, 0); GSL_SET_COMPLEX(&aux_DOWN, 0, 0); int i; int nSitios = this->_numSites; complex_spinor complex_spinor_res(nSitios); for(i=0; i<nSitios ; i++){ aux_UP = gsl_complex_add(complex_spinor_param.complex_spinor_get(i, UP) , this->complex_spinor_get(i, UP)); aux_DOWN = gsl_complex_add(complex_spinor_param.complex_spinor_get(i, DOWN) , this->complex_spinor_get(i,DOWN)); complex_spinor_res.complex_spinor_set(i, UP, aux_UP); complex_spinor_res.complex_spinor_set(i, DOWN, aux_DOWN); } return complex_spinor_res; }
/* The Lattes map */ gsl_complex P_doubler(gsl_complex p, const gsl_complex *g) { gsl_complex p2, p3; gsl_complex num; gsl_complex denom; gsl_complex term; p2 = gsl_complex_mul(p,p); p3 = gsl_complex_mul(p2,p); /* denom = 4p^3 - g2p - g3 */ denom = gsl_complex_sub(gsl_complex_mul_real(p3,4.0), gsl_complex_add(gsl_complex_mul(p,g[0]),g[1])); /* num = (p^2 + g2/4)^2 + 2g3p */ term = gsl_complex_add(p2,gsl_complex_mul_real(g[0],0.25)); num = gsl_complex_add(gsl_complex_mul(p,gsl_complex_mul_real(g[1],2.0)), gsl_complex_mul(term,term)); return gsl_complex_div(num,denom); }
void CModel::AllFacetHarmonics(int bw, double r, gsl_complex *coeff){ for(int i=0; i<bw*bw; i++) GSL_SET_COMPLEX(&coeff[i], 0.0, 0.0); gsl_complex *temp = new gsl_complex[bw*bw]; for(int i=0; i<f_no; i++){ FacetHarmonics(i, bw, r, temp); for(int j=0; j<bw*bw; j++) coeff[j] = gsl_complex_add(coeff[j],temp[j]); } delete [] temp; }
gsl_complex complex_spinor::operator* (const complex_spinor & complex_spinor_param) const{ gsl_complex aux_UP; gsl_complex aux_DOWN; gsl_complex aux; GSL_SET_COMPLEX(&aux_UP, 0, 0); GSL_SET_COMPLEX(&aux_DOWN, 0, 0); GSL_SET_COMPLEX(&aux, 0, 0); int i; int nSitios = this->_numSites; for(i=0; i<nSitios ; i++){ aux_UP = gsl_complex_mul(gsl_complex_conjugate(complex_spinor_param.complex_spinor_get(i,UP)) ,this->complex_spinor_get(i,UP)); aux_DOWN = gsl_complex_mul(gsl_complex_conjugate(complex_spinor_param.complex_spinor_get(i,DOWN)),this->complex_spinor_get(i,DOWN)); aux=gsl_complex_add(aux, gsl_complex_add(aux_UP,aux_DOWN)); } return aux; }
double intensita(gsl_complex A, gsl_complex B) { // PROVVISORIO //~ double intensita = (gsl_complex_abs2(A) + gsl_complex_abs2(B) )/(2*in.Z_st); double intensita = gsl_complex_abs(gsl_complex_mul(gsl_complex_add(A,B) , gsl_complex_conjugate(gsl_complex_add(A,B)))); printf("I=%e\n",intensita); #ifdef DEBUG printf("|A|=%e\n",gsl_complex_abs(A)); printf("|B|=%e\n",gsl_complex_abs(B)); printf("intensita=%e\n",intensita); #endif return intensita; }
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; }
double line_segment_integrand_wrapper(double t, void *data) { const LineSegmentParams *params = (const LineSegmentParams *)data; gsl_complex p = gsl_complex_add(params->p0, gsl_complex_mul_real(params->k, t)); gsl_complex v = f_envelope(p, params->params); double v_part = (params->part == REAL) ? GSL_REAL(v) : GSL_IMAG(v); double damped = exp( - params->damping * t) * v_part; return damped; }
/* NOTE: Assumes z is in fundamental parallelogram */ gsl_complex wP(gsl_complex z, gsl_complex tau, const gsl_complex *g) { int N = 6; int i; gsl_complex z0; gsl_complex z02; gsl_complex p; z = near_origin(z,tau); z0 = gsl_complex_div_real(z,(double)(1 << N)); z02 = gsl_complex_mul(z0,z0); /* Laurent expansion: P \approx 1/z^2 + (g2/20)z^2 + (g3/28) z^4 */ p = gsl_complex_add(gsl_complex_inverse(z02), gsl_complex_add(gsl_complex_mul(z02,gsl_complex_mul_real(g[0],0.05)), gsl_complex_mul(gsl_complex_mul(z02,z02),gsl_complex_mul_real(g[1],_CONST_1_28)))); for (i=0;i<N;i++) { p = P_doubler(p,g); } return p; }
int main(int argc, char** argv) { gsl_complex a,b; GSL_SET_COMPLEX(&a,3,4);//a=3+4i GSL_SET_COMPLEX(&b,6,8);//b=6+8i gsl_complex c = gsl_complex_add(a,b); printf("a+b\treal : %f image : %f\n",c.dat[0],c.dat[1]); c = gsl_complex_sub(a,b); printf("a-b\treal : %f image : %f\n",c.dat[0],c.dat[1]); c = gsl_complex_mul(a,b); printf("a*b\treal : %f image : %f\n",c.dat[0],c.dat[1]); c = gsl_complex_div(a,b); printf("a/b\treal : %f image : %f\n",c.dat[0],c.dat[1]); // system("PAUSE"); 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; };
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); }
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); }
void MCPMPCoeffs::GeoUpdate(double seconds) { for (int i=0;i<2*M();i++) { gsl_complex v = gsl_vector_complex_get(geoVelocities,i); // expressed in deltalon/s,deltalat/s gsl_complex p = gsl_vector_complex_get(geoPositions,i); // expressed in lon,lat gsl_complex np = gsl_complex_add(p,gsl_complex_mul_real(v, seconds)); gsl_vector_complex_set(geoPositions,i,np); // cout << "node " << i << " position = " << GSL_IMAG(np) << ", " << GSL_REAL(np) << endl; } }
/* The extended Lattes map (rational function doubling on the elliptic curve) */ void P_and_Pprime_doubler(gsl_complex *p, gsl_complex *pp, const gsl_complex *g) { gsl_complex pp3; gsl_complex ppp, ppp3; /* p'' */ ppp = gsl_complex_sub(gsl_complex_mul_real(gsl_complex_mul(*p,*p),6.0), gsl_complex_mul_real(g[0],0.5)); ppp3 = gsl_complex_mul(ppp,gsl_complex_mul(ppp,ppp)); pp3 = gsl_complex_mul(*pp,gsl_complex_mul(*pp,*pp)); *pp = gsl_complex_sub(gsl_complex_add(gsl_complex_mul_real(gsl_complex_div(gsl_complex_mul(*p,ppp),*pp),3.0), gsl_complex_mul_real(gsl_complex_div(ppp3,pp3),-0.25)), *pp); *p = P_doubler(*p,g); }
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; }
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); }
/****************************************************************************** * calc_I() * Calculate the field intensity at an arbitrary point within layer * * Parameters * --------- * * Returns * ------- * * Notes * ----- * Note assume that 0 <= z <= d[j] (but we dont check that here) * except for the base layer (j==0), in that case z <= 0 * ******************************************************************************/ double calc_I(int layer_idx, double z, ref_model *ref, angle_calc *ang_c, layer_calc *lay_c){ double I, k; gsl_complex Ai, Ar, Ei, Er, g, phase_i, phase_r; k = ref->k; GSL_REAL(Ai) = ang_c->Re_Ai[layer_idx]; GSL_IMAG(Ai) = ang_c->Im_Ai[layer_idx]; GSL_REAL(Ar) = ang_c->Re_Ar[layer_idx]; GSL_IMAG(Ar) = ang_c->Im_Ar[layer_idx]; GSL_REAL(g) = ang_c->Re_g[layer_idx]; GSL_IMAG(g) = ang_c->Im_g[layer_idx]; // calculate Ei at z within layer j // make sure z is neg for base layer if (layer_idx == 0){ if (z > 0) z = -1.0*z; } else { if (z < 0) z = -1.0*z; } GSL_REAL(phase_i) = 0.0; GSL_IMAG(phase_i) = 1.0*k*z; phase_i = gsl_complex_exp( gsl_complex_mul(phase_i,g)); Ei = gsl_complex_mul(Ai,phase_i); // calculate Er at z within layer j if (layer_idx > 0) { GSL_REAL(phase_r) = 0.0; GSL_IMAG(phase_r) = -1.0*k*z; phase_r = gsl_complex_exp( gsl_complex_mul(phase_r,g)); Er = gsl_complex_mul(Ar,phase_r); } else { GSL_REAL(phase_r) = 0.0; GSL_IMAG(phase_r) = 0.0; GSL_REAL(Er) = 0.0; GSL_IMAG(Er) = 0.0; } I = gsl_complex_abs2(gsl_complex_add(Ei,Er)); return (I); }
void tabulate(FILE *os, ComplexFunction fun, void *params, gsl_complex z0, gsl_complex z1, int n) { gsl_complex k = gsl_complex_sub(z1, z0); for (int i = 0; i < n; ++i) { double t = (double)i / (n - 1); gsl_complex z = gsl_complex_add(z0, gsl_complex_mul_real(k, t)); gsl_complex f = fun(z, params); double abs = gsl_complex_abs(f); fprintf(os, "%g %g %g %g %g %g %g\n", t, GSL_REAL(z), GSL_IMAG(z), GSL_REAL(f), GSL_IMAG(f), abs, -abs); } }
//go through all sets of Bethe rapidities and calculate g1 for all identical sets. return value is sum of all these terms. gsl_complex exact_integrationDE(double orteins, double ortzwei, double** kEp_plusminus, int anzahl_sets, double** coeffoverlap) { //variables to make loop easily readable, could delete from final version double c, Energie, Energieprime, normierung, normierungprime; double k[N]; double kprime[N];//corresponds to primed Bethe rapidity set in papers gsl_complex overlap, overlapprime, integral; GSL_SET_COMPLEX(&integral, 0.0, 0.0);//sum of all values, technically no needed but good for quick check of initial shape of g1 int zaehler_integrale = 0;//counter of total sets of integrals double Nminusone_fak = 1.0;//(N-1) factorial, see definition of integrals on restricted spatial domain for(int j=1; j<=(N-1); j++) Nminusone_fak = Nminusone_fak * ((double) j); for(int zaehler_eigenstate = 0 ; zaehler_eigenstate < anzahl_sets; zaehler_eigenstate++){//loop over all Bethe rapidity sets c = kEp_plusminus[zaehler_eigenstate][0];//interaction strength for(int bb=0; bb<N; bb++) k[bb]=kEp_plusminus[zaehler_eigenstate][bb+1];//Bethe rapidities Energie = kEp_plusminus[zaehler_eigenstate][N+1];//energy normierung=kEp_plusminus[zaehler_eigenstate][N+6];//norm GSL_SET_COMPLEX(&overlap, coeffoverlap[zaehler_eigenstate][0], coeffoverlap[zaehler_eigenstate][1]);//overlap of set with initial state //calculate g1_DE for this Bethe set gsl_complex integralwert = integraleigenfunction(k, k, c, normierung, normierung, orteins, ortzwei); integralwert = gsl_complex_mul_real(integralwert, (Nminusone_fak*Laenge));//integral evaluated in Rp only -> missing factor of (N-1)!. Laenge (=system length): definition of g1 has prefactor of N!/(n*(N-1)!) = Laenge integral = gsl_complex_add(integral, gsl_complex_mul(gsl_complex_mul(overlap, gsl_complex_conjugate(overlap)), integralwert)); }//end for loop zaehler_eigenstate return integral; };
/* NOTE: Assumes z is in fundamental parallelogram */ void wP_and_prime(gsl_complex z, gsl_complex tau, const gsl_complex *g, gsl_complex *p, gsl_complex *pp) { int N = 6; /* Enough iterations for good P, not so good P' */ int i; gsl_complex z0; gsl_complex z02; gsl_complex pout, ppout; gsl_complex ppsolve; z = near_origin(z,tau); z0 = gsl_complex_div_real(z,(double)(1 << N)); z02 = gsl_complex_mul(z0,z0); /* Laurent expansion: P \approx 1/z^2 + (g2/20)z^2 + (g3/28) z^4 */ pout = gsl_complex_add(gsl_complex_inverse(z02), gsl_complex_add(gsl_complex_mul(z02,gsl_complex_mul_real(g[0],0.05)), gsl_complex_mul(gsl_complex_mul(z02,z02),gsl_complex_mul_real(g[1],_CONST_1_28)))); /* Laurent expansion: P' \approx -2/z^3 + g2/10z + g3/7 z^3 */ ppout = gsl_complex_add(gsl_complex_mul_real(gsl_complex_inverse(gsl_complex_mul(z0,z02)),-2.0), gsl_complex_add(gsl_complex_mul(z0,gsl_complex_mul_real(g[0],0.1)), gsl_complex_mul(gsl_complex_mul(z0,z02),gsl_complex_mul_real(g[1],_CONST_1_7)))); for (i=0;i<N;i++) { P_and_Pprime_doubler(&pout, &ppout, g); } /* At this point ppout is a decent but not great approximation of P'(z) */ /* Instead of using it directly, we use it as a guide for which square root of */ /* (4P^3 - g2 P - g3) should be selected. */ ppsolve = gsl_complex_sqrt( gsl_complex_sub( gsl_complex_mul_real(gsl_complex_mul(pout,gsl_complex_mul(pout,pout)),4.0), gsl_complex_add(gsl_complex_mul(g[0],pout),g[1]) ) ); *p = pout; if (gsl_complex_abs(gsl_complex_sub(ppsolve,ppout)) < gsl_complex_abs(gsl_complex_add(ppsolve,ppout))) *pp = ppsolve; else *pp = gsl_complex_negative(ppsolve); }
int gsl_eigen_hermv (gsl_matrix_complex * A, gsl_vector * eval, gsl_matrix_complex * evec, gsl_eigen_hermv_workspace * w) { if (A->size1 != A->size2) { GSL_ERROR ("matrix must be square to compute eigenvalues", GSL_ENOTSQR); } else if (eval->size != A->size1) { GSL_ERROR ("eigenvalue vector must match matrix size", GSL_EBADLEN); } else if (evec->size1 != A->size1 || evec->size2 != A->size1) { GSL_ERROR ("eigenvector matrix must match matrix size", GSL_EBADLEN); } else { const size_t N = A->size1; double *const d = w->d; double *const sd = w->sd; size_t a, b; /* handle special case */ if (N == 1) { gsl_complex A00 = gsl_matrix_complex_get (A, 0, 0); gsl_vector_set (eval, 0, GSL_REAL(A00)); gsl_matrix_complex_set (evec, 0, 0, GSL_COMPLEX_ONE); return GSL_SUCCESS; } /* Transform the matrix into a symmetric tridiagonal form */ { gsl_vector_view d_vec = gsl_vector_view_array (d, N); gsl_vector_view sd_vec = gsl_vector_view_array (sd, N - 1); gsl_vector_complex_view tau_vec = gsl_vector_complex_view_array (w->tau, N-1); gsl_linalg_hermtd_decomp (A, &tau_vec.vector); gsl_linalg_hermtd_unpack (A, &tau_vec.vector, evec, &d_vec.vector, &sd_vec.vector); } /* Make an initial pass through the tridiagonal decomposition to remove off-diagonal elements which are effectively zero */ chop_small_elements (N, d, sd); /* Progressively reduce the matrix until it is diagonal */ b = N - 1; while (b > 0) { if (sd[b - 1] == 0.0 || isnan(sd[b - 1])) { b--; continue; } /* Find the largest unreduced block (a,b) starting from b and working backwards */ a = b - 1; while (a > 0) { if (sd[a - 1] == 0.0) { break; } a--; } { size_t i; const size_t n_block = b - a + 1; double *d_block = d + a; double *sd_block = sd + a; double * const gc = w->gc; double * const gs = w->gs; /* apply QR reduction with implicit deflation to the unreduced block */ qrstep (n_block, d_block, sd_block, gc, gs); /* Apply Givens rotation Gij(c,s) to matrix Q, Q <- Q G */ for (i = 0; i < n_block - 1; i++) { const double c = gc[i], s = gs[i]; size_t k; for (k = 0; k < N; k++) { gsl_complex qki = gsl_matrix_complex_get (evec, k, a + i); gsl_complex qkj = gsl_matrix_complex_get (evec, k, a + i + 1); /* qki <= qki * c - qkj * s */ /* qkj <= qki * s + qkj * c */ gsl_complex x1 = gsl_complex_mul_real(qki, c); gsl_complex y1 = gsl_complex_mul_real(qkj, -s); gsl_complex x2 = gsl_complex_mul_real(qki, s); gsl_complex y2 = gsl_complex_mul_real(qkj, c); gsl_complex qqki = gsl_complex_add(x1, y1); gsl_complex qqkj = gsl_complex_add(x2, y2); gsl_matrix_complex_set (evec, k, a + i, qqki); gsl_matrix_complex_set (evec, k, a + i + 1, qqkj); } } /* remove any small off-diagonal elements */ chop_small_elements (n_block, d_block, sd_block); } } { gsl_vector_view d_vec = gsl_vector_view_array (d, N); gsl_vector_memcpy (eval, &d_vec.vector); } return GSL_SUCCESS; } }
void MCPMPChan::Run() { /// fetch data objects gsl_matrix_complex inmat = min1.GetDataObj(); gsl_matrix_complex cmat = min2.GetDataObj(); // inmat : input signal matrix x(n) (NxM) // i // complex sample at time n from Tx number i // cmat : channel coeffs matrix h(n) (M**2xN) // ij // cmat matrix structure // // +- -+ // | h(0) . . . . h(n) | | // | 11 11 | | // | | | Rx1 // | h(0) . . . . h(n) | | // | 12 12 | | // | | // | h(0) . . . . h(n) | | // | 21 21 | | // | | | Rx2 // | h(0) . . . . h(n) | | // | 22 22 | | // +- -+ // // where h(n) represents the channel impulse response // ij // // at time n, from tx i to rx j // the matrix has MxM rows and N comumns. // The (i,j) channel is locater at row i*M+j // with i,j in the range [0,M-1] and rows counting from 0 // // gsl_matrix_complex_set_zero(outmat); for (int rx=0;rx<M();rx++) { //loop through Rx // // csubmat creates a view on cmat extracting the MxN submatrix for Rx number u // gsl_matrix_complex_const_view csubmat = gsl_matrix_complex_const_submatrix(&cmat,rx*M(),0,M(),N()); // // cut a slice of outmat // gsl_vector_complex_view outvec = gsl_matrix_complex_column(outmat,rx); for (int tx=0;tx<M();tx++) { // loop through Tx // // input signal from tx // gsl_vector_complex_view x = gsl_matrix_complex_column(&inmat,tx); gsl_vector_complex *tmp = gsl_vector_complex_alloc(N()); // // // extract the current tx-rx channel matrix // // for (int i=0; i<N(); i++) { gsl_complex h = gsl_matrix_complex_get(&csubmat.matrix,tx,(N()-i)%N()); for (int j=0; j<N(); j++) { gsl_matrix_complex_set(user_chan,j,(j+i) % N(),h); } } // cout << "Channel (" << tx << "-" << rx << "):" << endl; // gsl_matrix_complex_show(user_chan); // // compute the signal rx = H tx // gsl_blas_zgemv(CblasNoTrans, gsl_complex_rect(1.0,0), user_chan, &x.vector, gsl_complex_rect(0,0), tmp); // // sum for each tx // gsl_vector_complex_add(&outvec.vector,tmp); gsl_vector_complex_free(tmp); } // tx loop for (int i=0; i< N(); i++) { gsl_complex noisesample = gsl_complex_rect( gsl_ran_gaussian(ran,noisestd), gsl_ran_gaussian(ran,noisestd)); gsl_complex ctmp = gsl_complex_add(gsl_vector_complex_get(&outvec.vector,i),noisesample); gsl_vector_complex_set(&outvec.vector,i,ctmp); } } // rx loop // cout << "received signals matrix (" << N() << "x" << M() << ")" << endl; // gsl_matrix_complex_show(outmat); //////// production of data mout1.DeliverDataObj( *outmat ); }
void matrix_acc(gsl_matrix_complex *V,unsigned l, unsigned c, double _Complex a){ gsl_complex T1; T1=gsl_matrix_complex_get(V,l,c); gsl_matrix_complex_set(V,l,c,gsl_complex_add(T1,c2g(a))); }
void vector_acc(gsl_vector_complex *V,unsigned n, double _Complex a){ gsl_complex T1; T1=gsl_vector_complex_get(V,n); gsl_vector_complex_set(V,n,gsl_complex_add(T1,c2g(a))); }