Arbitrary Precision Math Procedures

I speed up more extensively adda and multa in doing computation in base 10000 instead of 10. Here is code

global base
set base 10000

# Add two numbers.
proc adda {xs ys} {
    global base
    set rs {}
    set carry 0
    if {[llength $xs]>[llength $ys]} {
        set len [llength $ys]
        set flag 0
    } else {
        set len [llength $xs]
        set flag 1
    }
    set pos 0
    foreach x $xs y $ys {
        if {$pos>=$len} {
            if {$flag} {set x 0} else {set y 0}
        }
        set n [expr {$x+$y+$carry}]
        set carry [expr {$n / $base}]
        lappend rs [expr {$n % $base}]
        incr pos ;# who stole this line? restored 11/00 MM
    }
    if {$carry} {lappend rs $carry}
    return $rs
}

proc multi {xs a} {
    global base
    set rs {}
    #puts "multi : xs=$xs"
    if { $a == $base } {
        set rs $xs
        set rs [ linsert $rs 0 0 ]
        #puts "multi: rs=$rs"
        return $rs
    }
    set carry 0
    foreach x $xs {
        set n [expr {$x*$a+$carry}]
        set carry [expr {$n / $base}]
        lappend rs [expr {$n % $base}]
    }
    if {$carry} {lappend rs $carry}
    return $rs
}

proc multa {xs ys} {
    global base
    set rs {}
    set d $ys
    foreach x $xs {
        set n [multi $d $x]
        set rs [adda $rs $n ]
        set d [multi $d $base ]
    }
    return $rs
}

# Convert an integer to a (list-formatted) number.
proc tolist {n} {
    global base
    set rs {}
    if {[catch {incr n 0}]} {
        set k 0
        set nn {}
        set rs {}
        set l [string length $n ]
        incr l -1
        for { set i $l } { $i >= 0 } { incr i -1 } {
            set digit [ string index $n $i ] 
            incr k
            set nn "$digit$nn"
            if { $k == 4} {
                set k 0         
                lappend rs  $nn 
                #puts -nonewline " $nn"
                set nn {}
            }
        }
        if { $nn != {} } {
            lappend rs  $nn 
            #puts -nonewline " $nn"
        }
        #puts ""
    } else {
        while {$n > 0} {
            lappend rs [expr {$n%$base}]
            set n [expr {$n/$base}]
        }
    }
    #puts "tolist rs= $rs"
    return $rs
}

# Convert a (list-formatted) number to a human-readable form.
# Will be an integer (modulo type-shimmering) if representable.
proc fromlist {xs} {
    set r {}
    foreach x $xs {
        if { $x == 0 } {
            set r "0000$r"
        } else {
            set r $x$r
        }
    }
    if {![string length $r]} {set r 0}
    return $r
}

# DEMO CODE: Factorial.  Try calculating [fact 40] for a 48-digit number
proc fact {n} {
    set this 1
    for {set i 1} {$i <= $n} {incr i} {
        set this [multa $this [tolist $i]]
    }
    return [fromlist $this]
}

# DEMO CODE: Fibonacci Sequence.  Doesn't grow anything like as fast as factorial (in fact, two-term recurrences such as Fibonacci grow at quadratic rates),
# but still grows beyond 32-bit integers quite easily.
proc fib {n} {
    set this 1
    set last 0
    for {set i 1} {$i<$n} {incr i} {
        set new [adda $this $last]
        set last $this
        set this $new
    }
    return [fromlist $this]
}

JJD

Here are a few procedures I put together to perform arbitrary precision arithmetic. If you are using these a lot, perhaps you should consider the mpexpr extension [1 ] instead.

The basic representation I use is a list of decimal digits (easy to convert to and from human-readable form) stored least-significant digit first (so the code handles the magnitude of the numbers implicitly.)

This all comes from a discussion I was having in email relating to some messages online about calculating factorials. I've decided to put the procs here so I can find them again. Feel free to optimise them, add in relevant links, more examples, other representations, etc.

DKF

WHOA! Donal, am I missing something here?

 % tolist 75676576576576576567575
 can't use floating-point value as operand of "%"
 %
   -PSE

That's not an integer, is it? It's just a string of digits... Oh well, I've fixed the code below now, so your example should now work. - DKF

HOW is that not an integer?

inýý·teýý·ger (nt-jr)
    n. Mathematics
  
      1.A member of the set of positive whole numbers (1, 2, 3, . . .),
          negative whole numbers (-1, -2, -3, . . .),
          and zero (0).
      2.A complete unit or entity.

BTW, I fixed your missing bracket problem down there... things are quite spiffy now. How would we ever get along without our own knight-of-the-lambda-calculus? Thanks Donal! -PSE

Hah! Dictionary definitions are for wimps! It cannot be parsed by Tcl_GetInt(), so obviously it cannot be an integer. This is confirmed by the use of the [string is integer 75676576576576576567575] test, which naturally fails.

(And cheers for fixing any missing bracket problems.)

DKF

All of the words in the dictionary cannot express my gratitude that I do not have to sit across the table from you at the Monday morning status meeting... -PSE

My status meetings are usually on Friday afternoons, and I have the advantage of working with people with heavy admin and/or teaching loads, so any work I choose to do is definitely appreciated. And I drink coffee that is substantially stronger than Starbucks makes theirs...

Now, I've got a compiler spec. that I really ought to get written for as soon as possible. So I do hope you'll forgive me if I leave this pleasant little discussion for now and get on with a little work. -DKF

So should I, but I like this place ;-) how 'bout

proc string_is_dictionary_integer {s} {regexp {^-?[0-9]+$} $s} ;#RS

proc K {x y} {set x};# For a speedup

# Add two numbers.
proc adda {xs ys} {
    set rs {}
    set carry 0
    if {[llength $xs]>[llength $ys]} {
        set len [llength $ys]
        set flag 0
    } else {
        set len [llength $xs]
        set flag 1
    }
    set pos 0
    foreach x $xs y $ys {
        if {$pos>=$len} {
            if {$flag} {set x 0} else {set y 0}
        }
        set n [expr {$x+$y+$carry}]
        set carry [expr {$n / 10}]
        lappend rs [expr {$n % 10}]
        incr pos ;# who stole this line? restored 11/00 MM
    }
    if {$carry} {lappend rs $carry}
    return $rs
}

# Multiply two numbers.
proc multa {xs ys} {
    set rs 0
    foreach x $xs {
        for {} {$x>0} {incr x -1} {
            set rs [adda [K $rs [set rs {}]] $ys]
        }
        set ys [linsert [K $ys [set ys {}]] 0 0]
    }
    return $rs
}

# Convert an integer to a (list-formatted) number.
proc tolist {n} {
    set rs {}
    if {[catch {incr n 0}]} {
        foreach digit [split $n {}] {
            set rs [linsert [K $rs [set rs {}]] 0 $digit]
        }
    } else {
        while {$n > 0} {
            lappend rs [expr {$n%10}]
            set n [expr {$n/10}]
        }
    }
    return $rs
}

# Convert a (list-formatted) number to a human-readable form.
# Will be an integer (modulo type-shimmering) if representable.
proc fromlist {xs} {
    set r {}
    foreach x $xs {
        set r $x$r
    }
    if {![string length $r]} {set r 0}
    return $r
}

# DEMO CODE: Factorial.  Try calculating [fact 40] for a 48-digit number
proc fact {n} {
    set this 1
    for {set i 1} {$i <= $n} {incr i} {
        set this [multa [K $this [set this {}]] [tolist $i]]
    }
    return [fromlist $this]
}

# DEMO CODE: Fibonacci Sequence.  Doesn't grow anything like as fast as factorial,
# but still grows beyond 32-bit integers quite easily.
proc fib {n} {
    set this 1
    set last 0
    for {set i 1} {$i<$n} {incr i} {
        set new [adda $this $last]
        set last $this
        set this $new
    }
    return [fromlist $this]
}

Another link: http://homepages.ihug.co.nz/~webscool/integer.html - RS


See math::bignum from tcllib. It is pure-Tcl. And in Tcl 8.5, default integers are now Bignums as described in TIP #237.


See mkTulip at http://mkextensions.sourceforge.net/ .


Also perhaps checkout Decimal Arithmetic Package for tcl 8.5


Check out Bignums Fast and Dirty and arbint and mpexpr.


[Maybe write here a bit about arithmetic based on Schönhage and Strassen, and also Priest's '91 paper on "Algorithms for Arbitrary Precision Floating Point Arithmetic". Is this the right place?]

  • Also Cody's Software for the Elementary Function
  • R. P. Brent. Fast multiple-precision evaluation of elementary functions. Journal of the Association for Computing Machinery, 23(2):242-251, April 1976.
  • R.P. Brent. A FORTRAN multiple-precision arithmetic package ACM Trans. on Math. Software, 4, no 1, 57-70, 1978.
  • Douglas M. Priest, "Algorithms for arbitrary precision floating point arithmetic," 10th IEEE Symposium on Computer Arithmetic, 1991, pp. 132-143
  • D. M. Smith, "A FORTRAN package for floating-point multiple-precision arithmetic," ACM transactions on mathematical software 17 (2) (Jun. 1991) 273-283.
  • David H. Bailey, "Multiprecision Translation and Execution of Fortran Programs", ACM Transactions on Mathematical Software, vol. 19, no. 3 (Sept. 1993), pg. 288--319
  • Smith, D.M. 1998. Multiple Precision Complex Arithmetic and Functions. ACM Trans. Math. Softw. 24, 4 (December), 359--367
  • http://www.netlib.org