static cut_result_t op_test(void) { complex_t a = { -1, 3 }; complex_t b = { 4, 0 }; CUT_ASSERT_COMPLEX(3, 3, complex_add(a, b)); CUT_ASSERT_COMPLEX(3, 3, complex_add(b, a)); CUT_ASSERT_COMPLEX(-5, 3, complex_sub(a, b)); CUT_ASSERT_COMPLEX(5, -3, complex_sub(b, a)); CUT_ASSERT_COMPLEX(-4, 12, complex_mul(a, b)); CUT_ASSERT_COMPLEX(-4, 12, complex_mul(b, a)); CUT_ASSERT_COMPLEX(-0.25, 0.75, complex_div(a, b)); CUT_ASSERT_COMPLEX(-0.4, -1.2, complex_div(b, a)); CUT_TEST_PASS(); }
complex_float complex_arccos(complex_float c1){ // arccos(z) = (pi/2) + i * log(i*z + sqrt(1 - z*z)) complex_float zz = complex_mul(c1,c1); complex_float a = complex_make(1.0f); a = complex_sub(a,zz); // 1 - z*z a = complex_pow(a,complex_make(0.5f)); // sqrt(...) complex_float iz = complex_i(c1); // i*z a = complex_add(iz,a); // i*z + sqrt(...) a = complex_ln(a); // log(...) a = complex_mul(complex_i(complex_make( 1.0f )),a); // i * log(...) complex_float r = complex_add( complex_make(1.57079632f), a); // pi/2 + ... return r; }
int main() { // Structures may be initialized at declaration time by putting // the list of elements in curly braces. struct complex_number c1 = {1.0, 1.0}; struct complex_number c2; c2.re = 2.0; c2.im = 4.0; printf("c1 = (%f,%f)\n", c1.re, c1.im); printf("c2 = (%f,%f)\n", c2.re, c2.im); struct complex_number result = complex_add(c1,c2); printf("c1 + c2 = (%f,%f)\n", result.re, result.im); struct complex_number *c_ptr; c_ptr = (struct complex_number*)malloc(sizeof(struct complex_number)); c_ptr->re = 7.0; c_ptr->im = -13.0; printf("*c_ptr = (%f,%f)\n", c_ptr->re, c_ptr->im); free(c_ptr); struct time t = {12,15,3}; time_dump(&t); time_init(&t); time_dump(&t); return 0; }
complex_float complex_cos(complex_float c1){ complex_float exp1 = complex_pow( complex_make(exp(1)), complex_i(c1) ); complex_float exp2 = complex_pow( complex_make(exp(1)), complex_mul(complex_make(-1.0f),complex_i(c1)) ); complex_float sum = complex_add(exp1,exp2); complex_float r = complex_div( sum, complex_make(2.0f) ); return r; }
static void ifftx(complex_t data[], complex_t temp[], int n) { int i; int h; int p; int t; int i2; complex_t wkt; if (n > 1) { h = n/2; for (i = 0; i < h; i++) { i2 = i*2; temp[i] = data[i2]; /* Even */ temp[h + i] = data[i2 + 1]; /* Odd */ } fftx(&temp[0], &data[0], h); fftx(&temp[h], &data[h], h); p = 0; t = MAX_FFT_LEN/n; for (i = 0; i < h; i++) { wkt = complex_mul(île[p], &temp[h + i]); data[i] = complex_add(&temp[i], &wkt); data[h + i] = complex_sub(&temp[i], &wkt); p += t; } } }
/* Normalized polynomials have the form of * x^n + a*x^(n-1) + .. * The coefficient for x^n is one. * solve_normalized_poly does expect to get this coefficient despite it being known. */ static int solve_normalized_poly(int degree, const complex_t* poly, complex_t* results) { const complex_t shift = complex_mult_real(-1.0 / (double) degree, poly[degree - 1]); complex_t shifted_coefs[MAX_DEGREE + 1]; int i, num_results; calc_shifted_coefs(shift, degree, poly, shifted_coefs); num_results = solve_depressed_poly(degree, shifted_coefs, results); for (i = 0; i < num_results; ++i) results[i] = complex_add(results[i], shift); return num_results; }
static inline void butterfly(osk_complex_t* r, const osk_complex_t* tf, int idx_a, int idx_b) { osk_complex_t up = r[idx_a]; osk_complex_t dn = r[idx_b]; //r[idx_a] = up + tf * dn; //r[idx_b] = up - tf * dn; osk_complex_t dntf = complex_mult(&dn, tf); r[idx_a] = complex_add(&up, &dntf); r[idx_b] = complex_sub(&up, &dntf); }
int main() { struct complex x, y, z; printf("첫번째 복소수를 입력하시오"); get_input(&x); printf("두번째 복소수를 입력하시오"); get_input(&y); z = complex_add(x, y); printf("%.1lf + %.1lfi\n", z.r, z.i); system("pause"); }
/* Based on http://en.wikipedia.org/wiki/Quartic_function#Quick_and_memorable_solution_from_first_principles */ static int solve_depressed_quartic(const complex_t* poly, complex_t* results) { complex_t helper_cubic[4]; complex_t helper_results[3]; complex_t quadratic_factor[3]; complex_t p, c_plus_p_sqr, d_div_p; const complex_t e = poly[0]; const complex_t d = poly[1]; const complex_t c = poly[2]; int num_results; if (complex_eq(d, complex_from_real(0.0))) { int i, num_quad_results; complex_t quadratic[3]; complex_t quadratic_results[2]; quadratic[0] = e; quadratic[1] = c; quadratic[2] = complex_from_real(1.0); num_quad_results = solve_poly(2, quadratic, quadratic_results); for (i = 0; i < num_quad_results; ++i) { const complex_t s = complex_sqrt(quadratic_results[i]); results[2*i] = complex_negate(s); results[2*i + 1] = s; } return 2 * num_quad_results; } helper_cubic[0] = complex_negate(complex_mult(d, d)); helper_cubic[1] = complex_add(complex_mult(c, c), complex_mult_real(-4.0, e)); helper_cubic[2] = complex_mult_real(2.0, c); helper_cubic[3] = complex_from_real(1.0); if (solve_poly(3, helper_cubic, helper_results) < 1) return 0; p = complex_sqrt(helper_results[0]); c_plus_p_sqr = complex_add(c, complex_mult(p, p)); d_div_p = complex_div(d, p); quadratic_factor[0] = complex_add(c_plus_p_sqr, complex_negate(d_div_p)); quadratic_factor[1] = complex_mult_real(2.0, p); quadratic_factor[2] = complex_from_real(2.0); num_results = solve_poly(2, quadratic_factor, results); quadratic_factor[0] = complex_add(c_plus_p_sqr, d_div_p); quadratic_factor[1] = complex_negate(quadratic_factor[1]); return num_results + solve_poly(2, quadratic_factor, results + num_results); }
static void calc_shifted_coefs(complex_t shift, int degree, const complex_t* src, complex_t* dst) { double binomials[MAX_DEGREE + 1][MAX_DEGREE + 1]; complex_t shift_powers[MAX_DEGREE + 1]; int dst_i, src_i; for (dst_i = 0; dst_i <= degree; ++dst_i) dst[dst_i] = complex_from_real(0.0); calc_binomials(degree+1, sizeof(binomials[0]) / sizeof(binomials[0][0]), binomials[0]); calc_powers(shift, degree, shift_powers); for (src_i = 0; src_i <= degree; ++src_i) for (dst_i = 0; dst_i <= src_i; ++dst_i) dst[dst_i] = complex_add(dst[dst_i], complex_mult_real(binomials[src_i][dst_i], complex_mult(src[src_i], shift_powers[src_i - dst_i]))); }
/* Based on http://en.wikipedia.org/wiki/Cubic_equation#Cardano.27s_method */ static int solve_depressed_cubic(const complex_t* poly, complex_t* results) { const complex_t q = poly[0]; const complex_t p = poly[1]; complex_t t, u, cubic_root_of_unity; int i; if (complex_eq(p, complex_from_real(0.0))) { results[0] = complex_pow_real(complex_negate(q), 1.0/3.0); return 1; } t = complex_add( complex_mult_real(0.25, complex_mult(q, q)), complex_mult_real(1.0/27.0, complex_mult(p, complex_mult(p, p)))); cubic_root_of_unity.real = -0.5; cubic_root_of_unity.imag = 0.5 * sqrt(3.0); for (i = 0; i < 3; ++i) { if (i == 0) u = complex_pow_real(complex_add(complex_mult_real(-0.5, q), complex_sqrt(t)), 1.0/3.0); else u = complex_mult(u, cubic_root_of_unity); results[i] = complex_add(u, complex_div(p, complex_mult_real(-3.0, u))); } return 3; }
complex_float complex_arcsin(complex_float c1){ // Hopefully I got this right, from a paper called: // "Implementing the Complex Arcsine and Arccosine Functions Using Exception Handling" // arcsin(z) = -i* log(i*z + sqrt(1 - z*z)) complex_float zz = complex_mul(c1,c1); complex_float a = complex_make(1.0f); a = complex_sub(a,zz); // 1 - z*z a = complex_pow(a,complex_make(0.5f)); // sqrt(...) complex_float iz = complex_i(c1); // i*z a = complex_add(iz,a); // i*z + sqrt(...) a = complex_ln(a); // log(...) complex_float r = complex_mul(complex_i(complex_make( -1.0f )),a); // -i * log(...) return r; }
void test_complex() { complexFloat c = complex_new(1,2); CU_ASSERT(c.real==1); CU_ASSERT(c.imag==2); complexFloat d = complex_add(c,complex_zero()); CU_ASSERT(d.real==1); CU_ASSERT(d.imag==2); d = complex_sub(c,complex_new(-1,-2)); CU_ASSERT(d.real==2); CU_ASSERT(d.imag==4); CU_ASSERT(within_tol(complex_amp(c),sqrt(5))); CU_ASSERT(within_tol(complex_amp(d),sqrt(20))); CU_ASSERT(within_tol(complex_amp_sqr(c),5)); CU_ASSERT(within_tol(complex_amp_sqr(d),20)); CU_ASSERT(within_tol(complex_amp(complex_scale(d,.5)),sqrt(5))); d = complex_conj(c); CU_ASSERT(d.real==1); CU_ASSERT(d.imag==-2); complexFloat e = complex_conj(complex_add(d,complex_conj(c))); CU_ASSERT(e.real==2); CU_ASSERT(e.imag==4); complexVector v = complex_vector_new(c,d,e); CU_ASSERT(v.A.real==1); CU_ASSERT(v.A.imag==2); CU_ASSERT(v.B.real==1); CU_ASSERT(v.B.imag==-2); CU_ASSERT(v.C.real==2); CU_ASSERT(v.C.imag==4); complexVector vc = complex_vector_conj(v); CU_ASSERT(vc.A.real==1); CU_ASSERT(vc.A.imag==-2); CU_ASSERT(vc.B.real==1); CU_ASSERT(vc.B.imag==2); CU_ASSERT(vc.C.real==2); CU_ASSERT(vc.C.imag==-4); }
void dwf_deriv( char *name) { /* * This marks the argument registers as defined by ABI as off limits * to us until they are freed by "getarg()"; */ int dum = defargcount(1); int retno; /* * S=phi^dag (MdagM)^-1 phi * * dS = phi^dag (MdagM)^-1 [ dMdag M + Mdag dM ] (MdagM)^-1 phi * * Let X = (MdagM)^-1 phi * Y = M X = M^-dag phi * * Want terms: Ydag dM X * Xdag dMdag Y * * Take Xdag 1-gamma Y * * Still a bit confused about the 1+g 1-g terms; but this may be simply a factor of two as we add +h.c. * Will continue to follow Chroma's routine */ reg_array_2d(Y,Cregs,4,3); // 4 spinor - 24 regs reg_array_2d(X,Cregs,4,3); // 4 spinor - 12 regs reg_array_1d(F,Cregs,3); // Force alreg(Z,Cregs); // Zero alreg(creg,Cregs); // Zero offset_3d(CHIIMM,FourSpinType,2,3,2*nsimd()); offset_3d(PSIIMM,FourSpinType,4,3,2*nsimd()); offset_3d(GIMM ,GaugeType, 3, 3 ,2*nsimd() ); def_off( GAUGE_SITE_IMM, FourSpinType,4*18*nsimd()); def_off( MAT_IMM , GaugeType,18*nsimd()); def_off( PSI_IMM , FourSpinType,24*nsimd()); def_off( CHI_IMM , FourSpinType,12*nsimd()); def_off( CONST_ZERO_OFFSET,Double,2*2*nsimd()); /* * Integer registers */ alreg(F_p,Iregs); /*Pointer to the current cpt of force field */ alreg(F_p_s,Iregs); alreg(Y_mu,Iregs); alreg(Y_p,Iregs); alreg(X_p,Iregs); alreg(length,Iregs); /*number of sites*/ alreg(tab,Iregs); /*Pointer to current entry in offset table*/ alreg(Complex_i,Iregs);/*Point to (0,1)x Nsimd*/ alreg(Ls,Iregs); alreg(s,Iregs); alreg(recbuf_base,Iregs); alreg(args,Iregs); alreg(s_offset,Iregs); /*Useful integer immediate constants, in units of Fsize*/ def_off( ZERO_IMM,Byte,0); def_off( minusone,Byte,-1); def_off( one,Byte,1); // Mask bits for predicating directions def_off( mask_0,Byte,1); def_off( mask_1,Byte,2); def_off( mask_2,Byte,4); def_off( mask_3,Byte,8); def_off( mask_4,Byte,16); def_off( mask_5,Byte,32); def_off( mask_6,Byte,64); def_off( mask_7,Byte,128); int mask_imm[8] = { mask_0, mask_1, mask_2, mask_3, mask_4, mask_5, mask_6, mask_7 }; alreg(mask ,Iregs); offset_1d(TAB_IMM,TableType,17); // Integer sizes int Isize = def_offset(PROC->I_size,Byte,"Isize"); int ISsize = def_offset(PROC->IS_size,Byte,"ISsize"); int i,j,co,sp; /*********************************************************************/ make_inst(DIRECTIVE,Enter_Routine,name); grab_stack(0); save_regs(); /********************************************* * our arguments ********************************************* */ getarg(args); /*Pointer to arg list*/ queue_iload(X_p, ZERO_IMM,args); queue_load_addr(args,Isize,args); //0 queue_iload(Y_p, ZERO_IMM,args); queue_load_addr(args,Isize,args); //1 queue_iload(F_p, ZERO_IMM,args); queue_load_addr(args,Isize,args); //2 queue_iload(length,ZERO_IMM,args); queue_load_addr(args,Isize,args); //3 queue_iload(Ls, ZERO_IMM,args); queue_load_addr(args,Isize,args); //4 queue_iload(tab, ZERO_IMM,args); queue_load_addr(args,Isize,args); //5 queue_iload(Complex_i,ZERO_IMM,args);queue_load_addr(args,Isize,args); //6 queue_load_addr(args,Isize,args); //7 queue_iload(recbuf_base,ZERO_IMM,args);queue_load_addr(args,Isize,args); //8 /************************************************** * Load common constants into Iregs ************************************************** */ for (int i =0; i<12; i++ ) { need_constant(i*2*SizeofDatum(FourSpinType)*nsimd()); } for (int i =0; i<9; i++ ) { need_constant(i*2*SizeofDatum(GaugeType)*nsimd()); } complex_constants_prepare(creg,Complex_i); complex_load(Z,CONST_ZERO_OFFSET,Complex_i,Double); // Site loop retno = get_target_label(); check_iterations(length,retno); int branchsite = start_loop(length); // S loop queue_iload_short(mask,TAB_IMM[10],tab); queue_iadd_imm (s,Ls,ZERO_IMM); queue_iload_imm(s_offset,ZERO_IMM); int branchls = start_loop(s); queue_iadd_imm(F_p_s,F_p,ZERO_IMM); // debugI(s); // Loop over directions for ( int mu=0;mu<4;mu++ ) { int dir = mu*2+1; // Always in forward dir // Complex branch structure for interior/exterior neighbours int lab_proj_mu = get_target_label(); int lab_continue = get_target_label(); queue_iand_imm (Y_mu,mask,mask_imm[dir]); // non-zero if exterior check_iterations(Y_mu,lab_proj_mu); // Exterior points are already projected. Just load. queue_iload_short(Y_mu,TAB_IMM[dir],tab); queue_iadd (Y_mu,Y_mu,recbuf_base); // debugI(Y_mu); //debugI(recbuf_base); queue_iadd (Y_mu,Y_mu,s_offset); for(int sp=0;sp<2;sp++){ for(int co=0;co<3;co++){ complex_load(Y[sp][co],PSIIMM[sp][co][0],Y_mu,FourSpinType); } } jump(lab_continue); make_inst(DIRECTIVE,Target,lab_proj_mu); // Interior points are not already projected. // * Spin project 4 spinor queue_iload_short(Y_mu,TAB_IMM[dir],tab); // debugI(tab); // debugI(Y_mu); queue_iadd (Y_mu,Y_mu,Y_p); queue_iadd (Y_mu,Y_mu,s_offset); // offset for this "s" queue_iadd (Y_mu,Y_mu,s_offset); // offset for this "s" for(int sp=0;sp<4;sp++){ for(int co=0;co<3;co++){ complex_load(X[sp][co],PSIIMM[sp][co][0],Y_mu,FourSpinType); // debugC(X[sp][co]); } } int pm = 1; // pm=0 == 1+gamma, pm=1 => 1-gamma if ( dagger ) pm = 0; if ( mu == 0 ) { if ( pm ==0 ) { for(co=0;co<3;co++) complex_ApiB(Y[0][co],X[0][co],X[3][co]); for(co=0;co<3;co++) complex_ApiB(Y[1][co],X[1][co],X[2][co]); } else { for(co=0;co<3;co++) complex_AmiB(Y[0][co],X[0][co],X[3][co]); for(co=0;co<3;co++) complex_AmiB(Y[1][co],X[1][co],X[2][co]); } } else if ( mu == 1 ) { if ( pm ==0 ) { for(co=0;co<3;co++) complex_sub(Y[0][co],X[0][co],X[3][co]); for(co=0;co<3;co++) complex_add(Y[1][co],X[1][co],X[2][co]); } else { for(co=0;co<3;co++) complex_add(Y[0][co],X[0][co],X[3][co]); for(co=0;co<3;co++) complex_sub(Y[1][co],X[1][co],X[2][co]); } } else if ( mu == 2 ) { if ( pm ==0 ) { for(co=0;co<3;co++) complex_ApiB(Y[0][co],X[0][co],X[2][co]); for(co=0;co<3;co++) complex_AmiB(Y[1][co],X[1][co],X[3][co]); } else { for(co=0;co<3;co++) complex_AmiB(Y[0][co],X[0][co],X[2][co]); for(co=0;co<3;co++) complex_ApiB(Y[1][co],X[1][co],X[3][co]); } } else if ( mu == 3 ) { if ( pm ==0 ) { for(co=0;co<3;co++) complex_add(Y[0][co],X[0][co],X[2][co]); for(co=0;co<3;co++) complex_add(Y[1][co],X[1][co],X[3][co]); } else { for(co=0;co<3;co++) complex_sub(Y[0][co],X[0][co],X[2][co]); for(co=0;co<3;co++) complex_sub(Y[1][co],X[1][co],X[3][co]); } } make_inst(DIRECTIVE,Target,lab_continue); /////////////////////////////////////////////////////////////// // Y contains spin projection of forward neighbour in mu direction // Repromote to Y to 4 spinor /////////////////////////////////////////////////////////////// for(int co_y=0;co_y<3;co_y++){ if ( (mu==0) && (pm==0) ) complex_AmiB(Y[2][co_y],Z,Y[1][co_y]); if ( (mu==0) && (pm==1) ) complex_ApiB(Y[2][co_y],Z,Y[1][co_y]); if ( (mu==1) && (pm==0) ) complex_add (Y[2][co_y],Z,Y[1][co_y]); if ( (mu==1) && (pm==1) ) complex_sub (Y[2][co_y],Z,Y[1][co_y]); if ( (mu==2) && (pm==0) ) complex_AmiB(Y[2][co_y],Z,Y[0][co_y]); if ( (mu==2) && (pm==1) ) complex_ApiB(Y[2][co_y],Z,Y[0][co_y]); if ( (mu==3) && (pm==0) ) complex_add (Y[2][co_y],Z,Y[0][co_y]); if ( (mu==3) && (pm==1) ) complex_sub (Y[2][co_y],Z,Y[0][co_y]); if ( (mu==0) && (pm==0) ) complex_AmiB(Y[3][co_y],Z,Y[0][co_y]); if ( (mu==0) && (pm==1) ) complex_ApiB(Y[3][co_y],Z,Y[0][co_y]); if ( (mu==1) && (pm==0) ) complex_sub (Y[3][co_y],Z,Y[0][co_y]); if ( (mu==1) && (pm==1) ) complex_add (Y[3][co_y],Z,Y[0][co_y]); if ( (mu==2) && (pm==0) ) complex_ApiB(Y[3][co_y],Z,Y[1][co_y]); if ( (mu==2) && (pm==1) ) complex_AmiB(Y[3][co_y],Z,Y[1][co_y]); if ( (mu==3) && (pm==0) ) complex_add (Y[3][co_y],Z,Y[1][co_y]); if ( (mu==3) && (pm==1) ) complex_sub (Y[3][co_y],Z,Y[1][co_y]); } /////////////////////////////////////////////////////////////// // Load X /////////////////////////////////////////////////////////////// for(int co_x=0;co_x<3;co_x++){ for(int sp=0;sp<4;sp++) { complex_load(X[sp][co_x],PSIIMM[sp][co_x][0],X_p,FourSpinType); } } /////////////////////////////////////////////////////////////// // Spin trace tensor product /////////////////////////////////////////////////////////////// for(int co_x=0;co_x<3;co_x++){ // Spin trace outer product for ( int co_y=0;co_y<3;co_y++) complex_load (F[co_y],GIMM[co_y][co_x][0],F_p_s); for ( int co_y=0;co_y<3;co_y++) complex_conjmadd(F[co_y],X[0][co_x],Y[0][co_y]); for ( int co_y=0;co_y<3;co_y++) complex_conjmadd(F[co_y],X[1][co_x],Y[1][co_y]); for ( int co_y=0;co_y<3;co_y++) complex_conjmadd(F[co_y],X[2][co_x],Y[2][co_y]); for ( int co_y=0;co_y<3;co_y++) complex_conjmadd(F[co_y],X[3][co_x],Y[3][co_y]); for ( int co_y=0;co_y<3;co_y++) complex_store(F[co_y],GIMM[co_y][co_x][0],F_p_s); } queue_load_addr(F_p_s,MAT_IMM,F_p_s); } queue_iadd_imm(X_p,X_p,PSI_IMM); queue_iadd_imm(s_offset,s_offset,CHI_IMM); stop_loop(branchls,s); queue_iadd_imm(F_p,F_p_s,ZERO_IMM); queue_load_addr(tab,TAB_IMM[16],tab); stop_loop(branchsite,length); make_inst(DIRECTIVE,Target,retno); /* * * EPILOGUE * */ restore_regs(); free_stack(); make_inst(DIRECTIVE,Exit_Routine,name); return; }
struct signal* fft(struct signal* p_signal) { struct signal* p_input_signal = \ (struct signal*) malloc(sizeof(struct complex_number)*(p_signal->size) + sizeof(p_signal->size)); struct signal* p_out_put_signal = \ (struct signal*)malloc(sizeof(struct complex_number)*(p_signal->size) + sizeof(p_signal->size)); *p_input_signal = *p_signal; *p_out_put_signal = *p_signal; int tmp = 0; int index = 0; int bits = 0; int layyer= 0; int selected_point = 0; int pre_half = 0; int r = 0; double x = 0; struct complex_number W_rN ; struct complex_number complex_tmp ; /* ** We caculate how many bits should be used to ** represent the size of the number of input signal. */ for(tmp = p_signal->size-1;tmp > 0;tmp>>=1) { bits++; } /* ** We should re-sequence the input signal ** by bit-reverse. */ for(tmp = 0;tmp < p_signal->size;tmp++) { index = reverse_bits(tmp,bits); p_input_signal->points[tmp] = p_signal->points[index]; #ifdef DEBUG printf(" tmp:%5d index:%5d ",tmp,index); show_complex_number(&p_signal->points[index]); #endif } for(layyer = 1;layyer <= bits;layyer++) { #ifdef DEBUG printf("layyer %d input\n",layyer); show_signal(p_input_signal); #endif for(selected_point = 0;selected_point < p_signal->size;selected_point += 1<<(layyer)) { for(pre_half = selected_point,r = 0,x = 0; pre_half < (selected_point + (1<<(layyer-1))); pre_half++) { r = get_r_in_Wn(pre_half,layyer,bits); #ifdef DEBUG printf("r: %d\n",r); #endif x = -2*PI*r/((double)(p_input_signal->size)); W_rN.real = cos(x); W_rN.imagine = sin(x); complex_tmp = complex_mul(&W_rN , &(p_input_signal->points[pre_half + (1<<(layyer-1))]) ); #ifdef DEBUG show_complex_number(&complex_tmp); #endif p_out_put_signal->points[pre_half] = \ complex_add(&p_input_signal->points[pre_half],&complex_tmp); p_out_put_signal->points[pre_half + (1<<(layyer-1))] = \ complex_sub(&p_input_signal->points[pre_half],&complex_tmp); } } #ifdef DEBUG printf("layyer%d output\n",layyer); show_signal(p_out_put_signal); #endif for(tmp = 0;tmp < p_out_put_signal->size;tmp++) { p_input_signal->points[tmp] = p_out_put_signal->points[tmp]; } } free(p_input_signal); return p_out_put_signal; }
void operator_complex() { double complex result; char in[USHRT_MAX]; double real; double imag; printf("Entre com a 1º parte real: "); scanf("%s", in); printf("\n"); real = atof(in); printf("Entre com a 1º parte imaginaria: "); scanf("%s", in); printf("\n"); imag = atof(in); result = complex_constructor(real, imag); int keep_going = 1; while (keep_going) { switch (menu_complex()) { case 1: // Add printf("Entre com a próxima parte real: "); scanf("%s", in); printf("\n"); real = atof(in); printf("Entre com a próxima parte imaginaria: "); scanf("%s", in); printf("\n"); imag = atof(in); complex_add(&result, complex_constructor(real, imag)); break; case 2: // Subtract printf("Entre com a próxima parte real: "); scanf("%s", in); printf("\n"); real = atof(in); printf("Entre com a próxima parte imaginaria: "); scanf("%s", in); printf("\n"); imag = atof(in); complex_subtract(&result, complex_constructor(real, imag)); break; case 3: // Multiply printf("Entre com a próxima parte real: "); scanf("%s", in); printf("\n"); real = atof(in); printf("Entre com a próxima parte imaginaria: "); scanf("%s", in); printf("\n"); imag = atof(in); complex_multiply(&result, complex_constructor(real, imag)); break; case 4: // Power printf("Entre com o próximo valor: "); scanf("%s", in); printf("\n"); complex_power(&result, atof(in)); break; case 5: // Divide while (1) { printf("Entre com a próxima parte real: "); scanf("%s", in); printf("\n"); real = atof(in); printf("Entre com a próxima parte imaginaria: "); scanf("%s", in); printf("\n"); imag = atof(in); if (real == 0 && imag == 0) printf("Combinação de valores inválida!\n\n"); else break; } complex_divide(&result, complex_constructor(real, imag)); break; default: keep_going = 0; break; } char *string = complex_string(result); printf("Resultado: %s\n\n", string); free(string); } }