Re^2: Decimal Floating Point (DFP) and does Perl needs DFP?

Replies are listed 'Best First'.
Re^3: Decimal Floating Point (DFP) and does Perl needs DFP? by syphilis (Archbishop) on Jan 19, 2015 at 01:05 UTC
would you mind stating the mathematically correct result (say, to six digits after decimal point)? According to Math::Decimal128: `C:\>perl -MMath::Decimal128=":all" -le "$n1=Math::Decimal128->new('10' +, 0);$n2=Math::Decimal128->new('1000001', -6);for(1..60000000){$n1 = + $n2}print $n1;" 114197313013072744502959647597176e-5` [download] Or, to 6 decimal places: 1141973130130727445029596475.971760 which is the same as flexvault got. With 80-bit long doubles, the calculation came out as: `C:\>perl -MMath::LongDouble=":all" -le "$n1=Math::LongDouble->new('10' +);$n2=Math::LongDouble->new('1.000001');for(1..60000000){$n1 = $n2}p +rint $n1;" 1.14197313013239314e+027` [download] Or, printing to 28 decimal digits (which implies a level of precision that we don't have): `C:\>perl -MMath::LongDouble=":all" -le "$n1=Math::LongDouble->new('10' +);$n2=Math::LongDouble->new('1.000001');for(1..60000000){$n1 = $n2}p +rint LDtoSTRP($n1, 28);" 1.141973130132393144424071168e+027` [download] This figure is equivalent to the first one you quoted. With __float128: `C:\>perl -MMath::Float128=":all" -le "$n1=Math::Float128->new('10');$n +2=Math::Float128->new('1.000001');for(1..60000000){$n1 = $n2}print $ +n1;" 1.14197313013072744502959647306684e+27` [download] This differs from your second figure - and I don't think there's any valid reason that they should differ. I'm inclined to think that mine is correct (surprise :-) because it matches up pretty well with the _Decimal128 calculation (where the respective precisions are reasonably close to each other). Might you have assigned a long double or double value that got cast to a __float128, instead of assigning an actual __float128 value ? As LanX points out, rounding is involved. The above one-liner programs all employ rounding to nearest with ties to even - the different results of course arising from the different precisions involved. Cheers, Rob	[reply] [d/l] [select]
Re^4: Decimal Floating Point (DFP) and does Perl needs DFP? by LanX (Saint) on Jan 19, 2015 at 01:44 UTC
> rounding is involved. Calculating 10 * 1.000001 ** 6e7 should minimize the propagation of rounding errors, if exponentiation is sufficiently well implemented. Cheers Rolf PS: Je suis Charlie!	[reply]
Re^5: Decimal Floating Point (DFP) and does Perl needs DFP? by syphilis (Archbishop) on Jan 19, 2015 at 03:48 UTC
Calculating 10 1.000001 ** 6e7 should minimize the propagation of rounding errors, if exponentiation is sufficiently well implemented.* I have found a case where that's not so for the calculation in question - namely, Windows 7, perl-5.20.0, nvtype is double. But the same perl version and configuration on Ubuntu supports your assertion. So it might just be that the Windows exponentiation (or something else there) is buggy. I haven't experimented much at all, and don't really intend to. What's the reasoning behind your assertion ? Cheers, Rob	[reply]
Re^6: Decimal Floating Point (DFP) and does Perl needs DFP? by LanX (Saint) on Jan 19, 2015 at 09:41 UTC
Re^7: Decimal Floating Point (DFP) and does Perl needs DFP? by syphilis (Archbishop) on Jan 20, 2015 at 14:40 UTC
Some notes below your chosen depth have not been shown here
Re^4: Decimal Floating Point (DFP) and does Perl needs DFP? by Anonymous Monk on Jan 19, 2015 at 18:55 UTC
Right you are about the __float128 case. After rewriting the constant as `(__float128)1000001 / 1e6`, my result now matches your calculation. I'm inclined to think the bc-calculated value is accurate. But verifying that is rather laborious, for 1000001**6e7 is a number with ca 360M decimal digits.	[reply] [d/l]
Re^5: Decimal Floating Point (DFP) and does Perl needs DFP? by syphilis (Archbishop) on Jan 19, 2015 at 23:34 UTC
I'm inclined to think the bc-calculated value is accurate Yes, and the mpfr library agrees: `C:\>perl -MMath::MPFR=":mpfr" -le "Rmpfr_set_default_prec(1000000); $x +=Math::MPFR->new('1.000001'); $x *= 60000000; $x = 10; Rmpfr_out_st +r($x, 10,43,MPFR_RNDN); 1.141973130130727445029596475971653735685612e27` [download] That's calculated with a million bits of precision - and gives the same result as when calculated with a thousand bits of precision. So I think we can rest assured that that is the correct figure for 43 decimal digits. Cheers, Rob	[reply] [d/l]
Re^3: Decimal Floating Point (DFP) and does Perl needs DFP? (50 digits precision) by LanX (Saint) on Jan 20, 2015 at 01:27 UTC
> would you mind stating the mathematically correct result (say, to six digits after decimal point)? This should be correct for at least 50 digits after decimal point: `1141973130130727445029596475.97165373568561208619839490929389898529956 +04918087368059784750017004880305063884032742217053556637130` [download] calculated using Math::BigFloat (which operates decimal with configurable precision) and taking advantage of exponentiation laws described here. (NB: BigFloat's own `->bpow()` method is far slower) `use strict; use warnings; use Math::BigFloat; my $exp=6e7; Math::BigFloat->precision(-100); my $x=Math::BigFloat->new('1.000001'); my $val=Math::BigFloat->new('1'); $\="\n"; for my $bit (reverse split //,sprintf '%b',$exp) { # print "$bit ",$x; $val->bmul($x) if $bit; $x->bpow(2); } $val->bmul(10); print "Result : $val"; my $syphilis=Math::BigFloat->new('1141973130130727445029596475.971760' +); print "diff: ", $val - $syphilis;` [download] took about a second on a netbook. `Compilation started at Tue Jan 20 02:19:30 /usr/bin/perl -w /home/lanx/pm/big_expo.pl Result : 1141973130130727445029596475.97165373568561208619839490929389 +89852995604918087368059784750017004880305063884032742217053556637130 diff: -0.0001062643143879138016050907061010147004395081912631940215249 +982995119694936115967257782946443362870 Compilation finished at Tue Jan 20 02:19:31` [download] The results from the C-libs are as you can see only accurate till the third digit after decimal point. I'm not a big expert on BigFloat, if you see a problem, all feedback welcome. :) Cheers Rolf PS: Je suis Charlie! update you can easily increase the accuracy to 1000 digits after decimal point by setting precision to -1050, only takes a second.	[reply] [d/l] [select]
Re^4: Decimal Floating Point (DFP) and does Perl needs DFP? by syphilis (Archbishop) on Jan 20, 2015 at 03:24 UTC
This should be correct for at least 50 digits after decimal point: 1141973130130727445029596475.9716537356856120861983949092938989852995604918087368059784750017004880305063884032742217053556637130 Yes, it's correct for 69 digits after the decimal point. The following, provided by Math::MPFR, appears to be correct for 129 digits - as increasing the mpfr precision above 450 bits doesn't alter the 129 digit value: 11419731301307274450295964759.716537356856120861983949092938989852995604918087368059784750017004844856171227209226348596180640102 And that agrees (to at least 129 digits) with LanX's script when M::BF precision is set to -1050. Cheers, Rob	[reply]
Re^3: Decimal Floating Point (DFP) and does Perl needs DFP? (correctness) by LanX (Saint) on Jan 18, 2015 at 16:58 UTC
Someone please correct me, but taken that each operation causes up to one bit of error and that we perform 60e6 operations ... We'll need calculate with 60.000.000 bits to be 100% sure of avoiding rounding errors. So a brute force calculation should be ruled out. Furthermore what is mathematical correct? Though it's taught in school, any rounding that maps 0.5 to 1 is with 50% probability wrong. Cheers Rolf PS: Je suis Charlie!	[reply]
Re^3: Decimal Floating Point (DFP) and does Perl needs DFP? by Anonymous Monk on Jan 18, 2015 at 17:19 UTC
Update. In above, s/52606976/something else/ — a cast to __float80 was used for the lack of proper printf format. But the error is magnitudes higher than that, so... Regarding the expected result: $ echo 'scale=80; 10 * (1.000001^78125)^768' \| bc 1141973130130727445029596475.971653735685612 Looks like the 60M figure was carefully picked :-)	[reply]

update