(n*(n+1))/2
  (12*(12+1))/2
  12 11 10 9 8 7 6 5 4 3 2 1
  [add 12 11 10 9 8 7 6 5 4 3 2 1 ] # answer 78

   # following statements can be pasted into eTCL console
   proc add {args} {return [ ::tcl::mathop::+ 0. {*}$args]} #
   add 1 2 4 8 16 32 64 128  # answer 255
   add 1 2 4 8 16 32 64 128 256 512 1024 2048  # answer  4095.0
   add 1 2 4 8    # answer  15.0
   add 1 4 9 16   # answer  30.0
   set babylonian_sequence [ add 1 4 9 16 25 36 49 64 81 100 ] #  answer 385.0
   set babylonian_problem_formula [expr (1./3. + 2./3.*10.)* 55 ] # answer 384.9999 ~~> 385.
   set babylonian_follow_on [expr (1./3.+(2./3.)*4.)*10. ] # answer 30.0
   set archimedes_follow_on  [expr 1./1. + 1./4. + 1./16.+ 1./64. + 1./256.+ 1./125.+ 1./1024. + 1./4096.+1/16384.+1./65536. ] # answer 1.3413 
   set harmonic_eval_10_terms  [expr 1./1. + 1./2.+ 1./3.  + 1./4. + 1./5.+ 1./6.+ 1./7. + 1./8.+ 1./9.+ 1./10.] # 2.928
   set alternating_harmonic_eval_10_terms  [expr 1./1. - 1./2. + 1./3. - 1./4. + 1./5.- 1./6.+ 1./7. - 1./8.+ 1./9.- 1./10.]  # 0.645, 
   set euler_series_10_terms [expr 1./1. + 1./2. + 1./9. + 1./16. + 1./25. + 1./32.+ 1./64.+ 1./49. + 1./81.+ 1./100.] # answer 1.8032

   proc add {args} {return [ ::tcl::mathop::+ 0. {*}$args]} #
   add 1 2 4 8 16 32 64 128  # answer 255
   add 1 2 4 8 16 32 64 128 256 512 1024 2048  # answer  4095.0
   add 1 2 4 8    # answer  15.0
   add 1 4 9 16   # answer  30.0
   set babylonian_sequence [ add 1 4 9 16 25 36 49 64 81 100 ] #  answer 385.0
   set babylonian_problem_formula [expr (1./3. + 2./3.*10.)* 55 ] # answer 384.9999 ~~> 385.
   set babylonian_follow_on [expr (1./3.+(2./3.)*4.)*10. ] # answer 30.0

   set archimedes_follow_on  [expr 1./1. + 1./4. + 1./16.+ 1./64. + 1./256.+ 1./125.+ 1./1024. + 1./4096.+1/16384.+1./65536. ] # answer 1.3413 
   set harmonic_eval_10_terms  [expr 1./1. + 1./2.+ 1./3.  + 1./4. + 1./5.+ 1./6.+ 1./7. + 1./8.+ 1./9.+ 1./10.] # 2.928
   set alternating_harmonic_eval_10_terms  [expr 1./1. - 1./2. + 1./3. - 1./4. + 1./5.- 1./6.+ 1./7. - 1./8.+ 1./9.- 1./10.]  # 0.645, 
   set euler_series_10_terms [expr 1./1. + 1./2. + 1./9. + 1./16. + 1./25. + 1./32.+ 1./64.+ 1./49. + 1./81.+ 1./100.] # answer 1.8032

  set sqrt_error [* 100. [- 1. [/ 3.1666666666666665 3.1622776601683795]] ]  # 0.3879257199 percent error
  set cubert_error [* 100. [- 1. [/ 2.3333333333333335 2.154434690031884]]]  # 8.30 percent error
  # program finds highest square below rational number, for initial guess of square root
  proc list2 { aa bb} { for {set i 1} {[* [+ $i 1] [+ $i 1]  ]<=[- $bb 1]} {incr i} {set j 1 };return $i}
  list2 1 100    #answer 9  ,  9*9 = 81 < 100
  # program finds highest cube below rational number, for initial guess of cube root
  proc list3 { aa bb} { for {set i 1} {[* [+ $i 1] [+ $i 1]  [+ $i 1] ]<=[- $bb 1]} {incr i} {set j 1 };return $i}
  [list3 1 100]    #answer 4  ,   4*4*4=64 < 100
  # list squares 
  proc listsq { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend booboo [ * $i  $i 1. ] };return $booboo}
  [listsq 1 5]
  #answer 1.0 4.0 9.0 16.0 25.0
  proc listnumbers { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend booboo [ expr 1.* $i] };return $booboo}
  #returns list of integer numbers from aa to bb as reals with decimals, usage listnumbers 1 5
  [listnumbers 1 5] 
  # answer is 1.0 2.0 3.0 4.0 5.0 
  proc sumsquares5 x {expr {$x<2? 1: $x*$x+[sumsquares5 [incr x -1]]}}
  # usage sumsquares5 2 # answer 5
  proc sum_ladder x {expr {$x<1? 1: 2**$x+[sum_ladder [incr x -1]]}}
  # usage sum_ladder 2  # answer 7 = 2**0+2**1+2**2

 # following statements can be pasted into eTCL console
 set project 1.0
 set sum_of_squares [ expr 1*1+2*2+3*3+4*4+5*5+6*6+7*7+8*8+9*9+10*10 ] # answer 385
 set sum_of_squares [ expr 5*5+6*6+7*7+8*8+9*9+10*10 ] # answer 355
 set sum_of_squares [ expr 2*2+3*3+4*4+5*5 ]   # answer 54
 set sum_of_squares [ expr 1*1+2*2+3*3+4*4+5*5+6*6+7*7+8*8+9*9+10*10+11*11+12*12+13*13+14*14+15*15 ] # answer 1240
 set sum_of_2_powers [ expr 1**1+2**2+3**2+4**2+5**2+6**2+7**2+8**2+9**2+10**2]   

        # pretty print from autoindent and ased editor
        # Babylonian Number Series calculator
        # written on Windows XP on eTCL
        # working under TCL version 8.5.6 and eTCL 1.0.1
        # gold on TCL WIKI, 15dec2016
        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 {{} {start :} }
        lappend names {end :}
        lappend names {optional : }
        lappend names {optional : }
        lappend names {answers: initial term :}
        lappend names {final term: }
        lappend names {sum: }
        lappend names {sum:} 
        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 Number Series 
            from TCL WIKI,
            written on eTCL "
            tk_messageBox -title "About" -message $msg } 
             proc sum_function { start end } { 
             global side1 side2 side3 side4 side5
             global side6 side7 side8   
             set sum 0
             set counter 1
             set start [int $start ]
             set counter [int $start ]
             set end [int $end ]
             while { $counter < 1E6  } {
             set sum [+ $sum [* $counter $counter ]]
             if { $counter   < $start } {set side5 [* $counter $counter ] } 
             set side6 [* $counter $counter ]
             if { $counter   > [- $end 1. ] } { break}              
             incr counter 
             }
             return $sum  }  
       proc calculate {     } {
            global answer2
            global side1 side2 side3 side4 side5
            global side6 side7 side8 
            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. ]
            set start $side1  
            set end $side2 
            set sum_of_squares [sum_function $start $end ]
            set side7 $sum_of_squares
            set side8 $sum_of_squares
                    }
        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 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 :|start|   |&"
            puts "&| $side2 :|end   | |& "  
            puts "&| $side3 :|optional | |& "
            puts "&| $side4 :|optional | |&"
            puts "&| $side5 :|answers: initial term | |&"
            puts "&| $side6 :|final term   |  |&"
            puts "&| $side7 :|sum  |  |&"
            puts "&| $side8 :|sum |  |&"                     
            }
        frame .buttons -bg aquamarine4
        ::ttk::button .calculator -text "Solve" -command { calculate   }
        ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 0.0 10.  1.0 1.0  0.0  100. 385 385}
        ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 2.0 5.0 1.0 1.0  1.0  25. 55. 55. }
        ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 0.0 15. 1.0 1.0  1.0   225 1240 1240 }
        ::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 Number Series Calculator"      

                  # autoindent from ased editor
                  # console program for babylonian algorithm for roots.
                  # follows tablet formulas but not very accurate  
                  # 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 {math::numtheory}
             namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
             set tcl_precision 17
         proc square_root_function { number_for_root  } {   
             set counter 0
             while { $counter < 50.  } {
             if { [* $counter $counter 1. ]   > [* $number_for_root 1.] } {break}            
             incr counter 
             }      
             set starter [- $counter 1  ]
             set remainder   [* $starter $starter 1. ]  
             set remainder [- $number_for_root [* $starter $starter 1. ] ]
             set  square_root_estimate  [+ $starter [/ $remainder [* 2. $starter ]]]
              }  
         proc cube_root_function { number_for_root  } {   
             set counter 0
             while { $counter < 50.  } {
             if { [* $counter $counter $counter  1. ]   > [* $number_for_root 1.] } {break}            
             incr counter 
                     }      
             set starter [- $counter 1  ]
             set remainder   [* $starter $starter $starter 1. ]  
             set remainder [- $number_for_root [* $starter $starter $starter 1. ] ]
             set  square_root_estimate  [+ $starter [/ $remainder [* 3. $starter ]]]
              }  
             puts " [square_root_function 10 ] "
             puts " [cube_root_function 10 ] "

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

    # pseudocode for interest rate problem
    pay_back / (capital+rate annual)= debt ratio 
    debt ratio = (capital+rate)**years
    debt ratio =    4/3  ** years
    7.5= (4/3)**7
    debt ratio = (1+18/60)**years
    debt ratio = (1+n · n · (n – 1)/60 )**years , where n evaled at 3
    debt ratio = [expr (1.+(18./60.))**3]=2.1, amount doubles in ~2 years
    table lookup vs   modern formula A=P*((1+i)**n) 
    maybe the some extant tables are interest rate tables, but not recognised.
    possible format for tablet thinking for sum of integers
    sum (1 ,2,3 ...  10) = (1/2) * 10 * (10 + 1)  
    set sum_of_integers [expr (1./2.) * 10. * (10. + 1.)  ] #  answer 55
    A =  P + I
    A = (1+12/60)  +   I
    A = (1+12/60) +18/60  = 1+30/60