Updated 2015-12-22 12:59:14 by RLE

if 0 {Richard Suchenwirth 2005-02-06 - The delightful exchanges on Googol magnitude led Lars H to code, in Binary representation of numbers:}
``` proc dec2bin {num} {
while {[regexp {[0-9]} \$num]} {
set num\
[string map {o0 0 o1 1 o2 2 o3 3 o4 4 i0 5 i1 6 i2 7 i3 8 i4 9 0 ""}\
[string map {0 0o 1 0i 2 1o 3 1i 4 2o 5 2i 6 3o 7 3i 8 4o 9 4i} \$num]]
}
string map {i 1 o 0} \$num
}

proc bin2dec {num} {
set num h[string map {1 i 0 o} \$num]
while {[regexp {[io]} \$num]} {
set num\
[string map {0o 0 0i 1 1o 2 1i 3 2o 4 2i 5 3o 6 3i 7 4o 8 4i 9 ho h hi h1}\
[string map {0 o0 1 o1 2 o2 3 o3 4 o4 5 i0 6 i1 7 i2 8 i3 9 i4} \$num]]
}
string range \$num 1 end
}```

if 0 {These functions convert between decimal strings (unbounded by arithmetic bit-width of integers, be they 32 or 64) and similarly unbounded bit strings. (Virtual memory might present an ultimate bound...) All numbers are non-negative integers, i.e. 0 or positive.

Now, what can we do with such bit strings, without being limited by bit width? One obvious idea is to perform bitwise operations (& and, | or, ^ xor) on two bit strings. For this, we need to normalize both to equal length, by padding the shorter one with zeroes. Then we can iterate over pairs of corresponding bits and apply the operator (as that comes from an argument, the expr must be unbraced):}
``` proc binop {a op b} {
set la [string length \$a]
set lb [string length \$b]
if {\$la>\$lb} {
set b [string repeat 0 [expr {\$la-\$lb}]]\$b
} elseif {\$la<\$lb} {
set a [string repeat 0 [expr {\$lb-\$la}]]\$a
}
set res ""
foreach i [split \$a ""] j [split \$b ""] {
append res [expr \$i \$op \$j]
}
regsub ^0+ \$res "" res     ;# suppress leading zeroes
expr {\$res eq ""? 0: \$res} ;# but not with 0
}
#-- Testing (using short strings, but Googols are fine too):
proc test {cmd expected} {
catch \$cmd res
if {\$res ne \$expected} {puts "\$cmd->\$res, expected \$expected"}
}
test {binop    1 & 1000} 0
test {binop   11 & 10}   10
test {binop    1 | 1000} 1001
test {binop 1111 ^ 101}  1010

#-- The single unary operator, bitwise NOT (~), gets specific code (and does no sign extension):
proc bin~ a {
regsub ^0+ [string map {0 1 1 0} \$a] "" res
expr {\$res eq ""? 0: \$res} ;# but not with 0
}

test {bin~ 1011}  100
test {bin~ 11111} 0
test {bin~ 0}     1```

if 0 {Other bitstring operations involve shifting - left shift(<<) corresponds to multiplication with powers of 2:}
``` proc bin<< {bits n} {
append bits [string repeat 0 \$n]
}
test {bin<< 111 3} 111000
test {bin<< 111 0} 111```

if 0 {Right shift (>>) corresponds to integer division, remainder discarded, by powers of 2. Note that this is "logical" shifting, not arithmetical, where the sign bit would be propagated, but we don't have one:}
``` proc bin>> {bits n} {
string range \$bits 0 end-\$n
}
test {bin>> 1010 2} 10
test {bin>> 1010 0} 1010```

if 0 { Counting how many 1-bits are in a bit string is useful at times, and that's easily done with regexp:}
``` interp alias {} bitcount {} regexp -all 1

test {bitcount 10110} 3
test {bitcount 0} 0
test {bitcount 11111} 5```

if 0 {Now, just for the fun of it, addition (certainly not the most efficient way to do it...) We need length normalization again, but iterate from right to left:}
``` proc bin+ {a b} {
set la [string length \$a]
set lb [string length \$b]
if {\$la>\$lb} {
set b [string repeat 0 [expr {\$la-\$lb}]]\$b
} elseif {\$la<\$lb} {
set a [string repeat 0 [expr {\$lb-\$la}]]\$a
set la \$lb
}
set res ""
set carry 0
for {set i [incr la -1]} {\$i>=0} {incr i -1} {
set sum [expr {\$carry+[string index \$a \$i]+[string index \$b \$i]}]
set res [expr {\$sum%2}]\$res ;# prepend latest bit
set carry [expr {\$sum/2}]
}
regsub ^0+ \$carry\$res "" res     ;# suppress leading zeroes
expr {\$res eq ""? 0: \$res} ;# but not with 0
}
test {bin+ 11 100}  111
test {bin+ 1  1}    10
test {bin+ 111 111} 1110```

if 0 {Given addition, multiplication is especially easy on base-2 numbers:}
``` proc bin* {a b} {
set res 0
foreach bit [split \$b ""] {
if \$bit {set res [bin+ \$res \$a]}
append res 0 ;# shift <<1, i.e. double
}
string range \$res 0 end-1 ;#-- undo the last <<1 shift
}
test {bin* 100  11} 1100
test {bin* 1010 10} 10100
test {bin* 11   11} 1001```

if 0 {

}