Generalised floating point addition: Difference between revisions

'''See also:''' [[Generalised floating point multiplication#ALGOL 68|Generalised floating point multiplication]]

 

# Define the basic addition operators #

# for the generalised base #

out # EXIT #

FI

################################################

# Define the basic operators and routines for #

# re anchor the array with a shift #

OP SHL = (DIGITS in, INT shl)DIGITS: in[@MSD in-shl];

# Define the basic operators and routines for #

# manipulating DIGITS specific to a BCD base #

out

FI

DIGITS out := arg;

FOR digit FROM LSD arg BY digit order OF arithmetic TO MSD arg DO

OP - = (DIGITS a, DIGIT b)DIGITS: a - INITDIGITS b;

OP - = (DIGIT a, DIGITS b)DIGITS: INITDIGITS a - a;

 

##################################################################

printf(($g$, REPR total, $" => "b("Passed","Failed")"!"$, LSD total = MSD total, $l$))

OD

<pre style="height:15ex;overflow:scroll">

12345679e63 x 81 gives: 999999999e63, Plus 1e63 gives: 1e72 => Passed!

=={{header|Go}}==

Although the big.Float type already has a 'Mul' method, we re-implement it by repeated application of the 'Add' method.

 

import (

e -= 9

}

 

{{out}}

Given

 

u * 10x ^ v

 

In other words, given a parse time word (<code>e</code>) which combines its two arguments as numbers, multiplying the number on its left by the exact exponent of 10 given on the right, I can do:

 

1000000000000000000000000000000000000000000000000000000000000000000000000

1 e 54 + 12345679012345679 e 54 * 81

1000000000000000000000000000000000000000000000000000000000000000000000000

1 e 36 + 12345679012345679012345679012345679x e 36 * 81

 

As usual, if the results seem mysterious, it can be helpful to examine intermediate results. For example:

 

1000000000000000000000000000000000000

 

So, ok, let's turn this into a sequence:

 

 

Here we show some examples of what these words mean:

 

12345679012345679012345679012345679000000000000000000000000000000000000

factor _3

1000000000000000000000000000000000000

adjust _3

 

Given these words:

 

_7+i.29 NB. these are the sequence elements we are going to generate

_7 _6 _5 _4 _3 _2 _1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

29

~.(adju + 81 * factor)&> _7+i.29 NB. here we see that they are all the same number

 

Note that <code>~. list</code> returns the unique elements from that list.

Java provides a <code>BigDecimal</code> class that supports robust arbitrary precision calculations. That class is demonstrated using the computations required in this task.

 

import java.math.BigDecimal;

 

 

}

 

{{out}}

=={{header|Julia}}==

Julia implements arbitary precision intergers and floating point numbers in its base function.

@assert(big"12345679e63" * BigFloat(81) + big"1e63" == big"1.0e+72")

@assert(big"12345679012345679e54" * BigFloat(81) + big"1e54" == big"1.0e+72")

@assert(big"12345679012345679012345679e45" * BigFloat(81) + big"1e45" == big"1.0e+72")

@assert(big"12345679012345679012345679012345679e36" * BigFloat(81) + big"1e36" == big"1.0e+72")

All assertions pass.

 

 

Although the BigDecimal type supports multiplication, I've used repeated addition here to be more in tune with the spirit of the task.

 

import java.math.BigDecimal

e -= 9

}

 

{{out}}

=={{header|Perl}}==

Calculations done in decimal, prints 'Y' for each successful test.

use warnings;

use Math::Decimal qw(dec_add dec_mul_pow10);

printf "$n:%s ", 10**72 == $sum ? 'Y' : 'N';

$e -= 9;

{{out}}

<pre>-7:Y -6:Y -5:Y -4:Y -3:Y -2:Y -1:Y 0:Y 1:Y 2:Y 3:Y 4:Y 5:Y 6:Y 7:Y 8:Y 9:Y 10:Y 11:Y 12:Y 13:Y 14:Y 15:Y 16:Y 17:Y 18:Y 19:Y 20:Y 21:Y

===bigatom===

Note this is decimal-only, and that mpfr.e does not really cope because it cannot hold decimal fractions exactly (though it could probably be fudged with a smidgen of rounding)

{{out|Output (trimmed)}}

(Use the %B format to better see the difference between adding and not adding e1.)

=== any base ===

Uses b_add() and b_mul() from [[Generalised_floating_point_multiplication#Phix]]

same ouput

 

The printed result is the exact difference of 1e72 and the result. So those <code>0</code>s you see are exactly nothing.

 

(define (f n (printf printf))

(define exponent (* (- n) 9))

(module+ main

(displayln "number in brackets is TOTAL number of digits")

 

{{out}}

(formerly Perl 6)

As long as all values are kept as rationals (type <code>Rat</code>) calculations are done full precision.

for -7..21 -> $n {

my $num = '12345679' ~ '012345679' x ($n+7);

printf "$n:%s ", 10**72 == $sum ?? 'Y' !! 'N';

$e -= 9;

{{out}}

<pre>-7:Y -6:Y -5:Y -4:Y -3:Y -2:Y -1:Y 0:Y 1:Y 2:Y 3:Y 4:Y 5:Y 6:Y 7:Y 8:Y 9:Y 10:Y 11:Y 12:Y 13:Y 14:Y 15:Y 16:Y 17:Y 18:Y 19:Y 20:Y 21:Y

└─┐ The number of digits for the precision is automatically adjusted. ┌─┘

└────────────────────────────────────────────────────────────────────┘

maxW= linesize() - 1 /*maximum width allowed for displays. */

/*Not all REXXes have the LINESIZE BIF.*/

say right(k,3) 'sum=' translate(_, "e", 'E') /*use a lowercase "E" for exponents. */

end /*k*/

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

<br>The &nbsp; '''LINESIZE.REX''' &nbsp; REXX program is included here &nbsp; ───► &nbsp; [[LINESIZE.REX]].<br>

 

===any base===

 

end /*j*/

 

 

do times

end

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

end

 

er: say '***error!***'; say; say arg(1); say; exit 13

er53: call er arg(1) 'not numeric'

 

=={{header|Ruby}}==

No code, it's built in (uses '*' for multiplication):

p 12345679012345679e54 * 81 + 1e54

p 12345679012345679012345679e45 * 81 + 1e45

All result in 1.0e+72.

 

=={{header|Tcl}}==

Tcl does not allow overriding the default mathematical operators (it does allow you to define your own expression engine — this is even relatively simple to do — but this is out of the scope of this task) but it also allows expressions to be written using a Lisp-like prefix form:

for {set n -7; set e 63} {$n <= 21} {incr n;incr e -9} {

append m 012345679

puts $n:[+ [* [format "%se%s" $m $e] 81] 1e${e}]

The above won't work as intended though; the default implementation of the mathematical operators does not handle arbitrary precision floats (though in fact it will produce the right output with these specific values; this is a feature of the rounding used, and the fact that the exponent remains expressible in an IEEE double-precision float). So here is a version that does everything properly:

proc + {num args} {

set num [impl::Tidy $num]

}

}

Now we can demonstrate (compare with the original code to see how little has changed syntactically):

for {set n -7; set e 63} {$n <= 21} {incr n;incr e -9} {

append m 012345679

puts $n:[+ [* [format "%se%s" $m $e] 81] 1e${e}]

{{out|Output (trimmed)}}

<pre>

 

Although the BigRat type supports multiplication, repeated addition has been used as in the Kotlin example.

 

var repeatedAdd = Fn.new { |br, times|

s = t + s

e = e - 9

 

{{out}}