# 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

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