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.}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

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

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

 

 

 

OP + = (DIGITS arg)DIGITS: arg;

 

 

 

 

 

 

# Next: Zero any totally non overlapping digit #

DO a plus b[place] := zero OD;

 

# Finally: normalise by removing leading & trailing "zero" digit #

 

 

 

 

 

 

 

 

FI

);

 

 

 

 

# Define the basic operators and routines for #

# manipulating DIGITS specific to a BCD base #

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

 

# define the basic axioms of the number system you are extending #

 

# mixin the Big_float base definitions #

 

MODE BIGREAL = DIGITS;

 

 

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

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

OP INITLONGREAL = (BIGREAL a)LONG REAL:

ELSE

OD;

FI;

 

 

 

 

 

INT sign = SIGN in int;

 

OD;

done:

);

 

 

 

 

 

);

 

 

 

STRING out;

OD;

ELSE

out

FI

 

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

# A program to test abritary length BCD floating point addition. #

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

 

 

 

# include the basic axioms of the digits being used #

 

test: (

sum := INITBIGREAL 0,

shifted pattern := pattern,

 

FOR term FROM -8 TO 20 DO

 

# First make shifted pattern smaller by shifting right by the pattern width #

MOID(sum +:= shifted pattern);

 

BIGREAL total = prod + shifted tiny;

 

ELSE

print((LSD prod - MSD prod + 1," digit test result: "))

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

90j18 ": factor 2 NB. formatted as decimal in 90 characters with 18 characters after the decimal point

12345679012345679012345679012345679012345679012345679012345679012345679.012345679012345679

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.