This page is under development. Constructive comments are welcome, but please load any constructive comments in the comments section at the bottom of the page. Please include your wiki MONIKER and date in your comment with the same courtesy that I will give you. Aside from your courtesy, your wiki MONIKER and date as a signature and minimal good faith of any internet post are the rules of this TCL-WIKI. Its very hard to reply reasonably without some background of the correspondent on his WIKI bio page. Thanks, gold 9/27/2025
gold Here are some TCL calculations for Babylonian Splitting and Doubling Algorithm. Additional utility programs below are used to check or improve subroutine.
The Babylonian splitting and doubling algorithm, developed around 1600 BCE, represents one of the earliest documented mathematical methods. This algorithm, found on cuneiform clay tablets, allowed Babylonian scribes to handle large numbers in their base-60 number system. Engineering students today can learn from this ancient technique. The algorithm breaks down complex calculations into simpler steps. This approach aligns with modern computational strategies. The introduction of modern tools, like the Tool Command Language (TCL), helps translate these ancient methods into decimal notation.
The college institutes, textbooks, and computer companies in the USA that previously used the Babylonian mathematical ideas without credit may be glad to know that the Babylonian copyrights and patents expired about 4000 years ago.
In the cuneiform math problems and coefficient lists on clay tablets, there are coefficient numbers which were used in determining the amount of materials and the daily work rates of the workers. In most cases, the math problem is how the coefficient was used in estimating materials, work rates, and math problems. One difficulty is determining the effective magnitude or power of the number coefficient in the base 60 notation. In cuneiform, numbers in base 60 are written on clay tablets using a notation of relative place value. For example, 20 could represent either 20*3600,20*60,20,20/60, 20/3600, or even 1/20. The basic dimensions and final tallies were presented in the cuneiform accounts on clay tablets, but some calculations, some units, and some problem answers (aw shucks!) were left off the tablet. Successive or iterated math solutions are called algorithms and the multiplication methods are some of the earliest algorithms documented, ref the bulk of math tablets were circa 1600 BCE. The TCL procedures are descendants of this idea. The Babylonians did not use algebra notation, decimal notation, or modern units, so the reader will have to bear some anachronisms in the TCL code. At least one approach for the modern reader and using modern terminology is to develop the implied algebraic equations and decimal equivalents from the cuneiform numbers. Then the TCL calculator can be run over a number of testcases to validate the algebraic equations. For the examples of presenting algorithms to modern readers, the calculator shell will give product in modern decimal units. The units can be changed in the internal calculator formulas as TCL code. Any convenient and consistent output units might be used like millimeters, inches, cubits, feet, or dollars to donuts.
For comparison of the Babylonian algorithm(s) with conventional Western methods, TCL code may include redundant procedures, redundant calculation paths, and printout check formulas to compute product, area, check diagnostics, and relative errors.
The Babylonian splitting and doubling algorithm is an ancient mathematical method. This method breaks large numbers into smaller parts. Each part is doubled or multiplied separately. The results are then recombined. The Babylonians used this method to handle numbers too large for direct calculation in their base-60 number system.
Modern engineering students can apply this same logic. The splitting and doubling algorithm is similar to modern divide-and-conquer strategies. These strategies appear in computer science, signal processing, and numerical methods. Breaking a large problem into smaller pieces makes computation more manageable. Recombining the results gives the final answer. Consider a simple example in Base 10 and modern decimal notation . An engineer needs to multiply 7,200 by 5. The number 7,200 is large in the Babylonian system. The Babylonian scribe splits 7,200 into 6,000 and 1,200. The scribe doubles 6,000 to get 12,000. The scribe doubles 1,200 to get 2,400. The scribe adds 12,000 and 2,400 to get 14,400. The scribe then multiplies 14,400 by 5 to get 72,000. The splitting step avoids direct handling of the full large number. This method may reduce computational error in some cases.
The Babylonian number system lacked the modern or conventional symbol for zero. Positional errors were common when recombining large numbers. Smaller numbers are less prone to these errors. Modern digital systems also benefit from modular computation. Splitting data reduces memory load and improves processing speed. Another example appears in Fast Fourier Transform algorithms. The Fast Fourier Transform breaks a large signal into smaller segments. Each segment is processed separately. The results are combined to form the full transform. This is the same logic as the Babylonian method. Note. The traces of the Babylonian development on the Zero concept are discussed elsewhere in more scholarly journals, very rare tablets in Astronomy.
The splitting reduces complexity. The recombination builds the final result. In structural engineering, large load calculations are often split into components. A building’s total load is divided into roof load, wall load, and foundation load. Each is calculated separately. The results are summed. This avoids overwhelming a single calculation. It also allows parallel computation. Teams can work on different parts at the same time.
The Babylonian method also teaches error management. When recombining split parts, the Babylonians sometimes made positional mistakes in place value, for lack of conventional Zero notation. Modern engineers face similar issues with floating-point precision or unit mismatches. Checking each recombination step prevents cumulative errors.
The Babylonian tablets show that even ancient engineers understood the need for verification. This algorithm is useful in embedded systems with limited memory. A microcontroller may not store a large number directly. The number is split into bytes or words. Each is processed. The results are merged. This is the Babylonian method in silicon.
The splitting and doubling algorithm is not outdated. It is a foundational concept. It shows that large problems become manageable when divided. It reminds engineers that recombination must be precise. The Babylonians developed this method without computers. Modern engineers use it with computers. The core idea remains unchanged.
This Babylonian splitting and doubling algorithm in the clay tablets has parallels to how I was taught to use the slide rule, which uses logarithms. You can tell me differently. In the college slide rule, we were taught to separate the mantissa from the powers of ten. In preliminary calculations with engineering notation, the powers of ten were calculated in divisor and numerator for an estimate to powers of ten, and then the mantissa was calculated with small number and decimal fractions, usually less than ten. In the splitting and doubling algorithm, the maximum power of Base 60 is split off. Something similar was done in Base 10 with the calculations using logarithm tables.
There were restrictions in computing reciprocals in the Babylonian number system. Only integer numbers that have integer factors 2,3,5 and smooth. Smooth meaning, have exact reciprocals in the Babylonian system. All other reciprocals require approximation techniques. Especially, prime numbers 7, 13, and above could only have approximate reciprocals in the reciprocal tables used for division, etc. It is conjectured that one use for the Babylonian splitting and doubling algorithm was calculating irregular reciprocal pairs, or one might say, the algorithm is a work around for the difficulty of handling the prime numbers in the Babylonian number system.
The Arakarum scaling technique provides a template for modern numerical methods that use temporary scaling to avoid computational overflow or underflow conditions in embedded systems with limited computational resources. The Babylonian mathematicians were using the Arakarum scaling methods because of the difficulty of handling irregular reciprocals in their Base 60 system. Note. Arakarum method: scale or multiply prime/irregular reciprocal by k (2 or 3), compute problem, divide out k . The last stage was often omitted in the notation on clay tablets and causes great confusion to modern readers.
Here's how Old Babylonian mathematical problems were structured in typical practice. When a mathematical problem was presented, it typically started with measurements using familiar units like length, area, or volume. These problems were usually posed by administrators working in the standard base-10 system that most people understood for everyday transactions.
The scribes responsible for solving these problems would then translate the given values into Babylonian sexagesimal notation (base-60). This conversion was a crucial step because all mathematical operations were performed in base-60, which offered significant computational advantages for handling fractions and reciprocals compared to other numbering systems.
Once the calculations were completed in base-60, the scribes would convert the final results back to the original measurement units and express them in base-10 format. This translation step ensured that the answers remained practical and accessible to the officials who commissioned the work. There are a few cuneiform problems that use base-10 throughout or else annotated in base-10, but not common tablets.
This problem workflow demonstrates a sophisticated understanding of mathematical systems optimization. The Babylonians recognized that while base-60 was superior for computational efficiency, base-10 remained more intuitive for practical applications. Modern engineering teams use similar approaches when they perform complex calculations in specialized software or coordinate systems, then present results in units and formats that stakeholders can readily interpret and apply. This is somewhat like the modern and occasional practice of using English units for product specifications, converting to Metric units for calculations, and then returning the answer to English units.
Note. Based on passage by Prof. Joran Friberg in Remarkable Collection of Babylonian tablets, section 03b
In the Late Babylonian period, there were numerous tablets and fragments showing many place reciprocals and factoring other numbers in base_60. The many place reciprocals are reciprocals with 5 to 10 places in base_60. The most unusual tables were many place reciprocals between 1 and 2, ref Friberg and Al-Rawi. Although less common or less extant, there are tables of many place reciprocals between 2 and 4. The square root of sixty is decimal 7.74, so continuing the tables beyond integer 8 would be redundant and not be useful. The tablets with many place reciprocals between 1 and 2 are generated for numbers between 60 and 30. The tablets with many place reciprocals between 2 and 4 are generated for numbers between 30 and 15. Because the Babylonians used relative place notation like a modern slide rule, remember that the calculated many place reciprocals between 60 and 15 could been used in relative base_60 places like 20,20*60,20*3600,20*216000 , and so on.
In addition, there are rare LB. fragments or tables that have numbers in reciprocal pairs in base_60 with the added glyph ibsi, which means either square or square root, ref Friberg and Al-Rawi. In a general sense on other tablets, the term ibsi is associated with square roots, cube roots, raising a number in exponent, or the reverse, but the term ibsi linked with reciprocals is curious. The minimal conclusion is that the Late Babylonian mathematicians considered the regular base_60 reciprocals involved with squares, square roots, or powers. A complete explanation of the many place reciprocal tables is not available, but it has been proven that the many place reciprocals and square tables were used in school copying exercises, school multiplication assignments, and factoring algorithms. There are two multiplication formulas from the Old Babylonian tablets that used differences, sums, and squares. With a squint eye of the amateur, the Old Babylonian tables with many place reciprocals in base_60 look somewhat like the many place numbers (meaning digits) in the modern tables for decimal and natural logarithms.
The Babylonian splitting and doubling algorithm offers timeless lessons for engineering students. This method simplifies complex calculations by breaking them into manageable parts. The algorithm’s error management strategies remain relevant for modern systems. TCL implementations make these ancient techniques accessible.
# using pseudocode for Babylonian expansion procedure algorithm.
# Professor Mathieu Ossendrijver is jumping through 5 different procedures
# for area of trapezoid and right angle trapezoid.
# Conventional formulas for trapezoid area from
# The other Wiki articles use conventional meters on all four sides.
# The Babylonian astronomy procedures use the sides and floor
# in degrees along the Zodiac and days of observation, respectively.
# possible problem instances include add 1/60 to sides until area goal reached
long_side = supplied value
short_side = supplied value
desired_goal = supplied value
# desired_goal usually 100 square units in some early math problems
set old_field_area = a*b , old field_area = long_side * short_side
set new_side_a = long_side + 1/60
set new_side_b = short_side + 1/60
set new_field_area = (long_side + 1/60) * ( short_side + 1/60 )
is new_field_area =? desired_area within +/- (1/60) , yes = finished loop
check error , abs (desired_goal - new_field_area) <= [/ 1. 60.]
half area = area * .5
quarter area = area * .25
check_answer new area =? desired goal , desired goal reached (yes/no)
set answers and printout with resulting values
formulas
following includes algebraic expressions,
terms, and notation
Western trapezoid formulas
and trapezoidal prism volume
following includes algebraic expressions,
terms, and notation not used on tablets
side_aa refs top, t. on side
side_bb refs bottom, t. on side
side_cc refs height, t. on side
median_length = .5*(side_aa+side_bb)
trapezoid_area= 0.5*(side_aa+side_bb)*height
trapezoid_area= median*height
trapezoidal_prism_volume=
t. vol=length*(0.5*(side_aa+side_bb))*height
median divides equal side lengths
Equations reference
1) median = .5*(l+s) conventional
2) trapezoid area = .5*(l+s)*h conventional
3) feed = (l-s)/h trapezoid_area_sq_law
4) h = (l-s)/feed trapezoid_area_sq_law
5) trapezoid area = (l**2-s**2)/(2.*feed) trapezoid_area_sq_law
# Also, the B. square rule for trapezoid area
# was extended to volumes by *width factor.
6) trapezoidal volume = .5*(l+s)*h*w conventional
7) trapezoidal volume = w*(l**2-s**2)/(2.*feed) trapezoid_area_sq_law
# cribbed code from quad page
set perimeter [+ $side1 $side2 $side3 $side4 ]
set reference_factor [/ [+ [* $side1 $side1 ] [* $side2 $side2 ]] [+ [* $side3 $side3 ] [* $side4 $side4 ]]]
if { $reference_factor > 1.1} { set flag 1. }
if { $reference_factor < 0.9} { set flag 1. }
set semip [* $perimeter .5 ]
set cyclic_quad_area [sqrt [* [- $semip $side1 ] [- $semip $side2 ] [- $semip $side3 ] [- $semip $side4 ]]]
set approx_quad_area [* [* .5 [+ $side1 $side3 ]] [* .5 [+ $side2 $side4 ] ] ]
# >>>> mean speed theorem follows <<<<<
# mean_speed_1 defined apparent velocity of Jupiter along Zodiac in degrees per day
# mean_speed_1 = [ expr { .5 * (velocity_1 + velocity_0 )} ]
# distance = mean speed * time in days, distance in total degrees (Babylonian us units)
# time in days = distance / mean speed
# time in days = [ expr { 5.659086123394399/(.5*(12./60+10./60+49./3600+20./21600) )} ]
# "exact solution time " = 29.690614589584406 days
# base_60 rounding in text a
# time in days = [ expr { (5.+22./60+30./3600)/(.5*(12./60+10./60+49./3600+20./21600) )} ]
# time = 28.200145737187267, rounded to 28 in text a
# end of file, pseudocode:Axiom 1: Numbers ≥ 60^4 unstable for direct use in B. system; split and recombine for larger (up to 60^9). Axiom 2: Split large numbers, compute parts, recombine by position; errors from no zero/ambiguous notation. Axiom 3: Recip(a·n) = recip(n)/a for regular a; for primes, use Arakarum_k: compute k/n, divide by k later. Axiom 4: Only 2,3,5-smooth numbers have exact reciprocals; Arakarum embeds others via scaling. Axiom 5: Finite reciprocal tables extended by scaling, interpolation, or factorization; prone to recombination errors. Axiom 6: Arakarum: scale prime/irregular reciprocal by k (2 or 3), compute, divide out k (often omitted in notation).
# TCL Version: 8.6 (chosen for maximum compatibility with university standards)
# Math Operations: Uses core TCL expr commands (e.g., *, /, pow) only.
# No external packages (e.g., mathop, math::bignum) required for portability.
# Purpose: Simulate Babylonian reciprocal pair scaling for factors 2, 3, or k,
# in sexagesimal and base-10 (engineering notation), with multi-tablet scheme.
# Utility: Convert base-10 decimal to sexagesimal (returns list of digits)
proc to_sexagesimal {num {places 6}} {
# Input: num (base-10 float), places (number of fractional digits)
# Output: Sexagesimal string (e.g., 0.5 -> 0;30)
set integer [expr {int($num)}]
set fraction [expr {$num - $integer}]
set result [list]
# Integer part (base-60 digits)
set int_digits [list]
set temp $integer
while {$temp > 0} {
lappend int_digits [expr {$temp % 60}]
set temp [expr {$temp / 60}]
}
if {[llength $int_digits] == 0} {lappend int_digits 0}
# Fractional part (base-60 digits)
set frac_digits [list]
set temp $fraction
for {set i 0} {$i < $places && $temp > 0} {incr i} {
set temp [expr {$temp * 60}]
lappend frac_digits [expr {int($temp)}]
set temp [expr {$temp - int($temp)}]
}
# Combine parts
if {[llength $int_digits] > 0} {
set result [join [lreverse $int_digits] ","]
} else {
set result "0"
}
if {[llength $frac_digits] > 0} {
append result ";" [join $frac_digits ","]
}
return $result
}
# Utility: Convert sexagesimal string to base-10
proc from_sexagesimal {sex_str} {
# Input: Sexagesimal string (e.g., "0;30")
# Output: Base-10 float (e.g., 0.5)
set parts [split $sex_str ";"]
set int_part [lindex $parts 0]
set frac_part [lindex $parts 1]
# Integer part
set int_digits [split $int_part ","]
set int_value 0.0
for {set i 0} {$i < [llength $int_digits]} {incr i} {
set digit [lindex $int_digits [expr {[llength $int_digits] - 1 - $i}]]
set int_value [expr {$int_value + $digit * pow(60, $i)}]
}
# Fractional part
set frac_digits [split $frac_part ","]
set frac_value 0.0
for {set i 0} {$i < [llength $frac_digits]} {incr i} {
set digit [lindex $frac_digits $i]
set frac_value [expr {$frac_value + $digit * pow(60, -($i + 1))}]
}
return [expr {$int_value + $frac_value}]
}
# Core: Scale reciprocal pair by factor k
proc scale_reciprocal {n recip k {base 60}} {
# Input: n (base-10 number), recip (base-10 reciprocal), k (scaling factor), base (default 60)
# Output: List of new_n, new_recip (sexagesimal), new_recip (base-10 engineering)
# Math: Uses expr with *, / only; no mathop required
set new_n [expr {$k * $n}]
set new_recip [expr {$recip / $k}]
return [list $new_n [to_sexagesimal $new_recip] [format "%.10e" $new_recip]]
}
# Generate sequence of reciprocal pairs for factor k
proc generate_table {start_n start_recip k max_iter {base 60}} {
# Input: start_n, start_recip (initial pair), k (factor), max_iter (iterations), base
# Output: List of pairs [n, recip_sexagesimal, n_base10, recip_base10]
set result [list]
set n $start_n
set recip $start_recip
for {set i 0} {$i < $max_iter} {incr i} {
lappend result [list $n [to_sexagesimal $recip] [format "%.10e" $n] [format "%.10e" $recip]]
set pair [scale_reciprocal $n $recip $k $base]
set n [lindex $pair 0]
set recip [expr {$recip / $k}]
}
return $result
}
# Simulate multi-tablet scheme: Combine results from multiple "tablets"
proc multi_tablet_scheme {start_n start_recip k max_iter places {base 60}} {
# Input: start_n, start_recip, k, max_iter, places (sexagesimal precision), base
# Simulates Babylonian multi-tablet calculation by splitting iterations
puts "Simulating multi-tablet calculation for factor $k, $max_iter iterations, $places places"
set tablet1 [generate_table $start_n $start_recip $k [expr {$max_iter / 2}]]
set tablet2 [generate_table [lindex [lindex $tablet1 end] 0] \
[from_sexagesimal [lindex [lindex $tablet1 end] 1]] \
$k [expr {$max_iter - ($max_iter / 2)}]]
puts "Tablet 1 Results:"
foreach row $tablet1 {
puts "n: [lindex $row 2], recip: [lindex $row 1] ([lindex $row 3])"
}
puts "Tablet 2 Results:"
foreach row $tablet2 {
puts "n: [lindex $row 2], recip: [lindex $row 1] ([lindex $row 3])"
}
}
# Example usage for factor 2 (doubling)
puts "Factor 2 (Doubling) Example:"
multi_tablet_scheme 2 0.5 2 10 6
# Example usage for factor 3
puts "\nFactor 3 Example:"
multi_tablet_scheme 3 [expr {1.0/3}] 3 10 6
Factor 2 (Doubling) Example:
Simulating multi-tablet calculation for factor 2, 10 iterations, 6 places
Tablet 1 Results:
n: 2.0000000000e+00, recip: 0;30 (5.0000000000e-01)
n: 4.0000000000e+00, recip: 0;15 (2.5000000000e-01)
...
Tablet 2 Results:
n: 6.4000000000e+01, recip: 0;0,56,15 (1.5625000000e-02)
...
Factor 3 Example:
Simulating multi-tablet calculation for factor 3, 10 iterations, 6 places
Tablet 1 Results:
n: 3.0000000000e+00, recip: 0;20 (3.3333333333e-01)
n: 9.0000000000e+00, recip: 0;6,40 (1.1111111111e-01)
...
Tablet 2 Results:
n: 7.2900000000e+02, recip: 0;0,4,56,17,46,40 (1.3717421125e-03)
...
Please place any comments here, Thanks.
| Category Numerical Analysis | Category Toys | Category Calculator | Category Mathematics | Category Example | Toys and Games | Category Games | Category Application | Category GUI |