void CIIRfilter::lowpass(complex *p, char *ptype, int np, double *sn, double *sd, int *ns ) { int iptr, i; *ns = 0; iptr = 0; for (i = 0; i < np; i++) { if ( ptype[i] == 'C' ) { sn[iptr] = 1.; sn[iptr + 1] = 0.; sn[iptr + 2] = 0.; sd[iptr] = real_part(cmplx_mul(p[i],cmplx_conjg(p[i]))); sd[iptr + 1] = -2. * real_part( p[i] ); sd[iptr + 2] = 1.; iptr = iptr + 3; *ns = *ns + 1; } else if ( ptype[i] == 'S' ) { sn[ iptr ] = 1.; sn[ iptr + 1 ] = 0.; sn[ iptr + 2 ] = 0.; sd[ iptr ] = -real_part( p[i] ); sd[ iptr + 1 ] = 1.; sd[ iptr + 2 ] = 0.; iptr = iptr + 3; *ns = *ns + 1; } } }
void CIIRfilter::lp_to_hp(complex p[], char ptype[], int np, double sn[], double sd[], int *ns ) { int i, iptr; *ns = 0; iptr = 0; for (i = 0; i < np; i++) { if (ptype[i] == 'C' ) { sn[ iptr ] = 0.f; sn[ iptr + 1 ] = 0.f; sn[ iptr + 2 ] = 1.f; sd[ iptr ] = 1.f; sd[ iptr + 1 ] = -2.f * real_part( p[i] ); sd[ iptr + 2 ] = real_part(cmplx_mul(p[i], cmplx_conjg(p[i]))); iptr = iptr + 3; *ns = *ns + 1; } else if ( ptype[i] == 'S' ) { sn[ iptr ] = 0.; sn[ iptr + 1 ] = 1.; sn[ iptr + 2 ] = 0.; sd[ iptr ] = 1.; sd[ iptr + 1 ] = -real_part( p[i] ); sd[ iptr + 2 ] = 0.; iptr = iptr + 3; *ns = *ns + 1; } } }
void CIIRfilter::lp_to_bp( complex *p, char *ptype, int np, double fl, double fh, double *sn, double *sd, int *ns ) { complex ctemp, p1, p2; double pi, twopi, a, b; int i, iptr; pi = M_PI; twopi = 2.*pi; a = twopi*twopi*fl*fh; b = twopi*( fh - fl ); *ns = 0; iptr = 0; for (i = 0; i < np; i++) { if ( ptype[i] == 'C' ) { ctemp = real_cmplx_mul(b, p[i]); ctemp = cmplx_mul(ctemp, ctemp); ctemp = cmplx_sub(ctemp, cmplx(4.*a, 0.)); ctemp = cmplx_sqrt( ctemp ); p1 = real_cmplx_mul(0.5, cmplx_add(real_cmplx_mul(b,p[i]), ctemp)); p2 = real_cmplx_mul(0.5, cmplx_sub(real_cmplx_mul(b,p[i]), ctemp)); sn[ iptr ] = 0.; sn[ iptr + 1 ] = b; sn[ iptr + 2 ] = 0.; sd[iptr] = real_part(cmplx_mul(p1, cmplx_conjg(p1))); sd[ iptr + 1 ] = -2. * real_part( p1 ); sd[ iptr + 2 ] = 1.; iptr = iptr + 3; sn[ iptr ] = 0.; sn[ iptr + 1 ] = b; sn[ iptr + 2 ] = 0.; sd[iptr] = real_part(cmplx_mul(p2, cmplx_conjg(p2))); sd[ iptr + 1 ] = -2. * real_part( p2 ); sd[ iptr + 2 ] = 1.; iptr = iptr + 3; *ns = *ns + 2; } else if ( ptype[i] == 'S' ) { sn[ iptr ] = 0.; sn[ iptr + 1 ] = b; sn[ iptr + 2 ] = 0.; sd[ iptr ] = a; sd[ iptr + 1 ] = -b*real_part( p[i] ); sd[ iptr + 2 ] = 1.; iptr = iptr + 3; *ns = *ns + 1; } } }
static Lisp_Object pluscc(Lisp_Object a, Lisp_Object b) /* * Add complex values. */ { Lisp_Object c, nil; push2(a, b); c = plus2(imag_part(a), imag_part(b)); pop2(b, a); errexit(); a = plus2(real_part(a), real_part(b)); errexit(); return make_complex(a, c); }
int main(void) { const double pi = 3.1415926; struct complex_struct z1 = make_from_real_img(2, 4), z2 = make_from_mag_ang(10, pi / 4); printf("z1:\nreal_part = %f\nimg_part = %f\nmagnitude = %f\nangle = %f\n", real_part(z1), img_part(z1), magnitude(z1), angle(z1)); printf("\n\n"); printf("z2:\nreal_part = %f\nimg_part = %f\nmagnitude = %f\nangle = %f\n", real_part(z2), img_part(z2), magnitude(z2), angle(z2)); return 0; }
Lisp_Object make_complex(Lisp_Object r, Lisp_Object i) { Lisp_Object v, nil = C_nil; /* * Here r and i are expected to be either both rational (which in this * context includes the case of integer values) or both of the same * floating point type. It is assumed that this has already been * arranged by here. */ if (i == fixnum_of_int(0)) return r; stackcheck2(0, r, i); push2(r, i); v = getvector(TAG_NUMBERS, TYPE_COMPLEX_NUM, sizeof(Complex_Number)); /* * The vector r has uninitialized contents here - dodgy. If the call * to getvector succeeded then I fill it in, otherwise I will not * refer to it again, and I think that unreferenced vectors containing junk * are OK. */ pop2(i, r); errexit(); real_part(v) = r; imag_part(v) = i; return v; }
static Lisp_Object Lrealpart(Lisp_Object nil, Lisp_Object a) { CSL_IGNORE(nil); if (!is_number(a)) return aerror1("realpart", a); if (is_numbers(a) && is_complex(a)) return onevalue(real_part(a)); else return onevalue(a); }
int main() { COMPLEX_FLOAT f = 1.0f + _Complex_I; float r1 = real_part(f); float r2 = real_part_2(f); return r1 - r2; }
// If x is real then Re(e).diff(x) is equal to Re(e.diff(x)) static ex real_part_expl_derivative(const ex & arg, const symbol & s) { if (s.info(info_flags::real)) return real_part_function(arg.diff(s)); else { exvector vec_arg; vec_arg.push_back(arg); return fderivative(ex_to<function>(real_part(arg)).get_serial(),0,vec_arg).hold()*arg.diff(s); } }
static Lisp_Object plusic(Lisp_Object a, Lisp_Object b) /* * real of any sort plus complex. */ { Lisp_Object nil; push(b); a = plus2(a, real_part(b)); pop(b); errexit(); /* * make_complex() takes responsibility for mapping #C(n 0) onto n */ return make_complex(a, imag_part(b)); }
static Lisp_Object Lconjugate(Lisp_Object nil, Lisp_Object a) { if (!is_number(a)) return aerror1("conjugate", a); if (is_numbers(a) && is_complex(a)) { Lisp_Object r = real_part(a), i = imag_part(a); push(r); i = negate(i); pop(r); errexit(); a = make_complex(r, i); errexit(); return onevalue(a); } else return onevalue(a); }
void register_abs_entry( size_type const ug_index, value_type const ug_value, value_type progress_ratio ) { size_type const m = ug_size; matrix_type real_part(m, 1); matrix_type imag_part(m, 1); std::fill( real_part.begin(), real_part.end(), value_type{} ); std::fill( imag_part.begin(), imag_part.end(), value_type{} ); value_type const weigh = ( value_type{1} - progress_ratio ) * std::sqrt( static_cast<value_type>(m) ); value_type const intensity = value_type{2} * weigh * ug_value * weigh * ug_value; real_part[ug_index][0] = weigh; imag_part[ug_index][0] = weigh; dsm.register_entry( intensity, real_part.begin(), imag_part.begin() ); }
CSLbool onep(Lisp_Object a) { switch ((int)a & TAG_BITS) { case TAG_FIXNUM: return (a == fixnum_of_int(1)); case TAG_NUMBERS: /* #C(r i) must satisfy onep(r) and zerop(i) */ if (is_complex(a) && onep(real_part(a))) return zerop(imag_part(a)); else return NO; case TAG_SFLOAT: { Float_union w; w.f = (float)1.0; return (a == (w.i & ~(int32_t)0xf) + TAG_SFLOAT); } case TAG_BOXFLOAT: return (float_of_number(a) == 1.0); default: return NO; } }
CSLbool zerop(Lisp_Object a) { switch ((int)a & TAG_BITS) { case TAG_FIXNUM: return (a == fixnum_of_int(0)); case TAG_NUMBERS: /* #C(r i) must satisfy zerop is r and i both do */ if (is_complex(a) && zerop(real_part(a))) return zerop(imag_part(a)); else return NO; case TAG_SFLOAT: /* * The code here assumes that the the floating point number zero * is represented by a zero bit-pattern... see onep() for a more * cautious way of coding things. */ return ((a & 0x7ffffff8) == 0); /* Strip sign bit as well as tags */ case TAG_BOXFLOAT: return (float_of_number(a) == 0.0); default: return NO; } }
void register_entry( size_matrix_type const& ar, value_type alpha, complex_matrix_type const& lhs_matrix, complex_matrix_type const& rhs_matrix, value_type beta, complex_matrix_type const& expm_matrix, matrix_type const& intensity, size_type const column_index = 0 ) { assert( ar.row() == ar.col() ); assert( ar.row() == lhs_matrix.row() ); assert( lhs_matrix.row() == lhs_matrix.col() ); assert( ar.row() == rhs_matrix.row() ); assert( ar.row() == intensity.row() ); assert( 1 == intensity.col() ); assert( (*(std::max_element(ar.begin(), ar.end()))) < ug_size ); assert( alpha >= value_type{0} ); assert( beta >= value_type{0} ); assert( alpha <= value_type{1} ); assert( beta <= value_type{1} ); assert( std::abs(alpha+beta-value_type{1}) < value_type{ 1.0e-10} ); //assert( c1_matrix.row() == ar.row() ); //assert( c1_matrix.col() == 1 ); assert( expm_matrix.row() == ar.row() ); assert( expm_matrix.col() == 1 ); assert( column_index < ar.row() ); size_type const n = ar.row(); size_type const m = ug_size; matrix_type real_part(m, 1); matrix_type imag_part(m, 1); value_type norm_factor{0}; //norm only one column //std::for_each( expm_matrix.col_begin( column_index ), expm_matrix.col_end( column_index ), [&norm_factor]( complex_type const& c ){ norm_factor += std::norm(c); } ); std::for_each( expm_matrix.begin(), expm_matrix.end(), [&norm_factor]( complex_type const& c ){ norm_factor += std::norm(c); } ); norm_factor /= static_cast<value_type>( expm_matrix.row() ); for ( size_type r = 0; r != ar.row(); ++r ) { //for \beta C/2 C/2 part extract_inner_product_coefficients( m, n, ar.row_begin(r), lhs_matrix.row_begin(r), rhs_matrix.col_begin(column_index), real_part.begin(), imag_part.begin() ); real_part *= alpha; imag_part *= alpha; //for \gamma E part real_part[0][0] += beta * std::real( expm_matrix[r][column_index] ); imag_part[0][0] += beta * std::imag( expm_matrix[r][column_index] ); //real_part[0][0] += beta * std::real( expm_matrix[r][column_index] ) / norm_factor; //imag_part[0][0] += beta * std::imag( expm_matrix[r][column_index] ) / norm_factor; //needs modifying here dsm.register_entry( intensity[r][0], real_part.begin(), imag_part.begin() ); } #if 0 //register lambda, ensuring lambda to be 1 std::fill( real_part.begin(), real_part.end(), value_type{} ); value_type const factor = value_type{1.0}; value_type const weigh = factor * std::sqrt( static_cast<value_type>( intensity.row() ) ); real_part[0][0] = weigh; imag_part[0][0] = weigh; dsm.register_entry( value_type{2} * weigh * weigh, real_part.begin(), imag_part.begin() ); #endif }
static CSLbool numeqic(Lisp_Object a, Lisp_Object b) { if (!zerop(imag_part(b))) return NO; else return numeq2(a, real_part(b)); }
static CSLbool numeqcc(Lisp_Object a, Lisp_Object b) { return numeq2(real_part(a), real_part(b)) && numeq2(imag_part(a), imag_part(b)); }
//--------------------------------------------------------------------------------------------------- complex add_complex(complex a, complex b){ return make_from_real_img(real_part(a)+real_part(b), img_part(a)+img_part(b)); }
complex minus_complex(complex a, complex b){ return make_from_real_img(real_part(a)-real_part(b), img_part(a)-img_part(b)); }
Lisp_Object negate(Lisp_Object a) { #ifdef COMMON Lisp_Object nil; /* needed for errexit() */ #endif switch ((int)a & TAG_BITS) { case TAG_FIXNUM: { int32_t aa = -int_of_fixnum(a); /* * negating the number -#x8000000 (which is a fixnum) yields a value * which just fails to be a fixnum. */ if (aa != 0x08000000) return fixnum_of_int(aa); else return make_one_word_bignum(aa); } #ifdef COMMON case TAG_SFLOAT: { Float_union aa; aa.i = a - TAG_SFLOAT; aa.f = (float) (-aa.f); return (aa.i & ~(int32_t)0xf) + TAG_SFLOAT; } #endif case TAG_NUMBERS: { int32_t ha = type_of_header(numhdr(a)); switch (ha) { case TYPE_BIGNUM: return negateb(a); #ifdef COMMON case TYPE_RATNUM: { Lisp_Object n = numerator(a), d = denominator(a); push(d); n = negate(n); pop(d); errexit(); return make_ratio(n, d); } case TYPE_COMPLEX_NUM: { Lisp_Object r = real_part(a), i = imag_part(a); push(i); r = negate(r); pop(i); errexit(); push(r); i = negate(i); pop(r); errexit(); return make_complex(r, i); } #endif default: return aerror1("bad arg for minus", a); } } case TAG_BOXFLOAT: { double d = float_of_number(a); return make_boxfloat(-d, type_of_header(flthdr(a))); } default: return aerror1("bad arg for minus", a); } }
boost::multi_array<double, DIMENSION> get_real_parts(const boost::multi_array<SCALAR, DIMENSION> &data) { boost::multi_array<double, DIMENSION> real_part(data.shape()); std::transform(data.begin(), data.end(), real_part.begin(), get_real); return real_part; };