{ ---------------------------------------------------------------------------
Rules for printing Dartmouth BASIC numbers  (except allowing more than 6
digits of precision, given the modern era of 64 bit FP.)

Let P = desired output precision:

1. If a number is an integer, the decimal point is not printed.  If the
   integer contains more than P digits, display in scientific notation with
   P significant digits.

2. For any decimal number, no more than P significant digits are printed.

3. For a number less than 0.1, the E notation is used unless the entire
   significant part of the number can be printed as a P decimal number.
   Thus, 0.01234578 means the number is exactly 0.012345678, while
   1.2345678E-2 means that the number has been rounded to 0.012345678

4. Trailing zeros after the decimal point are not printed.
 --------------------------------------------------------------------------- }

requires fpmath

create fp-repr  20 chars allot
create zero-str ,z" 00000000000000000" \ used to compare zero strings

: fp-integer?  ( exp -- )
    dup precision >=          \ exponent > precision => integer
    swap precision over -     \ length to compare
    swap fp-repr + swap       \ address to compare
    zero-str over compare 0=  \ compare to all zeros
    or ;

: (adjust)   ( addr count -- addr count' )
    over + 1-   \ addr end-addr
    BEGIN  dup c@ [char] 0 = WHILE
        1-
    REPEAT  over - 1+ ;

: .sci  ( exp -- )
    fp-repr c@ emit
    [char] . emit
    fp-repr 1+ precision 1- (adjust) type
    [char] E emit
    dup 0> IF  [char] + emit  THEN
    . ;

: .fp-integer ( exp -- )
    dup precision <= IF
        fp-repr swap type space
    ELSE
        1- .sci
    THEN ;

: .fp-small  ( exp -- )
    fp-repr precision + 1- c@  [char] 0 = IF
        ." 0."
        negate 0 DO  [char] 0 emit  LOOP
        fp-repr precision (adjust) type
    ELSE
        1- .sci
    THEN ;

: .fp   ( exp -- )
    dup IF
        dup fp-repr swap type
    ELSE
        [char] 0 emit
    THEN
    [char] . emit
    fp-repr over +  swap precision swap -  (adjust) type space ;

: fp.   ( fp -- )
    fp-repr precision represent
    invert IF abort" Invalid FP value on stack." THEN
    ( sign ) IF  [char] - emit  THEN

    fp-repr c@ [char] 0 = IF   \ zero special case
        drop ." 0" exit
    THEN
    dup fp-integer? IF
        .fp-integer exit
    THEN
    dup 0<    \ <= 10^-1
        IF .fp-small exit
    THEN
    ( ELSE ) .fp ;

Some tests:

0e fp. 0 ok
2e fsqrt fp. 1.41421356237  ok
944,221,771,433,788 d>f fp. 9.44221771434E+14  ok
0.00875e fp. 0.00875 ok
0.00877777777777777e fp. 8.77777777778E-3  ok
-25.75e fp. -25.75  ok
255e fp. 255  ok
49e fsqrt fp. 7  ok
0.530000e fp. 0.53  ok
6 set-precision  ok
676,211,477,636,211 d>f f. 676211000000000.  ok
676,211,477,636,211 d>f fp. 6.76211E+14  ok

http://jsfiddle.net/vcKdF/3248/


def ackermann(m, n):
while m >= 4:
if n == 0:
n = 1
else:
n = ackermann(m, n - 1)
m = m - 1
if m == 3:
return (1 << n + 3) - 3
elif m == 2:
return (n << 1) + 3
elif m == 1:
return n + 2
else:
return n + 1

print ackermann(4,2)


http://codepad.org/QdneSl1Q

a :: Integer -> Integer -> Integer
a 0 n = n + 1
a m 0 = a (m - 1) 1
a m n = a (m - 1) $ a m (n - 1)

main :: IO ()
main = print $ a 3 4