Generalised floating point addition: Difference between revisions

{{Template:Draft task}}

 

 

 

'''Test case:'''

 

{|class="wikitable" style="text-align: center; margin: 1em auto 1em auto;"

|+ Calculate the terms for -7 to 21 in this sequence of calculations

|etc.|| The final calculation will be over 256 digits wide || 1e72

|}

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - one minor extension to language used - PRAGMA READ, similar to C's #include directive.}}

''Note:'' This code stores the digits as array of digits with the "most significant digit" on the "left" as per normal "human" form. The net effect is that whole numbers (such as 100) are stored in the negative array positions, eg -2, -1 & 0, or [-2:0], And the fractional part of the floating point numbers are stored from index 1, eg. 1, 2, 3 etc. or [1:].

 

# 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!

</pre>

[[Category:Arbitrary precision]]

 

=={{header|J}}==

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

 

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.

 

=={{header|REXX}}==

 

 

 

end /*j*/

 

 

do times

end

 

# addend uncompressed (zoned) BCD number

── ────── ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

21 1e-189 [266 digits]

═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════

</pre>