# pretty print from autoindent and ased editor
        # Babylonian Cubic Equation Algorithm calculator
        # written on Windows XP on eTCL
        # working under TCL version 8.5.6 and eTCL 1.0.1
        # gold on TCL WIKI, 15jan2017
        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 {{} { length f(a) cubits : a*1 } }
        lappend names { front f(a) cubits :  a*(2/3)}
        lappend names { depth f(a) cubits :  a*12+1 : }
        lappend names { depth f(a), 2nd term cubits :  a*12+1 : }
        lappend names { volume cubic cubits:}
        lappend names {answers: length : }
        lappend names {front : }
        lappend names {depth :} 
        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 Babylonian Cubic Equation Algorithm 
            from TCL WIKI,
            written on eTCL "
            tk_messageBox -title "About" -message $msg } 
        proc table_look_up {limit } {
             global look_up_function counter
             set counter 1
             while { $counter < 50.  } {
             set look_up_function [* $counter $counter [- $counter 1] ]
             if { [* $counter $counter [- $counter 1] ]   > [* $limit] } {return $counter ; break}            
             incr counter   
             }  
             }
       proc calculate {     } {
            global answer2
            global side1 side2 side3 side4 side5
            global side6 side7 side8
            global look_up_function counter check_product_lfd 
            global testcase_number 
            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. ]
            # a*1* a*(2/3)*(a*(5/6)+1)= vol
            set a 6.
            set room_volume $side5
            set a [ table_look_up $room_volume ]
            set room_volume [expr  ($a*$side1)*($a*$side2)*($a*$side3+$side4) ]
            set length [expr  $a*$side1 ]
            set front [expr   $a*$side2 ]
            set depth [expr   $a*$side3+$side4 ]
            set check_product_lfd [* $length $front $depth 1. ]
            set side6 $length
            set side7 $front
            set side8 $depth
             }
        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 side1 side2 side3 side4 side5
            global side6 side7 side8 
            global look_up_function counter check_product_lfd
            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 :|length cubits|   |&"
            puts "&| $side2 :|front cubits   | |& "  
            puts "&| $side3 :|depth cubits | |& "
            puts "&| $side4 :|depth 2nd term  cubits | |&"
            puts "&| $side5 :|volume cubic cubits:  | |&"
            puts "&| $look_up_function :|volume limit table look up:  | |&"
            puts "&| $counter :|table look up solution:  | |&"
            puts "&| $check_product_lfd :|check; product length*front*depth =? vol :  | |&"
            puts "&| $side6 :|length cubits |  |&"
            puts "&| $side7 :|front cubits |  |&"
            puts "&| $side8 :|depth cubits |  |&" 
            }
        frame .buttons -bg aquamarine4
        ::ttk::button .calculator -text "Solve" -command { calculate   }
        ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 1.0 0.666  0.833 1.   144.0  6. 4. 6.}
        ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 1.0 0.666  0.833 1.0  200.0  7. 4.6 6.8 }
        ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 1.0 0.666  0.833 1.0  300.0  8. 5.3 7.6 }
        ::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 Cubic Equation Algorithm 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 babylonian algorithm for roots.
                  # combined tablet formulas and Newton's method
                  # written on Windows XP on eTCL
                  # working under TCL version 8.5.6 and eTCL 1.0.1
                  # TCL WIKI , 12dec2016             
             console show
             package require math::numtheory
             namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
             set tcl_precision 17
         proc square_root_function { number_for_root  } {   
             set counter 0
             set epsilon .0001
             while { $counter < 50.  } {
             if { [* $counter $counter 1. ]   > [* $number_for_root 1.] } {break}            
             incr counter 
             }   
             set  square_root_estimate $counter
             while {1} {
             set keeper $square_root_estimate        
             set starter $square_root_estimate
             set remainder   [* $starter $starter  1. ]  
             set remainder [- $number_for_root [* $starter $starter  1. ] ]
             set  square_root_estimate  [+ $starter [/ $remainder [* 2. $starter ]]]
             if {abs($keeper - $square_root_estimate) < $epsilon} break
                   }
             return $square_root_estimate
                }
             puts " square root of 2 is >>  [square_root_function 2 ] "