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

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

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.

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