static void ccall(JF, js_Ast *fun, js_Ast *args) { int n; switch (fun->type) { case EXP_INDEX: cexp(J, F, fun->a); emit(J, F, OP_DUP); cexp(J, F, fun->b); emit(J, F, OP_GETPROP); emit(J, F, OP_ROT2); break; case EXP_MEMBER: cexp(J, F, fun->a); emit(J, F, OP_DUP); emitstring(J, F, OP_GETPROP_S, fun->b->string); emit(J, F, OP_ROT2); break; case EXP_IDENTIFIER: if (!strcmp(fun->string, "eval")) { ceval(J, F, fun, args); return; } /* fall through */ default: cexp(J, F, fun); emit(J, F, J->strict ? OP_UNDEF : OP_GLOBAL); break; } n = cargs(J, F, args); emit(J, F, OP_CALL); emitraw(J, F, n); }
/* Conformal map that takes the unit disc onto the disc minus a slit * starting at cexp(I * u). Approximates the atomic maps for radial * SLE, and the reciprocal of this approximates the atomic maps for * full plane SLE. */ static complex sle_cmap_slit_disc(double t, double u, complex z) { complex rotation = cexp((I * u)); complex w = 4 * cexp(-t) * z; complex v = z + 1; return rotation * 1.0/w * (2 * v * v - w - 2 * v * csqrt(v * v - w)); }
void fft(double _Complex *in, double _Complex *out,unsigned char N, short sign) { double _Complex *mid; unsigned temp, temp1,rank; unsigned listlenth = pow(2,N); mid=(double _Complex *)malloc(sizeof(double _Complex)*listlenth); for(unsigned i=0;i<listlenth;i++) mid[i]=in[reversebit(i,(unsigned char)N)]; unsigned j, t, interval; double _Complex exponent, exponent_unit; interval = 1; for(unsigned i=1;i<=N;i++){ j=0; while(j<listlenth){ exponent_unit = (sign<=0)? cexp(I*PI/interval):cexp(-I*PI/interval); exponent= 1; for(t=0;t<interval*2;t++){ out[t+j]=mid[t%interval+j]+exponent*mid[t%interval+interval+ j]; exponent *= exponent_unit; } j=j+interval*2; } interval *= 2; memcpy(mid,out,listlenth*sizeof(double _Complex)); } if (sign <=0){ for(j = 0;j <listlenth;j++) out[j] /= listlenth; } free(mid); }
LTFAT_EXTERN void LTFAT_NAME_REAL(idwiltiii_long)(const LTFAT_REAL *c, const LTFAT_REAL *g, const ltfatInt L, const ltfatInt W, const ltfatInt M, LTFAT_REAL *f) { const ltfatInt N = L / M; const ltfatInt M2 = 2 * M; const ltfatInt M4 = 4 * M; const LTFAT_REAL scalconst = 1.0 / sqrt(2.0); const LTFAT_COMPLEX eipi4 = cexp(I * PI / 4.0); const LTFAT_COMPLEX emipi4 = cexp(-I * PI / 4.0); LTFAT_COMPLEX *coef2 = ltfat_calloc(2 * M * N * W, sizeof * coef2); LTFAT_COMPLEX *f2 = ltfat_malloc(L * W * sizeof * f2); LTFAT_COMPLEX *g2 = ltfat_malloc(L * sizeof * g2); for (ltfatInt ii = 0; ii < L; ii++) g2[ii] = g[ii]; const LTFAT_REAL *pcoef = c; LTFAT_COMPLEX *pcoef2 = coef2; PREPROC_COMPLEX LTFAT_NAME(idgt_long)(coef2, g2, L, W, M, 2 * M, FREQINV, f2); POSTPROC_REAL LTFAT_SAFEFREEALL(coef2, f2, g2); }
LTFAT_EXTERN void LTFAT_NAME_COMPLEX(dwiltiii_long)(const LTFAT_COMPLEX *f, const LTFAT_COMPLEX *g, const ltfatInt L, const ltfatInt W, const ltfatInt M, LTFAT_COMPLEX *cout) { const ltfatInt N=L/M; const ltfatInt M2=2*M; const ltfatInt M4=4*M; const LTFAT_REAL scalconst = 1.0/sqrt(2.0); const LTFAT_COMPLEX eipi4 = cexp(I*PI/4.0); const LTFAT_COMPLEX emipi4 = cexp(-I*PI/4.0); LTFAT_COMPLEX *coef2 = ltfat_malloc(2*M*N*W*sizeof*coef2); LTFAT_COMPLEX *f2 = ltfat_malloc(L*W*sizeof*f2); PREPROC LTFAT_NAME_COMPLEX(dgt_long)(f2, g, L, W, M, 2*M, coef2); LTFAT_COMPLEX *pcoef = cout; LTFAT_COMPLEX *pcoef2 = coef2; POSTPROC_COMPLEX LTFAT_SAFEFREEALL(coef2,f2); }
static void ccall(JF, js_Ast *fun, js_Ast *args) { int n; switch (fun->type) { case EXP_INDEX: cexp(J, F, fun->a); emit(J, F, OP_DUP); cexp(J, F, fun->b); emit(J, F, OP_GETPROP); emit(J, F, OP_ROT2); break; case EXP_MEMBER: cexp(J, F, fun->a); emit(J, F, OP_DUP); emitstring(J, F, OP_GETPROP_S, fun->b->string); emit(J, F, OP_ROT2); break; default: cexp(J, F, fun); emit(J, F, OP_GLOBAL); break; } n = cargs(J, F, args); emit(J, F, OP_CALL); emitraw(J, F, n); }
void mkexps(const double *rlams, const int nlambs, const int *numphys, const int nexptotp, dcomplex *xs, dcomplex *ys, double *zs) { int ntot, nell, mth, ncurrent; double hu, u; ntot = 0; for ( nell = 0; nell < nlambs; nell++) { hu = 2.0*M_PI/numphys[nell]; for ( mth = 0; mth < numphys[nell]/2; mth++ ) { u = mth*hu; ncurrent=3*(ntot+mth); zs[ncurrent] = exp( -rlams[nell] ); zs[ncurrent+1] = zs[ncurrent]*zs[ncurrent]; zs[ncurrent+2] = zs[ncurrent]*zs[ncurrent+1]; xs[ncurrent] = cexp(_Complex_I*cos(u)*rlams[nell]); xs[ncurrent+1] = xs[ncurrent]*xs[ncurrent]; xs[ncurrent+2] = xs[ncurrent]*xs[ncurrent+1]; ys[ncurrent] = cexp(_Complex_I*sin(u)*rlams[nell]); ys[ncurrent+1] = ys[ncurrent]*ys[ncurrent]; ys[ncurrent+2] = ys[ncurrent+1]*ys[ncurrent]; } ntot += numphys[nell]/2; } }
inline Complex PlasmaDispersion(Complex z) { static const double SQRT_PI = 1.7724538509055160272981674833411451; Complex Z; Complex z2 = z*z; // sometimes imaginary part is too high, due to test functions, limit if(cimag(z) > 25.) z = creal(z) + 25.I; // Use asymptotic expansions for large values |z| >> 1 // See definition in NRL Plasma Formulary if(creal(z*z) > 100) { const double x = creal(z); const double y = cimag(z); const double sigma = (y > 0.) ? 0 : (( y == 0) ? 1. : 2.); Complex z4 = z2*z2; Complex z6 = z4*z2; Z = 1.0I * SQRT_PI * sigma * cexp(-z2) - 1./z * ( 1. + 1./(2.*z2) + 3./(4.*z4) + 15./(8.*z6)); } else Z = 1.0I * SQRT_PI * cexp(- z2) * cerfc(- 1.0I * z); return Z; };
LTFAT_EXTERN void LTFAT_NAME_COMPLEX(idwiltiii_fb)(const LTFAT_COMPLEX *c, const LTFAT_COMPLEX *g, const ltfatInt L, const ltfatInt gl, const ltfatInt W, const ltfatInt M, LTFAT_COMPLEX *f) { const ltfatInt N = L / M; const ltfatInt M2 = 2 * M; const ltfatInt M4 = 4 * M; const LTFAT_REAL scalconst = 1.0 / sqrt(2.0); const LTFAT_COMPLEX eipi4 = cexp(I * PI / 4.0); const LTFAT_COMPLEX emipi4 = cexp(-I * PI / 4.0); LTFAT_COMPLEX *coef2 = ltfat_calloc(2 * M * N * W, sizeof * coef2); LTFAT_COMPLEX *f2 = ltfat_malloc(L * W * sizeof * f2); const LTFAT_COMPLEX *pcoef = c; LTFAT_COMPLEX *pcoef2 = coef2; PREPROC_COMPLEX LTFAT_NAME(idgt_fb)(coef2, g, L, gl, W, M, 2 * M, FREQINV, f2); POSTPROC_COMPLEX LTFAT_SAFEFREEALL(coef2, f2); }
static void cassignforin(JF, js_Ast *stm) { js_Ast *lhs = stm->a; if (stm->type == STM_FOR_IN_VAR) { if (lhs->b) jsC_error(J, lhs->b, "more than one loop variable in for-in statement"); emitlocal(J, F, OP_SETLOCAL, OP_SETVAR, lhs->a->a); /* list(var-init(ident)) */ emit(J, F, OP_POP); return; } switch (lhs->type) { case EXP_IDENTIFIER: emitlocal(J, F, OP_SETLOCAL, OP_SETVAR, lhs); emit(J, F, OP_POP); break; case EXP_INDEX: cexp(J, F, lhs->a); cexp(J, F, lhs->b); emit(J, F, OP_ROT3); emit(J, F, OP_SETPROP); emit(J, F, OP_POP); break; case EXP_MEMBER: cexp(J, F, lhs->a); emit(J, F, OP_ROT2); emitstring(J, F, OP_SETPROP_S, lhs->b->string); emit(J, F, OP_POP); break; default: jsC_error(J, lhs, "invalid l-value in for-in loop assignment"); } }
static void calculate(catastrophe_t *const catastrophe, const unsigned int i, const unsigned int j) { cmplx_equation_t *equation; point_array_t *point_array; /* Gamma function's precalculated values */ const double g14 = 3.625609908; const double g34 = 1.225416702; assert(catastrophe); equation = catastrophe->equation; point_array = catastrophe->point_array; assert(equation); assert(point_array); equation->initial_vector[V] = 0.5 * g14 * cexp(I * M_PI / 8.0); equation->initial_vector[V1] = 0; equation->initial_vector[V2] = 0.5 * I * g34 * cexp(I * 3.0 * M_PI / 8.0); cmplx_runge_kutta(0.0, 1.0, 0.01, catastrophe); }
/** Make basic arrays for servo analysis. */ static void servo_calc_init(SERVO_CALC_T *st, const dmat *psdin, double dt, long dtrat){ if(psdin->ny!=2){ error("psdin should have two columns\n"); } double Ts=dt*dtrat; st->fny=0.5/Ts; dmat *nu=st->nu=dlogspace(-3,log10(0.5/dt),1000); st->psd=dinterp1(psdin, 0, nu, 1e-40); st->var_sig=psd_inte2(psdin); dcomplex pi2i=COMPLEX(0, TWOPI); if(st->Hsys || st->Hwfs || st->Hint || st->s){ error("Already initialized\n"); } st->Hsys=cnew(nu->nx, 1); st->Hwfs=cnew(nu->nx, 1); st->Hint=cnew(nu->nx, 1); st->s=cnew(nu->nx,1); for(long i=0; i<nu->nx; i++){ dcomplex s=st->s->p[i]=pi2i*nu->p[i]; dcomplex zInv=cexp(-s*Ts); dcomplex Hint=st->Hint->p[i]=1./(1-zInv); dcomplex Hwfs, Hdac; if(dtrat==1){//we have a pure delay Hwfs=st->Hwfs->p[i]=zInv; Hdac=1; }else{ Hwfs=st->Hwfs->p[i]=(1-zInv)/(Ts*s); Hdac=Hwfs; } dcomplex Hlag=cexp(-s*dt);/*lag due to readout/computation*/ dcomplex Hmir=1;/*DM */ st->Hsys->p[i]=Hwfs*Hlag*Hdac*Hmir*Hint; } }
/** convert mod vector to ngs WFS cloc and add to it's opd or complex pupil function. Notice the the coordinate for each subaperture is different for TTF. */ void ngsmod2wvf(cmat *wvf, /**<[in/out] complex pupil function*/ double wvl, /**<[in] the wavelength*/ const dmat *modm, /**<[in] the NGS mode vector*/ const POWFS_S *powfs, /**<[in] the powfs configuration*/ int isa, /**<[in] index of subaperture*/ double thetax, /**<[in] direction of WFS*/ double thetay, /**<[in] direction of WFS*/ const PARMS_S *parms /**<[in] the parms*/ ){ const double *mod=modm->p; const dcomplex ik=COMPLEX(0, 2*M_PI/wvl); double dx=powfs->dxwvf; double ox=powfs->saloc->locx[isa]+dx*0.5; double oy=powfs->saloc->locy[isa]+dx*0.5; int nx=powfs->nxwvf; assert(wvf->nx==wvf->ny); dcomplex *p=wvf->p+(wvf->nx-nx)/2*(1+wvf->nx); if(modm->nx==2){ for(int iy=0; iy<nx; iy++){ double ym=(oy+iy*dx)*mod[1]; for(int ix=0; ix<nx; ix++){ double x=ox+ix*dx; double tmp=x*mod[0]+ym; p[ix+wvf->nx*iy]*=cexp(ik*tmp); } } }else{ const double hc=parms->maos.hc; const double hs=parms->maos.hs; const double scale=pow(1.-hc/hs, -2); const double scale1=1.-scale; double focus; if(modm->nx>5){ focus=mod[5]; if(!parms->maos.ahstfocus){ focus+=mod[2]*scale1; } }else{ focus=mod[2]*scale1; } for(int iy=0; iy<nx; iy++){ double y=oy+iy*dx; for(int ix=0; ix<nx; ix++){ double x=ox+ix*dx; double xy=x*y; double x2=x*x; double y2=y*y; double tmp= +x*mod[0] +y*mod[1] +focus*(x2+y2) +mod[2]*(-2*scale*hc*(thetax*x+thetay*y)) +mod[3]*((x2-y2)*scale1 - 2*scale*hc*(thetax*x-thetay*y)) +mod[4]*(xy*scale1-scale*hc*(thetay*x+thetax*y)); p[ix+wvf->nx*iy]*=cexp(ik*tmp); } } } }
/** * Initialisation of a transform plan, guru. * * \arg ths The pointer to a fpt plan * \arg N The number of source nodes * \arg M The number of target nodes * \arg sigma The parameter of the Gaussian * \arg n The polynomial expansion degree * \arg p the periodisation length, at least 1 * \arg m The spatial cut-off of the nfft * \arg flags FGT flags to use * * \author Stefan Kunis */ void fgt_init_guru(fgt_plan *ths, int N, int M, double _Complex sigma, int n, double p, int m, unsigned flags) { int j,n_fftw; fftw_plan fplan; ths->M = M; ths->N = N; ths->sigma = sigma; ths->flags = flags; ths->x = (double*)nfft_malloc(ths->N*sizeof(double)); ths->y = (double*)nfft_malloc(ths->M*sizeof(double)); ths->alpha = (double _Complex*)nfft_malloc(ths->N*sizeof(double _Complex)); ths->f = (double _Complex*)nfft_malloc(ths->M*sizeof(double _Complex)); ths->n = n; ths->p = p; ths->b = (double _Complex*)nfft_malloc(ths->n*sizeof(double _Complex)); ths->nplan1 = (nfft_plan*) nfft_malloc(sizeof(nfft_plan)); ths->nplan2 = (nfft_plan*) nfft_malloc(sizeof(nfft_plan)); n_fftw=X(next_power_of_2)(2*ths->n); nfft_init_guru(ths->nplan1, 1, &(ths->n), ths->N, &n_fftw, m, PRE_PHI_HUT| PRE_PSI| MALLOC_X| MALLOC_F_HAT| FFTW_INIT, FFTW_MEASURE); nfft_init_guru(ths->nplan2, 1, &(ths->n), ths->M, &n_fftw, m, PRE_PHI_HUT| PRE_PSI| MALLOC_X| FFTW_INIT, FFTW_MEASURE); ths->nplan1->f = ths->alpha; ths->nplan2->f_hat = ths->nplan1->f_hat; ths->nplan2->f = ths->f; if(ths->flags & FGT_APPROX_B) { fplan = fftw_plan_dft_1d(ths->n, ths->b, ths->b, FFTW_FORWARD, FFTW_MEASURE); for(j=0; j<ths->n; j++) ths->b[j] = cexp(-ths->p*ths->p*ths->sigma*(j-ths->n/2)*(j-ths->n/2)/ ((double)ths->n*ths->n)) / ths->n; nfft_fftshift_complex(ths->b, 1, &ths->n); fftw_execute(fplan); nfft_fftshift_complex(ths->b, 1, &ths->n); fftw_destroy_plan(fplan); } else { for(j=0; j<ths->n; j++) ths->b[j] = 1.0/ths->p * csqrt(PI/ths->sigma)* cexp(-PI*PI*(j-ths->n/2)*(j-ths->n/2)/ (ths->p*ths->p*ths->sigma)); } }
/*! \memberof splitop create new operator using values in prefs */ splitop_t * splitop_new(preferences_t * prefs) { splitop_t * w = malloc(sizeof(splitop_t)); assert(w); w->prefs = prefs; // cache values double * V = prefs->potential->data; int bins = prefs->bins; double dt = prefs->dt; double dk = prefs->dk; // allocate all the arrays needed w->eV = fftw_alloc_complex(bins); assert(w->eV); w->eVn = fftw_alloc_complex(bins); assert(w->eVn); w->ehV = fftw_alloc_complex(bins); assert(w->ehV); w->ehVn = fftw_alloc_complex(bins); assert(w->ehVn); w->eT = fftw_alloc_complex(bins); assert(w->eT); w->apsi = fftw_alloc_complex(bins); assert(w->apsi); w->psi = fftw_alloc_complex(bins); assert(w->psi); w->psik = fftw_alloc_complex(bins); assert(w->psik); for (int k = 0; k < bins; k++) { w->apsi[k] = 0; } // calculate position space propagators for (int n = 0; n < bins; n++) { w->eV[n] = cexp(-I * V[n] * dt); w->eVn[n] = w->eV[n] / bins; w->ehV[n] = cexp(-I * V[n] * dt / 2); w->ehVn[n] = w->ehV[n] / bins; } // calculate momentum space propagator for (int n = 0; n < bins; n++) { if (n < bins/2) { w->eT[n] = cexp(-I * dk * dk * n * n * dt); } else { // negative frequencies come after bins/2 int m = (n - bins); w->eT[n] = cexp(-I * dk * dk * m * m * dt); } } // prepare fftw plans for DFT w->fwd = fftw_plan_dft_1d(bins, w->psi, w->psik, FFTW_FORWARD, FFTW_MEASURE); w->bwd = fftw_plan_dft_1d(bins, w->psik, w->psi, FFTW_BACKWARD, FFTW_MEASURE); // setup initial system state wavefunction for (int k = 0; k < bins; k++) { w->psi[k] = prefs->psi->data[k]; } return w; }
static complex phi_recov_unif(const double u, const void *p_recovery) { params_recov_unif *p = (params_recov_unif *) p_recovery; complex z1; complex z2; complex result; if (u == 0) return(1.); z1 = cexp(I*u*(1-p->a)) - cexp(I*u*(1-p->b)); z2 = I*u*(p->b-p->a); result = z1 / z2; return ( result ); }
void init_LargeScale2DNoise(struct Field fldi) { int i,j,k; int num_force=0; int total_num_force; double fact; for( i = 0; i < NX_COMPLEX/NPROC; i++) { for( j = 0; j < NY_COMPLEX; j++) { k=0; if(kz[ IDX3D ] == 0.0) { if(pow(k2t[ IDX3D ], 0.5) / ( 2.0*M_PI ) < 1.0 / param.noise_cut_length_2D) { fldi.vx[ IDX3D ] += param.per_amplitude_large_2D * mask[IDX3D] * randm() * cexp( I * 2.0*M_PI*randm() ) * NTOTAL; fldi.vy[ IDX3D ] += param.per_amplitude_large_2D * mask[IDX3D] * randm() * cexp( I * 2.0*M_PI*randm() ) * NTOTAL; #ifdef MHD fldi.bx[ IDX3D ] += param.per_amplitude_large_2D * mask[IDX3D] * randm() * cexp( I * 2.0*M_PI*randm() ) * NTOTAL; fldi.by[ IDX3D ] += param.per_amplitude_large_2D * mask[IDX3D] * randm() * cexp( I * 2.0*M_PI*randm() ) * NTOTAL; #endif if(mask[IDX3D] > 0) num_force++; } } } } // Get the total number of forced scales. #ifdef MPI_SUPPORT MPI_Allreduce( &num_force, &total_num_force, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); #else total_num_force=num_force; #endif fact=pow(total_num_force,0.5); // Divide by the total number of modes for( i = 0; i < NX_COMPLEX/NPROC; i++) { for( j = 0; j < NY_COMPLEX; j++) { k=0; if(kz[ IDX3D ] == 0.0) { fldi.vx[ IDX3D ] = fldi.vx[ IDX3D ] / fact; fldi.vy[ IDX3D ] = fldi.vy[ IDX3D ] / fact; #ifdef MHD fldi.bx[ IDX3D ] = fldi.bx[ IDX3D ] / fact; fldi.by[ IDX3D ] = fldi.by[ IDX3D ] / fact; #endif } } } enforce_complex_symm(fldi); }
static void findroots(complex double a, complex double b, complex double c, complex double e[]) { int i; complex double p = (b - a * a / 3.) / 3.; complex double q = (2. * a * a * a / 27. - a * b / 3. + c) / 2.; complex double D = creal(p * p * p + q * q); /* MODEL SPECIFIC!!! */ double eps; assert(abs(cimag(p)) < 1e-10); assert(abs(creal(q)) < 1e-10); assert(abs(cimag(p * p * p + q * q)) < 1e-10); complex double upr = -q + csqrt(D); double mod_upr = pow(cabs(upr), 1. / 3.); double arg_upr = carg(upr); complex double umr = -q - csqrt(D); double mod_umr = pow(cabs(umr), 1. / 3.); double arg_umr = carg(umr); complex double rp = .5 * (-1. + I * sqrt(3.)); complex double rm = .5 * (-1. - I * sqrt(3.)); complex double up = mod_upr * cexp(I * arg_upr / 3.); for (eps = 1e-30; eps < 1e-6; eps *= 10.) { complex double um[3]; double sort[3]; for (i = 0; i < 3; i++) { um[i] = mod_umr * cexp(I*(2. * M_PI * i + arg_umr) / 3.); sort[i] = cabs((um[i] * up + p) / p); } qsort(sort, 3, sizeof(*sort), cmp); for (i = 0; i < 3; i++) { double test = cabs((um[i] * up + p) / p); if (test == sort[0] && test < eps) { e[0] = up + um[i] - a / 3.; e[1] = rp * up + rm * um[i] - a / 3.; e[2] = rm * up + rp * um[i] - a / 3.; return; } } } fprintf(stderr, "This should never happen!\n"); fprintf(stderr, "up=%lg%+lg*I p=%lg%+lg*I q=%lg%+lg*I D=%lg\n", creal(up), cimag(up), creal(p), cimag(p), creal(q), cimag(q), creal(D)); }
//! Creates the test signal // 0 (default): random // 1 : lin. comb. of exp's // 2 : exp + noise // 3 : sinc // 4 : gaussian // 5 : audio void create_signal(complex double *vec, int sz, int kind){ int i, sz2; double tmp; double *buf; FILE *fin; sz2 = sz>>1; switch (kind){ case 1: // sum of exp's -- tiled version for (i=0; i<sz; i++) vec[i] = cexp(I*i*M_PI*0.05) + exp(I*i*M_PI*0.075); break; case 2: // exp + noise -- tiled version srand(0); for (i=0; i<sz; i++) vec[i] = cexp(I*i*M_PI*0.05) + (rand()%(2001) - 1000)*1e-4; break; case 3: // sinc -- rescaled version tmp = 100./(double) sz; for (i=0; i<sz; i++) vec[i] = sin(tmp*(i-sz+1e-4)) / (tmp*(i-sz+1e-4)); break; case 4: // gaussian -- rescalled version for (i=0; i<sz; i++) vec[i] = exp(-tmp*pow(i-sz2,2)); break; case 5: // audio -- fixed length assert(sizeof(double)==8); fin = fopen("tests/music.dat", "rb"); if (!fin) { printf("Can't open tests/music.dat. Make sure the file is there!\n"); return; } buf = malloc( (1<<17)*sizeof(double) ); //jump initial noisy part fread(buf, sizeof(double), (1<<12) , fin); fread(buf, sizeof(double), (1<<17) , fin); fclose(fin); for (i=0; i<sz; i++) vec[i] = (double complex) buf[i%(1<<17)]; free(buf); break; default: srand(0); for (i=0; i<sz; i++) vec[i] = rand()%2001 - 1000; break; } }
Gamma * gamma_spline_calc_gamma (const GammaSpline *gs, double epsilon) { //int q=0; double kc; int Nkc = Nkc_from_epsilon(epsilon); Gamma * g = gamma_new (Nkc); double dkc=2*KCMAX/Nkc; double denom=pow(KCMAX,4); int q=Nkc/2; /* we do this in a funny order to keep phase oscillations out of the spectrum */ for (kc=-KCMAX+dkc;kc<KCMAX;kc=kc+dkc) { complex double a = gsl_interp_eval(gs->wx_spline_re,gs->k,gs->Wxr,kc,gs->w_accel)+I*gsl_interp_eval(gs->wx_spline_im,gs->k,gs->Wxi,kc,gs->w_accel); complex double b = cexp(-4*pow(fabs(kc),4)/denom+I*gsl_interp_eval(gs->phi_spline,gs->k,gs->phi,kc,gs->phi_accel)/epsilon); g->x[q]= a*b; a = gsl_interp_eval(gs->wy_spline_re,gs->k,gs->Wyr,kc,gs->w_accel)+I*gsl_interp_eval(gs->wy_spline_im,gs->k,gs->Wyi,kc,gs->w_accel); g->y[q]=a*b; a = gsl_interp_eval(gs->wz_spline_re,gs->k,gs->Wzr,kc,gs->w_accel)+I*gsl_interp_eval(gs->wz_spline_im,gs->k,gs->Wzi,kc,gs->w_accel); g->z[q]=a*b; q++; if (q==Nkc) q=0; } return g; }
// Function to generate the DFT/IDFT N x N Twiddle matrix to be passed to the GPU //! @param isIDFT IDFT/DFT option //! @param pTwiddleMatrix Generated twiddle matrix handle //! @param pTwiddleMatrix_z Generated twiddle matrix complex type handle void twiddleMatrixGen(bool isIDFT, Complex *pTwiddleMatrix, double complex *pTwiddleMatrix_z) { // Exponent return value double complex m_result; // Capture Twiddle Matrix reference for resetting pointer before return Complex *pTwiddleRef = pTwiddleMatrix; double complex *pTwiddleRef_z = pTwiddleMatrix_z; // Condition exponent sign bit and scaling on DFT or IDFT int sign = -1; float scale = 1; if ( !isIDFT ) { sign = 1; scale = 1 / static_cast<float> ( N ) ; } for ( int i = 0; i < N; ++i ) for ( int j = 0; j < N; ++j, ++pTwiddleMatrix, ++pTwiddleMatrix_z ) { m_result = cexp( sign * 2 * M_PI * i * j / N * I ) * scale; *pTwiddleMatrix_z = m_result; pTwiddleMatrix->x = creal( m_result ); pTwiddleMatrix->y = cimag( m_result ); } // Reset the Matrix pointers pTwiddleMatrix = pTwiddleRef; pTwiddleMatrix_z = pTwiddleRef_z; }
/* Y. L. Luke, 'The Special Functions and Their Approximation', vol II, p 304 */ complex float cgamma (complex float z) { static double coeff[7] = {41.624436916439068, -51.224241022374774, 11.338755813488977, -0.747732687772388, 0.008782877493061, -1.899030264e-6, 1.946335e-9}; complex double s,H,w; int n; if(creal(z) < 0.0) { complex double denom = 1.0; int flr = -floor(creal(z)); for (n = 0; n < flr; ++n) denom = denom * (z + n); return cgamma(z + flr) / denom; } else { w = z - 1.0; s = coeff[0]; H=1.0; for(n=1; n<7; n++) { H *= (w+1-n) / (w+n); s += coeff[n] * H; } return( 2.506628274631 * cexp(-w-5.5) * cpow(w+5.5,w+0.5) * s ); } }
inline void expMatTimesVec( fftw_complex *vec, const double *mat, const fftw_complex cc, const uint64_t N ){ uint64_t i; for( i = 0; i < N; i++ ){ vec[i] *= cexp( cc*mat[i] ); } }
void chirp_generator(matrix* time_vector, matrix* chirp, radar_variables* variables){ printf("Chirp start frequency (Hz): "); int ret = scanf("%li", &variables->start_frequency); if(variables->start_frequency < 0){ printf("Negative start frequency entered, closing.\n"); return; } printf("Chirp bandwidth (Hz): "); ret = scanf("%li", &variables->bandwidth); if(variables->bandwidth < 0){ printf("Negative bandwidth entered, closing.\n"); return; } printf("Chirp bandwidth-time product: "); ret = scanf("%u", &variables->btproduct); if(variables->btproduct < 1){ printf("Too small BT-product entered, closing.\n"); return; } double chirp_duration_s = (double)variables->btproduct/variables->bandwidth; double chirp_rate_hz_per_s = variables->bandwidth/(chirp_duration_s); unsigned int sample_frequency_hz = 2*variables->bandwidth; double sample_period = 1/(double)sample_frequency_hz; variables->chirp_samples = chirp_duration_s*sample_frequency_hz; variables->signal_distance = chirp_duration_s*C; printf("Chirp duration: %f (s)\n", chirp_duration_s); printf("Chirp rate: %lf (Hz/s)\n", chirp_rate_hz_per_s); printf("Sample frequency: %u (Hz)\n", sample_frequency_hz); printf("Chirp samples: %lf\n", variables->chirp_samples); printf("Uncompressed pulse resolution: %fm\n", variables->signal_distance); /* Allocate memory for the time vector and generate it. */ time_vector->rows = variables->chirp_samples; time_vector->cols = 1; time_vector->data = malloc(variables->chirp_samples*sizeof(complex double)); double last_time = 0; for(int i = 0; i < chirp_duration_s*sample_frequency_hz; i++){ time_vector->data[i] = last_time; last_time += sample_period; } /* Allocate memory for the chirp waveform and generate it. */ chirp->rows = variables->chirp_samples; chirp->cols = 1; chirp->data = malloc(variables->chirp_samples*sizeof(complex double)); for(int i = 0; i < variables->chirp_samples; i++){ double time = time_vector->data[i]; chirp->data[i] = cexp(_Complex_I*2*PI*(variables->start_frequency*time+chirp_rate_hz_per_s*time*time)); } }
/* check inside a radius */ static void taylor_check (const gchar *name, AranLaurentSeriesd *als, gcomplex128 (*func) (gcomplex128 z), gcomplex128 center, gdouble radius) { gcomplex128 z, res, ref; guint i, j; z = 0.; ref = func (z+center); res = aran_laurent_seriesd_evaluate (als, z); err (name, z+center, ref, res); for (i=0; i<=N; i ++) { gdouble r = i * radius / N; for (j=0; j<i; j ++) { gdouble arg = 2. * j * G_PI / i; z = r*cexp (I*arg); ref = func (z+center); res = aran_laurent_seriesd_evaluate (als, z); err (name, z+center, ref, res); } } }
//## Complex Complex.cexpl(); static KMETHOD Complex_cexpl(KonohaContext *kctx, KonohaStack *sfp) { kComplex *kc = (kComplex *) sfp[0].asObject; long double _Complex zl = (long double _Complex)kc->z; long double ret = cexp(zl); KReturnFloatValue(ret); }
//## Complex Complex.cexpf(); static KMETHOD Complex_cexpf(KonohaContext *kctx, KonohaStack *sfp) { kComplex *kc = (kComplex *) sfp[0].asObject; float _Complex zf = (float _Complex)kc->z; float ret = cexp(zf); KReturnFloatValue(ret); }
/* * fft * * Takes an input vector, output vector and a number of points * Performs a Fast Fourier Transform on the input vector * and stores it in the output vector. */ void fft( vector *in, vector *out, int n ) { int k; if( n == 1 ) VEC( out, 0 ) = VEC( in, 0 ); else { complex double wn = cexp( -2*M_PI*I / n ); vector *x, *y, *p, *q; create_vector( &x, n/2 ); create_vector( &y, n/2 ); create_vector( &p, n/2 ); create_vector( &q, n/2 ); for( k = 0; k < n/2; k++ ) { VEC( x, k ) = VEC( in, 2*k ); VEC( y, k ) = VEC( in, 2*k + 1 ); } fft( x, p, n/2 ); fft( y, q, n/2 ); for( k = 0; k < n; k++ ) { VEC( out, k ) = VEC( p, k % (n/2) ) + cpow(wn,k)*VEC( q, k % (n/2) ); } destroy_vector( x ); destroy_vector( y ); destroy_vector( p ); destroy_vector( q ); } }
int main(int argc,char *argv[]){ int i; double cphase; // Starting carrier phase double cstep; // Phase increment in radians/sample double complex v; struct sample s; cphase = Startphase; cstep = 2 * M_PI * Carrier / Samprate; Nsamp = 10 * Samprate; fprintf(stderr,"carrier %lf Hz, sample rate %lf Hz, amplitude %lf, phaseinc %lg rad/samp\n", Carrier,Samprate,Amplitude,cstep); for(i=0;i<Nsamp;i++){ v = Amplitude * cexp(I*cphase); s.i = creal(v); s.q = cimag(v); fwrite(&s,sizeof(s),1,stdout); // increment phase and reduce mod 2 pi cphase += cstep; if(cphase >= 2*M_PI) cphase -= 2*M_PI; } exit(0); }
static cmpl mult_layer_refl_ni_nojacob(int nb, const cmpl ns[], const double ds[], double lambda) { const double omega = 2 * M_PI / lambda; cmpl nt, nc, R; int j; nt = ns[nb-2]; nc = ns[nb-1]; R = refl_coeff_ni(nt, nc); for(j = nb - 3; j >= 0; j--) { cmpl r, rho, beta; cmpl den; double th = ds[j]; nc = nt; nt = ns[j]; beta = - 2.0 * I * omega * nc; rho = cexp(beta * THICKNESS_TO_NM(th)); r = refl_coeff_ni(nt, nc); den = 1 + r * R * rho; R = (r + R * rho) / den; } return R; }