CRFPConstMult::CRFPConstMult(Target* target, int wE_in, int wF_in, int wE_out, int wF_out, string _constant):
FPConstMult(target, wE_in, wF_in, wE_out, wF_out),
constant (_constant)
{
#if 0
sollya_obj_t node;
mpfr_t mpR;
mpz_t zz;
srcFileName="CRFPConstMult";
/* Convert the input string into a sollya evaluation tree */
node = sollya_lib_parse_string(constant.c_str());
/* If parse error throw an exception */
if (sollya_lib_obj_is_error(node))
{
ostringstream error;
error << srcFileName << ": Unable to parse string "<< constant << " as a numeric constant" <<endl;
throw error.str();
}
mpfr_inits(mpR, NULL);
sollya_lib_get_constant(mpR, node);
if(verbose){
double r;
r = mpfr_get_d(mpR, GMP_RNDN);
cout << " Constant evaluates to " <<r <<endl;
}
// compute the precision -- TODO with NWB
cst_width = 2*wF_in+4;
REPORT(0, "***** WARNING Taking constant with 2*wF_in+4 bits. Correct rounding is not yet guaranteed. This is being implemented." );
REPORT(INFO, "Required significand precision to reach correct rounding is " << cst_width );
mpfr_set_prec(mpfrC, cst_width);
sollya_lib_get_constant(mpR, node);
// Now convert mpR into exponent + integral significand
// sign
cst_sgn = mpfr_sgn(mpR);
if(cst_sgn<0)
mpfr_neg(mpR, mpR, GMP_RNDN);
// compute exponent and mantissa
cst_exp_when_mantissa_1_2 = mpfr_get_exp(mpR) - 1; //mpfr_get_exp() assumes significand in [1/2,1)
cst_exp_when_mantissa_int = cst_exp_when_mantissa_1_2 - cst_width + 1;
mpfr_init2(mpfr_cst_sig, cst_width);
mpfr_div_2si(mpfr_cst_sig, mpR, cst_exp_when_mantissa_1_2, GMP_RNDN);
REPORT(INFO, "mpfr_cst_sig = " << mpfr_get_d(mpfr_cst_sig, GMP_RNDN));
// Build the corresponding FPConstMult.
// initialize mpfr_xcut_sig = 2/cst_sig, will be between 1 and 2
mpfr_init2(mpfr_xcut_sig, 32*(cst_width+wE_in+wE_out)); // should be accurate enough
mpfr_set_d(mpfr_xcut_sig, 2.0, GMP_RNDN); // exaxt op
mpfr_div(mpfr_xcut_sig, mpfr_xcut_sig, mpfr_cst_sig, GMP_RNDD);
// now round it down to wF_in+1 bits
mpfr_t xcut_wF;
mpfr_init2(xcut_wF, wF_in+1);
mpfr_set(xcut_wF, mpfr_xcut_sig, GMP_RNDD);
mpfr_mul_2si(xcut_wF, xcut_wF, wF_in, GMP_RNDN);
// It should now be an int; cast it into a mpz, then a mpz_class
mpz_init2(zz, wF_in+1);
mpfr_get_z(zz, xcut_wF, GMP_RNDN);
xcut_sig_rd = mpz_class(zz);
mpz_clear(zz);
REPORT(DETAILED, "mpfr_xcut_sig = " << mpfr_get_d(mpfr_xcut_sig, GMP_RNDN) );
// Now build the mpz significand
mpfr_mul_2si(mpfr_cst_sig, mpfr_cst_sig, cst_width, GMP_RNDN);
// It should now be an int; cast it into a mpz, then a mpz_class
mpz_init2(zz, cst_width);
mpfr_get_z(zz, mpfr_cst_sig, GMP_RNDN);
cst_sig = mpz_class(zz);
mpz_clear(zz);
REPORT(DETAILED, "mpzclass cst_sig = " << cst_sig);
// build the name
ostringstream name;
name <<"FPConstMult_"<<(cst_sgn==0?"":"M") <<cst_sig<<"b"
<<(cst_exp_when_mantissa_int<0?"M":"")<<abs(cst_exp_when_mantissa_int)
<<"_"<<wE_in<<"_"<<wF_in<<"_"<<wE_out<<"_"<<wF_out;
uniqueName_=name.str();
// cleaning up
mpfr_clears(mpR, mpfr_xcut_sig, xcut_wF, mpfr_cst_sig, NULL);
icm = new IntConstMult(target, wF_in+1, cst_sig);
oplist.push_back(icm);
buildVHDL();
#endif
}
void FixComplexKCM::init()
{
if(lsb_in>msb_in)
{
throw string("FixComplexKCM: Error, lsbIn>msbIn");
}
// definition of the source file name, used for info and error reporting
// using REPORT
srcFileName="FixComplexKCM";
// definition of the name of the operator
ostringstream name;
name << "FixComplexKCM_" << vhdlize(msb_in) <<"_" << vhdlize(lsb_in)
<< "_" << vhdlize(lsb_out) << "_" << vhdlize(constant_re) << "_" <<
vhdlize(constant_im) << "_" << ((signedInput) ? "" : "un") <<
"signed" ;
setName(name.str());
// Copyright
setCopyrightString("3IF 2015 dev team (2015)");
input_width = 1 + msb_in - lsb_in;
// declaring inputs
addInput ("ReIN" , input_width);
addInput ("ImIN" , input_width);
//Computing constants for testBench and in order to know constant width
sollya_obj_t nodeIm, nodeRe;
nodeRe = sollya_lib_parse_string(constant_re.c_str());
if(sollya_lib_obj_is_error(nodeRe))
{
ostringstream error;
error << srcFileName <<" : Unable to parse string \"" <<
constant_re << "\" as a numeric constant" << endl;
throw error.str();
}
nodeIm = sollya_lib_parse_string(constant_im.c_str());
if(sollya_lib_obj_is_error(nodeIm))
{
ostringstream error;
error << srcFileName <<" : Unable to parse string \"" <<
constant_im << "\" as a numeric constant" << endl;
throw error.str();
}
mpfr_inits2(10000, mpfr_constant_re, mpfr_constant_im, NULL);
sollya_lib_get_constant(mpfr_constant_re, nodeRe);
sollya_lib_get_constant(mpfr_constant_im, nodeIm);
constantReNeg = (mpfr_sgn(mpfr_constant_re) < 0);
constantImNeg = (mpfr_sgn(mpfr_constant_im) < 0);
mpfr_t log2C;
mpfr_init2(log2C, 100);
//Constant real part width
mpfr_log2(log2C, mpfr_constant_re, GMP_RNDN);
constantReMsb = mpfr_get_si(log2C, GMP_RNDU);
//Constant imaginary part width
mpfr_log2(log2C, mpfr_constant_im, GMP_RNDN);
constantImMsb = mpfr_get_si(log2C, GMP_RNDU);
//Free
mpfr_clear(log2C);
int constantMaxMSB = max(constantReMsb, constantImMsb);
//Do we need an extra sign bit ?
bool extraSignBitRe = !signedInput && (constantReNeg || !constantImNeg);
bool extraSignBitIm = !signedInput && (constantReNeg || constantImNeg);
int msbout_re, msbout_im;
msbout_re = msbout_im = msb_in + constantMaxMSB +1;
if(extraSignBitRe)
{
msbout_re++;
}
if(extraSignBitIm)
{
msbout_im++;
}
outputre_width = msbout_re - lsb_out + 1;
outputim_width = msbout_im - lsb_out + 1;
if(outputre_width < 0 || outputim_width < 0)
{
THROWERROR("Computed msb will be lower than asked lsb."
" Result would always be zero ");
}
}
int main(void) {
sollya_obj_t a[51];
int t[51];
int i;
sollya_lib_init();
a[0] = sollya_lib_absolute();
a[1] = sollya_lib_binary();
a[2] = sollya_lib_decimal();
a[3] = sollya_lib_default();
a[4] = sollya_lib_dyadic();
a[5] = sollya_lib_error();
a[6] = sollya_lib_false();
a[7] = sollya_lib_file();
a[8] = sollya_lib_fixed();
a[9] = sollya_lib_floating();
a[10] = sollya_lib_hexadecimal();
a[11] = sollya_lib_honorcoeffprec();
a[12] = sollya_lib_off();
a[13] = sollya_lib_on();
a[14] = sollya_lib_perturb();
a[15] = sollya_lib_pi();
a[16] = sollya_lib_postscript();
a[17] = sollya_lib_postscriptfile();
a[18] = sollya_lib_powers();
a[19] = sollya_lib_relative();
a[20] = sollya_lib_true();
a[21] = sollya_lib_void();
a[22] = sollya_lib_constant_from_double(1.0);
a[23] = sollya_lib_free_variable();
a[24] = sollya_lib_string("error");
a[25] = sollya_lib_string("");
a[26] = sollya_lib_list(NULL, 0);
a[27] = sollya_lib_list(a, 2);
a[28] = sollya_lib_end_elliptic_list(a, 2);
a[29] = sollya_lib_parse_string("[1, 2]");
a[30] = sollya_lib_round_down();
a[31] = sollya_lib_round_up();
a[32] = sollya_lib_round_towards_zero();
a[33] = sollya_lib_round_to_nearest();
a[34] = sollya_lib_double_obj();
a[35] = sollya_lib_build_function_double(sollya_lib_free_variable());
a[36] = sollya_lib_single_obj();
a[37] = sollya_lib_build_function_single(sollya_lib_free_variable());
a[38] = sollya_lib_quad_obj();
a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable());
a[40] = sollya_lib_halfprecision_obj();
a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable());
a[42] = sollya_lib_doubleextended_obj();
a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable());
a[44] = sollya_lib_double_double_obj();
a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable());
a[46] = sollya_lib_triple_double_obj();
a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable());
a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5));
a[49] = sollya_lib_end_elliptic_list(NULL, 0);
a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}");
for(i=0;i<51;i++) t[i] = sollya_lib_obj_is_error(a[i]);
if (t[0]) sollya_lib_printf("sollya_lib_obj_is_error detects absolute\n");
if (t[1]) sollya_lib_printf("sollya_lib_obj_is_error detects binary\n");
if (t[2]) sollya_lib_printf("sollya_lib_obj_is_error detects decimal\n");
if (t[3]) sollya_lib_printf("sollya_lib_obj_is_error detects default\n");
if (t[4]) sollya_lib_printf("sollya_lib_obj_is_error detects dyadic\n");
if (t[5]) sollya_lib_printf("sollya_lib_obj_is_error detects error\n");
if (t[6]) sollya_lib_printf("sollya_lib_obj_is_error detects false\n");
if (t[7]) sollya_lib_printf("sollya_lib_obj_is_error detects file\n");
if (t[8]) sollya_lib_printf("sollya_lib_obj_is_error detects fixed\n");
if (t[9]) sollya_lib_printf("sollya_lib_obj_is_error detects floating\n");
if (t[10]) sollya_lib_printf("sollya_lib_obj_is_error detects hexadecimal\n");
if (t[11]) sollya_lib_printf("sollya_lib_obj_is_error detects honorcoeffprec\n");
if (t[12]) sollya_lib_printf("sollya_lib_obj_is_error detects off\n");
if (t[13]) sollya_lib_printf("sollya_lib_obj_is_error detects on\n");
if (t[14]) sollya_lib_printf("sollya_lib_obj_is_error detects perturb\n");
if (t[15]) sollya_lib_printf("sollya_lib_obj_is_error detects pi\n");
if (t[16]) sollya_lib_printf("sollya_lib_obj_is_error detects postscript\n");
if (t[17]) sollya_lib_printf("sollya_lib_obj_is_error detects postscriptfile\n");
if (t[18]) sollya_lib_printf("sollya_lib_obj_is_error detects powers\n");
if (t[19]) sollya_lib_printf("sollya_lib_obj_is_error detects relative\n");
if (t[20]) sollya_lib_printf("sollya_lib_obj_is_error detects true\n");
if (t[21]) sollya_lib_printf("sollya_lib_obj_is_error detects void\n");
if (t[22]) sollya_lib_printf("sollya_lib_obj_is_error detects a constant\n");
if (t[23]) sollya_lib_printf("sollya_lib_obj_is_error detects free_variable\n");
if (t[24]) sollya_lib_printf("sollya_lib_obj_is_error detects the string \"error\"\n");
if (t[25]) sollya_lib_printf("sollya_lib_obj_is_error detects the empty string.\n");
if (t[26]) sollya_lib_printf("sollya_lib_obj_is_error detects the empty list.\n");
if (t[27]) sollya_lib_printf("sollya_lib_obj_is_error detects a non empty list.\n");
if (t[28]) sollya_lib_printf("sollya_lib_obj_is_error detects a non empty end-elliptic list.\n");
if (t[29]) sollya_lib_printf("sollya_lib_obj_is_error detects a range.\n");
if (t[30]) sollya_lib_printf("sollya_lib_obj_is_error detects RD.\n");
if (t[31]) sollya_lib_printf("sollya_lib_obj_is_error detects RU.\n");
if (t[32]) sollya_lib_printf("sollya_lib_obj_is_error detects RZ.\n");
if (t[33]) sollya_lib_printf("sollya_lib_obj_is_error detects RN.\n");
if (t[34]) sollya_lib_printf("sollya_lib_obj_is_error detects D as symbol.\n");
if (t[35]) sollya_lib_printf("sollya_lib_obj_is_error detects D(_x_).\n");
if (t[36]) sollya_lib_printf("sollya_lib_obj_is_error detects S as symbol.\n");
if (t[37]) sollya_lib_printf("sollya_lib_obj_is_error detects S(_x_).\n");
if (t[38]) sollya_lib_printf("sollya_lib_obj_is_error detects QD as symbol.\n");
if (t[39]) sollya_lib_printf("sollya_lib_obj_is_error detects QD(_x_).\n");
if (t[40]) sollya_lib_printf("sollya_lib_obj_is_error detects HP as symbol.\n");
if (t[41]) sollya_lib_printf("sollya_lib_obj_is_error detects HP(_x_).\n");
if (t[42]) sollya_lib_printf("sollya_lib_obj_is_error detects DE as symbol.\n");
if (t[43]) sollya_lib_printf("sollya_lib_obj_is_error detects DE(_x_).\n");
if (t[44]) sollya_lib_printf("sollya_lib_obj_is_error detects DD as symbol.\n");
if (t[45]) sollya_lib_printf("sollya_lib_obj_is_error detects DD(_x_).\n");
if (t[46]) sollya_lib_printf("sollya_lib_obj_is_error detects TD as symbol.\n");
if (t[47]) sollya_lib_printf("sollya_lib_obj_is_error detects TD(_x_).\n");
if (t[48]) sollya_lib_printf("sollya_lib_obj_is_error detects a constant expression.\n");
if (t[49]) sollya_lib_printf("sollya_lib_obj_is_error detects an empty end-elliptic list.\n");
if (t[50]) sollya_lib_printf("sollya_lib_obj_is_structure detects structure { .a = 5; .b = exp(_x_)}.\n");
for(i=0;i<51;i++) sollya_lib_clear_obj(a[i]);
sollya_lib_close();
return 0;
}
