# take a known reciprocal pair of 2 and .5, set result from proportions
             set target_a 2.
             set reciprocal .5
             set doubling_halving_reciprocal [* [/ $target_a $target_number  ] $reciprocal  ]

           # using pseudocode for Babylonian doubling and halving algorithm
           # for reciprocals 
           # irregular defined as not in standard B. table of reciprocals
       supplied values 
         lower limit
         upper limit
         start number
         factor
         standard table  N <  81
         1,2,4,8,16,32,64
         3,6,12,24,48
         5,10,20,40,80
         9,18,36,72 
        doubling and halving algorithm
        reciprocal pairs starting with 1
                                  1   1
                                  2   0.5
                                  4   0.25
                                  8   0.125 
       reciprocal pairs starting with 3                               
                                  3   0.333
                                  6   0.1666
                                 12   0.08333
                                 24   0.04166             
      Late Babylonian interest 1> N > 2
      need to compare result with TCL calculation
      check in error subroutine

**** figure. BABYLONIAN DOUBLING AND HALVING ALGORITHM OVERVIEW **** 

+----------------------------------------------------------------------------------+
| BABYLONIAN DOUBLING AND HALVING ALGORITHM FOR RECIPROCALS                        |
|                                                                                  |
|    Purpose: Generate reciprocal pairs from a known starting pair using           |
|             simple doubling (×2) and halving (×0.5) operations.                 |
|                                                                                  |
|    Core Idea: If you know n and 1/n, then 2×n has reciprocal (1/n)/2            |
|               and 3×n has reciprocal (1/n)/3, etc.                              |
|                                                                                  |
|    Educational Value: One of the simplest and most powerful Babylonian methods   |
|    for extending the standard reciprocal table.                                  |
+----------------------------------------------------------------------------------+

**** figure. ALGORITHM CORE STEPS **** 

+----------------------------------------------------------------------------------+
| CORE STEPS (Doubling and Halving)                                                |
|                                                                                  |
|    1. Start with a known regular reciprocal pair (n , 1/n)                       |
|    2. Double the number → new_n = 2 × n                                         |
|    3. Halve the reciprocal → new_reciprocal = (1/n) / 2                          |
|    4. Repeat as needed (can also triple, quadruple, etc.)                        |
|    5. Verify: new_n × new_reciprocal = 1                                        |
|                                                                                  |
|    This method lets scribes quickly build long tables from a few memorized pairs.|
+----------------------------------------------------------------------------------+

**** figure. STANDARD RECIPROCAL TABLE EXAMPLES **** 

+----------------------------------------------------------------------------------+
| OLD BABYLONIAN STANDARD RECIPROCAL TABLE (Regular Numbers)                       |
|                                                                                  |
|    n       Reciprocal (sexagesimal)     Modern decimal                          |
|    2       0;30                          0.5                                     |
|    3       0;20                          0.333                                   |
|    4       0;15                          0.25                                    |
|    5       0;12                          0.2                                     |
|    6       0;10                          0.1667                                  |
|    8       0;7,30                        0.125                                   |
|    9       0;6,40                        0.1111                                  |
|    10      0;6                           0.1                                     |
|    16      0;3,45                        0.0625                                  |
|    60      0;1                           0.01667                                 |
|                                                                                  |
|    These were memorized by scribes. Doubling/halving extends the table easily.   |
+----------------------------------------------------------------------------------+

**** figure. TESTCASE 1 - STARTING FROM 2 **** 

+----------------------------------------------------------------------------------+
| TESTCASE 1 - DOUBLING SEQUENCE FROM 2                                            |
|                                                                                  |
|    Start:   n=2     reciprocal=0.5                                               |
|    Double:  n=4     reciprocal=0.25                                              |
|    Double:  n=8     reciprocal=0.125                                             |
|    Double:  n=16    reciprocal=0.0625                                            |
|    Double:  n=32    reciprocal=0.03125                                           |
|    Double:  n=64    reciprocal=0.015625                                          |
|                                                                                  |
|    All pairs verify: n × reciprocal = 1                                          |
+----------------------------------------------------------------------------------+

**** figure. TESTCASE 2 & 3 SUMMARY **** 

+----------------------------------------------------------------------------------+
| TESTCASES 2 & 3                                                                  |
|                                                                                  |
|    Testcase 2 (starting from 9):                                                 |
|      9 → 18 → 36 → 72   with reciprocals 0.1111 → 0.0556 → 0.0278 → 0.0139      |
|                                                                                  |
|    Testcase 3 (mixed scaling):                                                   |
|      Shows flexible use of doubling/halving/tripling for different ranges.       |
|                                                                                  |
|    Excellent for extending the standard table up to large powers of 60.          |
+----------------------------------------------------------------------------------+

**** figure. SCALED RECIPROCALS (Practical Babylonian Use) **** 

+----------------------------------------------------------------------------------+
| SCALED RECIPROCALS (igi-n-scaled column)                                         |
|                                                                                  |
|    Scribes usually worked with scaled values multiplied by 3600 (1,0,0).        |
|    Example:                                                                      |
|      1/2  → scaled 30,0,0   (=1800)                                             |
|      1/9  → scaled 6,40,0   (=400)                                              |
|      1/60 → scaled 1,0,0    (=60)                                               |
|                                                                                  |
|    This turns tiny fractions into manageable integers for hand calculation.      |
+----------------------------------------------------------------------------------+

**** figure. BABYLONIAN DOUBLING AND HALVING SUMMARY **** 
+----------------------------------------------------------------------------------+
| SUMMARY                                                                          |
|                                                                                  |
|    Strengths:                                                                    |
|      • Extremely simple — only doubling and halving operations                   |
|      • Extends the memorized standard reciprocal table efficiently               |
|      • Low error rate and easy verification (product = 1)                        |
|      • Core method behind many Babylonian coefficient lists and tables           |
|                                                                                  |
|    The eTCL calculator lets you explore these sequences interactively.           |
+----------------------------------------------------------------------------------+

        # pretty print from autoindent and ased editor
        # Babylonian doubling and halving algorithm for reciprocals  calculator
        # written on Windows XP on eTCL
        # working under TCL version 8.5.6 and eTCL 1.0.1
        # gold on TCL WIKI, 2nov2017
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        frame .frame -relief flat -bg aquamarine4
        pack .frame -side top -fill y -anchor center
        set names {{} {lower limit :} }
        lappend names {upper limit:}
        lappend names {doubling factor (usually 2. ) : }
        lappend names {optional: halving factor (usually 0.5 ): }
        lappend names {answers: trial  :}
        lappend names {function : }
        lappend names {percentage error: }
        lappend names {initial reciprocal :} 
        foreach i {1 2 3 4 5 6 7 8} {
            label .frame.label$i -text [lindex $names $i] -anchor e
            entry .frame.entry$i -width 35 -textvariable side$i
            grid .frame.label$i .frame.entry$i -sticky ew -pady 2 -padx 1 }
        proc about {} {
            set msg "Calculator for doubling and halving algorithm for reciprocals
            from TCL WIKI,
            written on eTCL "
            tk_messageBox -title "About" -message $msg } 
       proc ::tcl::mathfunc::precision {precision float}  {
            #  tcl:wiki:Floating-point formatting, [AM]
            set x [ format "%#.5g" $float ]
            return $x
           }   
            #proc errorx always returns a positive error. 
            #Normally assume $aa is human estimate,
            #assume $bb is divinely exact.
       proc errorx  {aa bb} {expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*100. : (($bb*1.)/$aa -1.)*100.}}
             proc doubling_halving_algorithm { target_number } {
             # initialize placeholder answer
             set doubling_halving_reciprocal 1.
             set target_a 2.
             set reciprocal .5
             set doubling_halving_reciprocal [* [/ $target_a $target_number  ] $reciprocal  ]
             return $doubling_halving_reciprocal
             }
       proc calculate {     } {
            global answer2
            global side1 side2 side3 side4 side5
            global side6 side7 side8 
            global lower_limit upper_limit doubling_factor
            global testcase_number
            global doubling_halving_reciprocal check_answer_product4
            incr testcase_number 
            set side1 [* $side1 1. ]
            set side2 [* $side2 1. ]
            set side3 [* $side3 1. ]
            set side4 [* $side4 1. ]
            set side5 [* $side5 1. ]
            set side6 [* $side6 1. ]
            set side7 [* $side7 1. ]
            set side8 [* $side8 1. ]
            # initialize placeholder answer
            set doubling_halving_reciprocal 1.
            set doubling_factor $side3
            # begin doubling_halving_algorithm
            set lower_limit $side1
            set upper_limit $side2
                    }
        proc fillup {aa bb cc dd ee ff gg hh} {
            .frame.entry1 insert 0 "$aa"
            .frame.entry2 insert 0 "$bb"
            .frame.entry3 insert 0 "$cc"
            .frame.entry4 insert 0 "$dd"
            .frame.entry5 insert 0 "$ee"
            .frame.entry6 insert 0 "$ff" 
            .frame.entry7 insert 0 "$gg"
            .frame.entry8 insert 0 "$hh" 
             }
        proc clearx {} {
            foreach i {1 2 3 4 5 6 7 8 } {
                .frame.entry$i delete 0 end } }
        proc reportx {} {
            global answer2
            global side1 side2 side3 side4 side5
            global side6 side7 side8 
            global lower_limit upper_limit doubling_factor
            global testcase_number
            console show;
            puts "%|table $testcase_number|printed in| tcl wiki format|% "
            puts "&| quantity| value| comment, if any|& "
            puts "&| $testcase_number:|testcase_number | |&"
            puts "&| $side1 :|lower limit  |   |&"
            puts "&| $side2 :|upper limit | |& "  
            puts "&| $side3 :|doubling factor (usually 2. ) | |& "
            puts "&| $side4 :|optional: halving factor (usually 0.5 ): | |&"
            puts "&| $side5 :|answers: trial | |&"
            puts "&| $side6 :|function |  |&"
            puts "&| $side7 :|percentage error |  |&"
            puts "&| $side8 :|initial reciprocal |  |&" 
            puts " reciprocal [ doubling_halving_algorithm 10 ] "
             set counter 1
             set keeper 1
             set reciprocal 1.
             puts "%|doubling_halving_algorithm|printed in| tcl wiki format| || |% "
             puts "&| quantity| value| factor |comment, if any|||&"
             puts "&| line number | target number | factor |  reciprocal solution |||&"
             set target_number 1.
             while { $keeper < $upper_limit  } {    
             set keeper [* $keeper $doubling_factor ] 
             set reciprocal [* $reciprocal [/ 1. $doubling_factor ] ] 
             puts "&| $counter | $keeper  | $reciprocal  | answer for reciprocal |
[/ 1. $keeper ]  | 1/n comparison with tcl math |&   "      
             incr counter   
             } 

            }
        frame .buttons -bg aquamarine4
        ::ttk::button .calculator -text "Solve" -command { set side8 0 ; calculate   }
        ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 1.  81.0 2.0 0.5  4.0   1.0   1.0    0.5}
        ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 1.0 81.0 2.0 0.5  9.0   1.0  0.138   2.1}
        ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 1.0 81.0 2.0 0.5  81.0  1.0  0.5     1.1}
        ::ttk::button .clearallx -text clear -command {clearx }
        ::ttk::button .about -text about -command {about}
        ::ttk::button .cons -text report -command { reportx }
        ::ttk::button .exit -text exit -command {exit}
        pack .calculator  -in .buttons -side top -padx 10 -pady 5
        pack  .clearallx .cons .about .exit .test4 .test3 .test2   -side bottom -in .buttons
        grid .frame .buttons -sticky ns -pady {0 10}
               . configure -background aquamarine4 -highlightcolor brown -relief raised -border 30
        wm title . "Babylonian Doubling and Halving Algorithm for Reciprocals Calculator"     

  puts " %| testcase $testcase_number | value| units |comment |%"
  puts " &| volume| $volume| cubic meters |based on length $side1 and width $side2   |&"  

                  # autoindent from ased editor
                  # console program for doubling_halving reciprocal algorithm 
                  # written on Windows XP on eTCL
                  # working under TCL version 8.5.6 and eTCL 1.0.1
                  # TCL WIKI , 30jan2017
             console show
             package require math::numtheory
             namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory } 
             proc doubling_halving_algorithm { target_number } {
             global side1 side2 side3 side4 side5
             global side6 side7 side8 
             global doubling_halving_reciprocal check_answer_product4
             # initialize placeholder answer
             set doubling_halving_reciprocal 1.
             set target_a 2.
             set reciprocal .5
             set doubling_halving_reciprocal [* [/ $target_a $target_number  ] $reciprocal  ]
             #puts "doubling_halving $doubling_halving_reciprocal "
             return $doubling_halving_reciprocal
             }
            # initialize placeholder answer
            set doubling_halving_reciprocal 1.
            # begin doubling_halving_algorithm
            # set doubling_halving_reciprocal [ doubling_halving_algorithm $target_number ]
             set counter 1
             puts "%|doubling_halving_algorithm|printed in| tcl wiki format| || |% "
             puts "&| quantity| value| factor |comment, if any|||&"
             puts "&| line number | target number | factor |  reciprocal solution |||&"
             set target_number 1.
             while { $counter < 50.  } {           
             set target_number [* 2. $target_number ]
             puts "&| $counter |$target_number  | [ doubling_halving_algorithm $target_number ] | answer for reciprocal |[/ 1. 

$target_number ] | 1/n comparison with tcl math |&   "      
             incr counter   
             } 

n_sexagesimal,n_decimal,igi_n_sexagesimal,igi_n_decimal,modern_fraction
2,2,0;30,0.5,1/2
3,3,0;20,0.3333333333333333,1/3
4,4,0;15,0.25,1/4
5,5,0;12,0.2,1/5
6,6,0;10,0.16666666666666666,1/6
8,8,0;7,30,0.125,1/8
9,9,0;6,40,0.1111111111111111,1/9
10,10,0;6,0.1,1/10
12,12,0;5,0.08333333333333333,1/12
15,15,0;4,0.06666666666666667,1/15
16,16,0;3,45,0.0625,1/16
18,18,0;3,20,0.05555555555555555,1/18
20,20,0;3,0.05,1/20
24,24,0;2,30,0.041666666666666664,1/24
25,25,0;2,24,0.04,1/25
27,27,0;2,13,20,0.037037037037037035,1/27
30,30,0;2,0.03333333333333333,1/30
36,36,0;1,40,0.027777777777777776,1/36
40,40,0;1,30,0.025,1/40
45,45,0;1,20,0.022222222222222223,1/45
48,48,0;1,15,0.020833333333333332,1/48
50,50,0;1,12,0.02,1/50
54,54,0;1,6,40,0.018518518518518517,1/54
1,0,60,0;1,0.016666666666666666,1/60
1,4,64,0;0,56,15,0.015625,1/64
1,15,75,0;0,48,0.013333333333333334,1/75
1,21,81,0;0,44,26,40,0.012345679012345678,1/81
1,40,100,0;0,36,0.01,1/100
2,0,120,0;0,30,0.008333333333333333,1/120
2,15,135,0;0,26,40,0.007407407407407408,1/135
2,24,144,0;0,25,0.006944444444444444,1/144
3,0,180,0;0,20,0.005555555555555556,1/180
4,0,240,0;0,15,0.004166666666666667,1/240
5,0,300,0;0,12,0.0033333333333333335,1/300
6,0,360,0;0,10,0.002777777777777778,1/360
8,0,480,0;0,7,30,0.0020833333333333333,1/480
9,0,540,0;0,6,40,0.001851851851851852,1/540
10,0,600,0;0,6,0.0016666666666666668,1/600
12,0,720,0;0,5,0.001388888888888889,1/720
15,0,900,0;0,4,0.0011111111111111111,1/900
18,0,1080,0;0,3,20,0.000925925925925926,1/1080
20,0,1200,0;0,3,0.0008333333333333334,1/1200
24,0,1440,0;0,2,30,0.0006944444444444445,1/1440
30,0,1800,0;0,2,0.0005555555555555556,1/1800
36,0,2160,0;0,1,40,0.00046296296296296297,1/2160
45,0,2700,0;0,1,20,0.00037037037037037035,1/2700
1,0,0,3600,0;0,1,0.0002777777777777778,1/3600

n_sexagesimal,n_decimal,igi_n_sexagesimal,igi_n_decimal,modern_fraction,igi_n_scaled_sexagesimal,igi_n_scaled_decimal,meaning
2,2,0;30,0.5,1/2,30,0,0,1800,"3600/2"
3,3,0;20,0.3333333333333333,1/3,20,0,0,1200,"3600/3"
4,4,0;15,0.25,1/4,15,0,0,900,"3600/4"
5,5,0;12,0.2,1/5,12,0,0,720,"3600/5"
6,6,0;10,0.16666666666666666,1/6,10,0,0,600,"3600/6"
8,8,0;7,30,0.125,1/8,7,30,0,450,"3600/8"
9,9,0;6,40,0.1111111111111111,1/9,6,40,0,400,"3600/9"
10,10,0;6,0.1,1/10,6,0,0,360,"3600/10"
12,12,0;5,0.08333333333333333,1/12,5,0,0,300,"3600/12"
15,15,0;4,0.06666666666666667,1/15,4,0,0,240,"3600/15"
16,16,0;3,45,0.0625,1/16,3,45,0,225,"3600/16"
18,18,0;3,20,0.05555555555555555,1/18,3,20,0,200,"3600/18"
20,20,0;3,0.05,1/20,3,0,0,180,"3600/20"
24,24,0;2,30,0.041666666666666664,1/24,2,30,0,150,"3600/24"
25,25,0;2,24,0.04,1/25,2,24,0,144,"3600/25"
27,27,0;2,13,20,0.037037037037037035,1/27,2,13,20,133.33333333333334,"3600/27"
30,30,0;2,0.03333333333333333,1/30,2,0,0,120,"3600/30"
36,36,0;1,40,0.027777777777777776,1/36,1,40,0,100,"3600/36"
40,40,0;1,30,0.025,1/40,1,30,0,90,"3600/40"
45,45,0;1,20,0.022222222222222223,1/45,1,20,0,80,"3600/45"
48,48,0;1,15,0.020833333333333332,1/48,1,15,0,75,"3600/48"
50,50,0;1,12,0.02,1/50,1,12,0,72,"3600/50"
54,54,0;1,6,40,0.018518518518518517,1/54,1,6,40,66.66666666666667,"3600/54"
1,0,60,0;1,0.016666666666666666,1/60,1,0,0,60,"3600/60"
1,4,64,0;0,56,15,0.015625,1/64,0,56,15,56.25,"3600/64"
1,15,75,0;0,48,0.013333333333333334,1/75,0,48,0,48,"3600/75"
1,21,81,0;0,44,26,40,0.012345679012345678,1/81,0,44,26,40,44.44444444444444,"3600/81"
1,40,100,0;0,36,0.01,1/100,0,36,0,36,"3600/100"
2,0,120,0;0,30,0.008333333333333333,1/120,0,30,0,30,"3600/120"
2,15,135,0;0,26,40,0.007407407407407408,1/135,0,26,40,26.666666666666668,"3600/135"
2,24,144,0;0,25,0.006944444444444444,1/144,0,25,0,25,"3600/144"
3,0,180,0;0,20,0.005555555555555556,1/180,0,20,0,20,"3600/180"
4,0,240,0;0,15,0.004166666666666667,1/240,0,15,0,15,"3600/240"
5,0,300,0;0,12,0.0033333333333333335,1/300,0,12,0,12,"3600/300"
6,0,360,0;0,10,0.002777777777777778,1/360,0,10,0,10,"3600/360"
8,0,480,0;0,7,30,0.0020833333333333333,1/480,0,7,30,7.5,"3600/480"
9,0,540,0;0,6,40,0.001851851851851852,1/540,0,6,40,6.666666666666667,"3600/540"
10,0,600,0;0,6,0.0016666666666666668,1/600,0,6,0,6,"3600/600"
12,0,720,0;0,5,0.001388888888888889,1/720,0,5,0,5,"3600/720"
18,0,1080,0;0,3,20,0.000925925925925926,1/1080,0,3,20,3.3333333333333335,"3600/1080"
20,0,1200,0;0,3,0.0008333333333333334,1/1200,0,3,0,3,"3600/1200"
24,0,1440,0;0,2,30,0.0006944444444444445,1/1440,0,2,30,2.5,"3600/1440"
36,0,2160,0;0,1,40,0.00046296296296296297,1/2160,0,1,40,1.6666666666666667,"3600/2160"
45,0,2700,0;0,1,20,0.00037037037037037035,1/2700,0,1,20,1.3333333333333333,"3600/2700"
1,0,0,3600,0;0,1,0.0002777777777777778,1/3600,1,1,"3600/3600"

igi-n-scaled = 1/ n × 60 × 60 = 3600 / n

Examples: 
igi-2 = 0;30 → scaled = 30,0,0 (= 1800) because 3600 ÷ 2 = 1800  
igi-9 = 0;6,40 → scaled = 6,40,0 (= 400) because 3600 ÷ 9 = 400  
igi-1,0,0 (3600) = 0;0,1 → scaled = 1