#   procs below should should be pastable into TCL Console
     proc pi {} {expr acos(-1)} #   AMG
     time {pi} 5000             #   returns 0.6178 microseconds per iteration
     proc pie {} {acos -1 }     #   braces may take place of expr expression
     time { pie } 5000          #   0.5982  microseconds per iteration
     proc pies {} [acos -1  ]   #   dropping expr expression in math ops; math op slightly improved time
     time { pies } 5000         #   returns 0.5846 microseconds per iteration
     #   use args for list of multiple inputs & return list of list of counts and values
     proc multiple_pies {args} { foreach i $args {lappend res " count [incr $i ] for [acos $i] "}}
     #   Usage multiple_pies -1 -1 -1 -1 -1 -1 -1 -1 -1 #   returns list of counts and values
     time {multiple_pies -1 -1 -1} 3 #   returns 2509 microseconds per iteration & list of counts & values
     #   sample multiple_pies printout  => \n count 1 for 3.14 \n count 2 for 3.14 \n count 3 for 3.14 
     proc pq {} {set temp [ expr { acos(-1)} ] ; return $temp }        #   temporary variables not recommended
     time {pq} 5000  #   returns  0.6338 microseconds per iteration     #   temporary variables usually slow results
     proc add {args} {return [ ::tcl::mathop::+ 0. {*}$args]}          #   using math ops and $args
     #   Usage add 1 2 3 4 5 6 7 8 9  returns 45
     #   suggest maintain dead spaces and air gaps near expr, brackets, etc in following statements
     #   example one liners program uses internal conditional in the expr command
     proc errorx  {aa bb} {expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*100. : (($bb*1.)/$aa -1.)*100.}}
     #   Usage errorx 3.1 3.14 returns error 1.2903 in positive percent
     #   variable naming conventions
     set adjacent_side_aa 3.
     set opposite_side_bb 4.
     set hypotenuse_side_cc "unk"
     proc Pythagorean_formula {adjacent_side_aa opposite_side_bb } { expr { sqrt ($adjacent_side_aa**2 + $opposite_side_bb**2)}}
     set hypotenuse_side_cc [ Pythagorean_formula 3 4 ] #   returns 5
     #   begin RS code in One liners program for basic style let in one line
     proc let2 {_var expr} {upvar 1 $_var var;set var [uplevel 1 [list expr $expr]] } #   RS
     #   Usage let2 a {999999} ; puts $a #   returns 999999
     #   Usage  let2 bombs without  braces or brackets  on widely spaced math expression
     #   Usage let2 a  4   *    9999     +       77777.  #   returns error should be "let2 _var expr"
     #   subbed  $args into expr variable and bb as assignment symbol
     #   _var is assigned variable and args expression follows assignment operator ==
     #   $args in let3 can handle a widely spaced list <expression>  unlike let2
     #   let3 working previously, but having troubles and sometimes buggy now
     proc let3 {_var bb args} {upvar 1 $_var var;set var [uplevel 1 [list expr $args]] }  #   $args in RS derived
     #   Usage let3 a == [ expr 4   *    9999     +       77777.      ] ; puts $a           #   returns 117773.0
     #   Usage let3 a ==  4   *    9999     +       77777.  ; puts $a                       #   returns 117773.0

       #   using pseudocode 
       #   collect possible problem instances 
       #   collect testcases over range of operation 
       #   time averaging, weighted, random or linear piece wise solution
       #   can produce surprising and robust results
       #   possible modeling a 3ird or Nth order solution to 
       #   2nd order over expected range of operation
       #   possible normalize some parameters to 1
      initialize algorithm_result = 1.
      #   desired_goal usually 1 unit or 100 square units in some early math problems
      set false1 [expr $guess * 3/5]
      set false2 [expr $guess * 4/5]
      calculate f(false1) and f(false2)
      solution band between false1 lower limit
      and false2 upper limit
      #   recommended, avoid division or division by zero in one liners
      center of solution band < f(false1) & f(false2) > * .5
      double false position solution dfps
      error1 = product -f1
      error2 = product -f2
      [expr (e2*f1-e1*f2)/(e2-e1)]
      check algorithm 
      f(solution) =? initial product solution
      check error , abs (desired_goal -  current value) <=? $required_accuracy 
      check_sum = a+b+c+d+e = total of shares = original real estate = normalized 1
      check_answer   new answer =? desired goal , desired goal reached (yes/no)
      yes = finished loop
      set answers and printout with resulting values 
      pseudocode: need test cases > small,medium, giant 
      pseudocode: need testcases within range of expected operation.
      pseudocode: are there any cases too small or large to be solved?

              #   procs below should should be pastable into TCL Console
              #   returns logical on find element in list
              #   1 or 0 for yes or no, using lsearch command
              #   Suggest maintain dead space and air gap around expr, brackets, etc
              proc find_in_list  {lister element} {expr {[lsearch -exact $lister $element] >= 0}} #   Wiki Books TCLP
              time {find_in_list {11 22 33} 22} 5000                          #    results in 0.6286 microseconds per iteration
              #   using lsearch cmd in precompiled code from TCL core
              time {lsearch -exact {11 22 33} 22} 5000                        #    results in 0.2764 microseconds per iteration
              #   precompiled TCL code from TCL core & TCLLIB
              #   precompiled TCL core saves computation time about 60 percent here
              #   over one liners program
              #   following list2 proc equivalent to list command
              proc list2 args {set args}  #   Wiki Books TCLP
              time { list2 TCL must avoid unbalanced quotes or braces } 5000   #   results in 0.4576 microseconds per iteration
              #   using list cmd in precompiled code from TCL core 
              time { list  TCl must avoid unbalanced quotes or braces } 5000   #    results in 0.0986 microseconds per iteration
              #   precompiled TCL core saves computation time about 80 percent here
              #   from one liners program

    #   random integer in the range  zero to $nn 
    #   one liner uses the expr calculation method
    proc  random_number_less_than nn { expr { int($nn * rand())}}
    #   Usage  random_number_less_than 10
    #   may return 3, 8, 9  or other random number

        #  Random Dice & alternate procedures, checking math and format here
        # Original base expression is expr {1 + int(rand()*6)}    RLE
        # check parens? weak eyes here. 
        proc dice_sides_N    { dice_sides } { expr { 1 + int(rand()*$dice_sides)} }  
        proc dice_sides_N    { dice_sides } { expr { 1 + int(rand()*$dice_sides)} }
        # Computes optimum for Dragon Counting Game  from James Munro,  Oxford mathematician  
        proc optimum_N    { dice_sides } { expr { int(1.718281828 *$dice_sides) }} 
        # Alternate gimmick and fudge constant under test
        proc optimum_G    { dice_sides } { expr { int(1.6180339887498948420  *$dice_sides) }} 
        # set g_constant .6180339887498948420
        #  golden ratio is 1.6180339887498948420 

    #   following one liners use math operator notation
    #   degrees Centigrade to degrees  Fahrenheit 
    proc  Fahrenheit cc {  [+ [* 1.8 $cc]  32. ]}
    #   Usage Fahrenheit 20 returns 68. degrees  Fahrenheit 
    #   degrees Fahrenheit to degrees  Centigrade 
    proc Centigrade ff  { [/ [-  $ff 32. ] 1.8 ]}
    #   Usage Centigrade 68 returns 20 degrees centigrade

     #   Reference Tcl 8.4 Built-In Commands - expr manual page
     #   random integer in the range 0. zero to $nn 
     proc  random_number_less_than nn { expr { int($nn * rand()) } }
     #   Usage  random_number_less_than 10
     #   may return 3 or other random number
     #   random_number_less_than 0 returns 0
     #   random_number_less_than 1 returns 0, on clipping $nn
     #   Reference Tcl 8.4 Built-In Commands - expr manual page
     #   convert cartesian coordinates into polar coordinates:
     #   convert from ($x,$y)
     proc radius {y x} { expr { hypot($y, $x) } }
     proc angle  {y x} { expr { atan2($y, $x) } }
     #   Usage radius 1 1 returns 1.414 or square root 2
     #   Usage angle 1 1  returns 0.785
     #   Reference Tcl 8.4 Built-In Commands - while manual page
     proc print_out nn {set x 0; while {$x<$nn} { puts " number $x"; incr x}} 
     #   Usage print_out 2 returns number 0, number 1
     #   Reference Tcl 8.4 Built-In Commands - foreach manual page
     proc list_numbers {} { set lister {}; foreach {i j} {1 2 3 4 5} { lappend lister $j $i}; return $lister}
     #   list_numbers returns 2 1 4 3 {} 5
     #   Tk8.6.10 Documentation > Tcl Commands > for
     #; www.tcl-lang.org/man/tcl8.6/TclCmd/for
     proc powers_of_two nn { for {set x 1} {$x<=$nn} {set x [expr {$x * 2}]} { puts "x is $x"}}
     #   Usage powers_of_two 2 returns x is 1; x is 2
     #   Usage powers_of_two 1024 returns x is 1; x is 2;..... x is 1024
     #   following use math ops

    #   compute the doubling time constant in years for money
    #    using interest rate in percent for exact constant 
    proc rule_72_constant {percent } {  expr { log( 2. )/ log (1. + $percent/100.)} }  
    #   Usage rule_72_constant 10  returns 7.27253 years,
    #   7.27253  years to double money at 10 percent interest
    #   setting the doubling constant at 10* 7.27253 percent rounds to 72.
    proc approximate_doubling_time {percent} { expr { 72. / $percent}}
    #   example 1, { expr {72./10 }}   approximates 7.2 years
    #   example 2, { expr {72./4 }}  approximates 18 years 
    #   money at 4 percent doubles about 18 years

    #   These statements should be pastable into the easy eye console.
    #   *****  simple interest problems in TCL one liners procedures  *****
    #   find simple interest amount from 3 entries as < principal  interest  years >
    proc simple_interest_amount   { principal interest  years } { expr {  ($principal*1.)*(1.+$years*$interest )}}
    #   Usage simple_interest_amount  5000. .05 7. returns 6750.0
    #   find simple interest principal  from 3 entries as < amount  interest  years >
    proc simple_interest_principal { amount  interest  years } { expr {  ($amount*1.)/(1.+$years*$interest )}}
    #   Usage simple_interest_principal 6750.0 .05 7. returns 5000.0
    #   find simple interest rate from 3 entries as < amount  principal  years >
    proc simple_interest_rate { amount  principal  years } { expr { ((($amount*1.)/$principal)-1.)/$years }}
    #   Usage  simple_interest_rate 6750.0 5000. 7.   returns 0.05
    #   find years of  simple interest from 3 entries as < amount  principal  interest >
    proc simple_interest_years { amount  principal  interest } { expr { ((($amount*1.)/$principal)-1.)/$interest }}
    #   Usage simple_interest_years 6750.0 5000. .05  returns 7.0
    #   ******  compound  interest problems in TCL one liners procedures ******
    #   find compound interest amount from 4 entries as < principal  interest  years compounding_times_per_year >
    #   cd is compounding times per year, usually 4 quarters or 12 months
    proc compound_interest_amount   { principal interest  years cd } { expr {  ($principal*1.)*((1.+( $interest /$cd))**($years*$cd))}}
    #   Usage compound_interest_amount 5000 .05 7 12 retuRns 7090.180
    #   find compound interest principal from 4 entries as < amount  interest  years cd >
    #   cd is compounding times per year, usually 4 quarters or 12 months
    proc compound_interest_principal { amount  interest  years cd  } { expr { $amount*( 1. +(($interest*1.)/$cd ) )**(-1.*$cd*$years)}}
    #   Usage compound_interest_principal 7090.180 0.05 7 12 returns  4999.997, rounds to 5000.
    #   find interest in compound interest from 4 entries as < amount  principal  years cd >
    #   cd is compounding times per year, usually 4 quarters or 12 months 
    proc compound_interest_interest { amount principal  years cd } { expr { $cd*((($amount*1.0)/$principal)**(1./($cd*$years))-1.)}}
    #   Usage compound_interest_interest 7090.180 5000. 7 12 returns 0.049, rounds to 0.05
    #   find years of  compound  interest from 4 entries as < amount  principal  interest  cd>
    proc compound_interest_years { amount principal interest cd  } { expr { (log10 (($amount*1.0)/$principal)) / ($cd*log10(1.+(($interest*1.)/$cd) ) ) }}
    #   Usage compound_interest_years 7090.180 5000. 0.05 12 returns 6.99, rounds to 7 years
    #   ******** continuous_compounding *******  based on exponential formulas and natural log.
    proc amount_continuous_compounding { principal interest years } { expr { $principal* exp ( $interest*$years*1. ) }}
    #   Usage  amount_continuous_compounding  5000. 0.05 7  returns 7095.3377 
    proc principal_continuous_compounding { amount interest years } { expr { $amount * exp ( $interest*$years* -1.  ) }}
    #   Usage  principal_continuous_compounding 7095.33 0.05 7. returns 4999.994, rounds to 5000.
    proc interest_continuous_compounding { amount principal years } { expr { (log ( ($amount*1.) /$principal  )) / ($years * log (exp(1.) ) )  }}
    #   Usage  interest_continuous_compounding 7095.33 5000. 7 returns 0.04999, rounds to 0.05
    proc years_continuous_compounding { amount principal interest } { expr { (log ( ($amount*1.) /$principal  )) / ($interest * log (exp(1.) ) )  }}
    #   Usage  years_continuous_compounding 7095.33 5000. 0.05 returns 6.999, rounds to 7 years
    proc  eckart–mchale_69p3 {rate} { return [expr {(69.3/$rate) * (200./(200.-$rate))} ] }
    #   2nd order  eckart–mchale, 20 percent interest rate doubles money in how many years?
    #   Usage  eckart–mchale_69p3 20.0 #   returns 3.85
    #   2nd order solution, should be not that far from exact 3.802.
    proc pade_rule_69.3 { rate } { return [ (69.3/$rate) * (600.+4.* $rate)/(600.+$rate) ] }
    #   pade_rule 20 percent interest rate doubles money in how many years?
    #   Usage   pade_rule_69p3  20.0 #   returns 3.8 
    #   3ird order solution, should be not that far from exact 3.802 
    #   following exact doubling rule etc in TCL using natural logarithms.
    #   Denominator term < log (1.+ $rate/100.)> represents Principle and Interest P&I
    #   Manipulating log term in nominator, log (2) for doubling,
    #   and log (3) for tripling, log (1.5) for 50% (factor >.5<) rise.
    #   extensions log (5)  for 5X, log (10)  for 10X, log (16)  for 16X, etc.
    proc exact_doubling_rule { rate } { return [ expr { log (2.) /  log (1.+ $rate/100.)}] }
    #   what is computation times (years here), 
    #   to double amount at interest rate of 20 percent
    #   Usage <exact_doubling_rule 20. > returns 3.8017 years
    proc exact_tripling_rule { rate } { return [ expr { log (3.) /  log (1.+ $rate/100.)}] }
    #   what is computation times (years here), 
    #   to triple amount at interest rate of 20 percent
    #   Usage <exact_tripling_rule  20 > #   returns 6.0256 years
    proc exact_rise_rule { rate } { return [ expr { log (1.5) /  log (1.+ $rate/100.)}] }
    #   what is computation times (years here), 
    #   to rise amount 50 percent (>.5< factor below) 
    #   at interest rate of 20 percent
    #   Usage <exact_rise_rule 20. > #   returns 2.2239 years

   proc plainsub {text item replacewith} { set text [string map [list $item $replacewith] $text]} #   RS derived
   #   Usage plainsub {The quick brown fox jumped over the fences.} fox cat
   #   returns The quick brown cat jumped over the fences.
   #   Usage plainsub {123456789} 3 * returns "12*456789"
   #   Usage plainsub  123456789  3 1 returns "121456789"
   proc commify number {regsub -all {\d(?=(\d{3})+($|\.))} $number {\0,}} #    Peter Spjuth 
   #   Usage commify {123456789}   returns 123,456,789
   #   begin RS code
   #   One liners program for
   #   basic style let in one line
   proc let {_var expr} {upvar 1 $_var var;set var [uplevel 1 [list expr $expr]] } #   RS
   #   Usage let a {999999} ; puts $a

proc Lister args {set args}

    #   conversion unit formulas in one line TCL procs
    #   HOMA-IR standing for Homeostatic Model Assessment of Insulin Resistance 
    #   HOMA_IR = expr { $insulin * $glucose * $scale_factor}
    #   fasting blood insulin in units  uIU/mL
    #   fasting blood glucose in units mg/dL
    proc HOMA_IR2 { insulin  glucose }  {
            set scale_factor [ expr { 1. / 405. } ]
            return [expr { $insulin * $glucose * $scale_factor}]}
    #   HOMA-IR calculations here requires U.S. standard units.
    #   European SI units as best understood. 
    #   To convert component terms of  HOMA-IR ( $insulin & $glucose)
    #   from international S.I. units:
    #   Insulin: pmol/L to uIU/mL, divide by (÷) 6
    #   Glucose: mmol/L to mg/dL, multiply by (x) 18
    #   hbA1c_convert_to_average_blood_glucose mg/dl  HbA1c
    #   HbA1c test is a simple blood test that measures your 
    #   average blood sugar levels over the past 3 months.
    #   As a peg point, 5 HbA1c units converts to 100 mg/dl,
    #   mg/dl is abbreviation for milligrams per deciliter.
    proc a1c hbA1c {  expr { 35.6*$hbA1c -77.3} }
    #   convert mg/dl to mmol/L average blood glucose
    #    European SI units conversion on blood glucose
    #   some papers round off 18.016 to mgdl/18.
    proc mgdl_to_mmoll mgdl {  expr { $mgdl/18.0 } }
    #   convert  mmol/L to mg/dl average blood glucose
    proc mmoll_to_mgdl mmoll {  expr { $mmoll*18.0 } }
    #   formula QUICKI_index insulin resistance = 1/(log(insulin) + log(glucose)), decimal logs 
    proc QUICKI_INDEX_IR { insulin  glucose } { return [ expr { 1./(log10($insulin) + log10($glucose))} ] }
    #   Usage set answer [  QUICKI_INDEX_IR 4. 100. ] #   eval 0.38

   #   conversion unit formulas in one line TCL procs
   #   body mass index in metric units, persons weight in kilograms, height in meters
   proc  body_mass_index_BMI { weight  height } { return [ expr { (1.* $weight ) / ( $height * $height)} ] }
   #   metric testcase, weight is  64 kg and height is  1.9 meters tall. 
   set answer [  body_mass_index_BMI 64. 1.9 ] #; evals to 17.728,  rounds to BMI of 17.7
   #   formula in English units, BMI = ( 703. X weight_in_pounds ) / ( height_in_inches * height_in_inches )
   proc  body_mass_index_BMI_lbs { weight  height } { return [ expr { (703.*  $weight) / ( $height * $height ) } ] }
   #   testcase 58 inches , 100 pounds, BNI = 21., proc returns 20.897, rounds to 21.
   set answer [ body_mass_index_BMI_lbs 100. 58. ]

   #   total daily calories from carbohydrates, proteins, and fats, all entries in grams
   #   Carbs provide 4 calories per gram, 
   #   protein provides 4 calories per gram, and fat provides 9 calories per gram.
   proc  total_daily_calories { carbs proteins fats } { return [ expr {  4. * $carbs + 4. * $proteins + 9. * $fats } ] }
   #   testcase from daily keto diet, 20 grams carbs, 80 grams protein, and 150 grams fats and oils 
   #   Usage, 
   set carbs 20. ; set proteins 80. ; set fats 150.
   set answer [ total_daily_calories $carbs $proteins $fats ]  #   returns 1750 calories 

        # proc precisionx used to round off floating point numbers
        set precision 5.
        set float      3.000000000001
        set test_float_2 3.999999999997
        set x [ expr {round( 10 ** $precision * $float) / (10.0 ** $precision)} ]  #   <AM>
        proc rnd_floating_pt {precision float} { expr {round( 10 ** $precision * $float) / (10.0 ** $precision)}}  #   <AM>
        set float $test_float_2
        proc precisionx {precision float }  {
            #  tcl:wiki:Floating-point formatting, <AM>
            # select numbers only, not used on every number.
            set x [ expr {round( 10 ** $precision * $float) / (10.0 ** $precision)} ]
            #  rounded or clipped to nearest 5ird significant figure
            set x [ format "%#.5g" $x ]
            return $x
        }

#  list of TCLLIB rounding commands
::math::decimal::round_half_even decimal digits
::math::decimal::round_half_up decimal digits
::math::decimal::round_half_down decimal digits
::math::decimal::round_down decimal digits
::math::decimal::round_up decimal digits
::math::decimal::round_floor decimal digits
::math::decimal::round_ceiling decimal digits
::math::decimal::round_05up decimal digits

        #under test from www.codecodex.com/wiki
        set lister { 1 2 4 5 6 7 8 9 10 }
        set s {starchild}
        package require struct::list
        proc reverseWords s {return [struct::list reverse [split $s]]}
        proc ! n {expr {$n<2? 1: $n*[! [incr n -1]]}}
        #   Usage    ! 5  returns 120
        #   Suggest maintain dead space and air gap around expr, brackets, etc
        proc average list {expr ([join $list +])/[llength $list].}
        for {set i 1} {$i <= 1000} {incr i} {pust [expr {$i*($i+1)/2}]}
        namespace import ::tcl::mathop::*
        proc average list {expr {[+ {*}$list]/double([llength $list])}}
        #   works here , average $lister returns 5.777777777777778
        proc fib n {expr {$n<2? $n: [fib [incr n -1]] + [fib [incr n -1]]}}
        #   not working here 
        namespace import ::tcl::mathfunc::*
        ::tcl::mathfunc::isqrt 25
        #   ::tcl::mathfunc::isqrt 25  returns 5, working here        
        set date [clock format [clock scan $date] -format {%Y-%m-%d %H:%M:%S}] # dclaar 
        scriptEval clock format [clock scan $tDate] -format {%Y-%m-%d %H:%M:%S} # dclaar 
        #   clock scan is your friend; it knows all sorts of formats. In 
        #   case above, it converts: Oct 15 06:52:45 2009 to: 2009-10-15 06:52:45

        #   pretty print from autoindent and ased editor
        #   list_twin_primes V2
        #   written on Windows 10 on TCL
        #   working under TCL version 8.6
        #   gold on TCL Club , 8/20/2020
        #   Ref. WIKI BOOKS, Tcl_Programming_Introduction
        #   Book Section  contrasts one liners
        #   versus  traditional procedural  approach
        #   below contains redundant procs
        package require Tk
        package require math::numtheory
        package require math::constants
        package require math::trig
        package require math
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory math::trig math::constants }
        set tcl_precision 17
        proc pie {} {return [expr acos(-1)]}
        console show
        console eval {.console config -bg palegreen}
        console eval {.console config -font {fixed 20 bold}}
        console eval {wm geometry . 40x20}
        # invoking TCLLIB math::numtheory
        proc isprimex x {expr {$x>1 && ![regexp {^(oo+?)\1+$} [string repeat o $x]]}}
        # list_twin_primes proc  under test, list_twin_primes and isprime procs are recursion limited
        proc list_twin_primesx { aa bb cc} { for {set i $aa} {$i<=$bb} {incr i $cc} { if {[isprime $i] && [isprime [+ $i $cc ]] } {lappend  boo  $i [+ $i $cc ]  } } ; return $boo}
        proc list_twin_primes { aa bb cc} { for {set i $aa} {$i<=$bb} {incr i 1} { if {[isprime $i] && [isprime [+ $i $cc ] ] } {  lappend  boo  $i  [+ $i $cc ]   } } ; return $boo}
        #   aa is start number, bb is upper limit, cc is separator number, usually even 2
        #   The original Dickson conjecture has separator even numbers 2,4,6 ... ?
        #   list_twin_primes 0 25 2 returns 3 5 5 7 11 13 17 19
        #   The sets <13 15> and <15 17> are separated by a even 2,
        #   but left out of answer.
        #   Note the 15 is not a prime number and has factors <3 5>.
        #   The set <13 17> has two primes, but separated by an even 4.
        #   reference On-Line Encyclopedia of Integer Sequences website
        #   OEIS A077800 discussed that the twin prime sets <p,p+2> are
        #   (3, 5), (5, 7), (11, 13), (17, 19),
        #   (29, 31), (41, 43), (59, 61), (71, 73),
        #   (101, 103), (107, 109), (137, 139)...
        #   OEIS A275021 has  samples of <p,p+4> and omits pairs of <p,p+2>
        #   79, 83, 127, 131, 163, 167, 379, 383, 397, 401, 439, 443,...
        #   list_twin_primes 75 135 4 returns 79 83 103 107 127 131
        #   reference On-Line Encyclopedia of Integer Sequences website
        #   OEIS A023201 has some samples of <p,p+6> 
        #   5, 7, 11, 13, 17, 23, 31, 37, 
        #   41, 47, 53, 61, 67, 73, 83, 97, 101
        #   contains redundant procs for testing
        puts "[list_twin_primes 3 25 2 ]"
        puts "[list_twin_primes 3 25 4 ]"
        puts "[list_twin_primes 3 25 6 ]"

  listPrimePairs 
  listPrimeProgressions

        set  strinit “123456789”
        proc string_end strin5 { string index $strin5 end}
        string_end $strinit
        #   out  9
        proc sea5 bb { set i 2;if {$i < 10} { while {$i < 5} { puts [incr i]}}}
        sea 5
        #   return first character of string
        proc string_end5 bb  { string index $bb 0 }
        #   return last character of string
        proc string_end5 bb  { string index $bb end }
        #   Enter number num for next above power of 2, John K. Ousterhout, Tcl and the Tk Toolkit
        proc near_above_power_of_2  num {set pow 1; while {$pow<$num} {set pow [expr { $pow*2} ]}; return $pow}
        #   Usage  near_above_power_of_2 7 returns 8,
        #   Usage  near_above_power_of_2 9 returns 16,
        #   Usage near_above_power_of_2 99999999999999 140737488355328
        #   Enter number num for next below power of 2, John K. Ousterhout, Tcl and the Tk Toolkit
        proc near_below_power_of_2  num {set pow 1; while {$pow< [expr {$num - 1}] } {set pow [expr { $pow*2} ]}; return [expr { $pow*.5} ]}
        #   Usage  near_below_power_of_2  7 returns 4.        

  console show
  proc pie {} {expr acos(-1)} #   AMG
  proc writer {args } { puts $args }
  proc call {args} {uplevel catch [list $args]}
  call writer "jack" "&" "jill"
  call writer jack & jill went up the hill with [pie]

   console show
   proc pi {} {expr {acos(-1)}} #   AMG 
   #   proc pi from AMG see below
   proc degtoradiansconst {} { expr {180./ [pi] }}
   proc degz {} { expr {180./ [pi] }}
   proc degx {aa} { expr { degz *acos($aa)}}
   proc inrad {a b c} { expr {(sqrt(($a+$b+$c)*($a+$b-$c)*($a-$b+$c)*($b+$c-$a)))/(2.*($a+$b+$c))}}
   proc circlediameter {radius} { expr { 2.* $radius }}
   proc circlearea {radius} { expr { [pi] *($radius**2)}}
   proc circlecircumference   {radius} { expr {2.* [pi]  *$radius }}
   proc spherediameter {radius} { expr { 2.* $radius }}
   proc spherevolume {radius} { expr { (4./3.)* [pi]  *($radius**3)}}
   proc spheresurface {radius} { expr { 4.* [pi]  *($radius**3)}}
   proc cubevolume {aa}  { expr { 1.*$aa*$aa*$aa }}
   proc squarearea  {aa}  { expr { 1.*$aa*$aa }}
   proc ellipsoidvolume {aa bb cc} { expr { 1.*(4./3.)* [pi] *$aa*$bb*$cc }}
   proc ellipsearea1 { aa bb } { expr { 1.* [pi]  *$aa*$bb  }}
   proc ellipseperimeterx {aa bb} { set tt [ expr { ($aa*$aa+$bb*$bb)/2.}];return [ expr { 2.*[pi]*sqrt($tt)} ] }
   proc spherevolumex {aa } { expr { 1.*(4./3.)* [pi]  *$aa*$aa*$aa }}
   proc spheroidvolumex {aa cc } { expr { 1.*(4./3.)* [pi]  *$aa*$aa*$cc }}
   proc torusvolumex {aa bb } { expr {(1./4.) * [pi] * [pi] * ($aa + $bb) * ($aa - $bb)*2.}}
   proc torussurfacex {aa bb } { expr { [pi] * [pi] * ($aa*$aa - $bb*$bb)}} 
   proc conesurfacex {aa rr } { expr { [pi]  *$rr*$aa}}
   proc cylindersurfacesidex {aa rr } { expr {2.* [pi] *$rr*$aa}}   
   proc cylinderwholesurfacesidex {aa rr } { expr {2.* [pi] *$rr*$aa +2.* [pi]  *$rr*$rr}}   
   proc cylindervolumesidex {aa rr } { expr { [pi] *$rr*$rr*$aa}} 
   proc conevolumex {aa rr }  { expr { (1./3.)* [pi] *$rr*$rr*$aa}} 
   proc pyramidvolumex {aa bb cc } { expr {(1./3.)*$aa*$bb*$cc }} 
   proc rectangularprismvolumex {aa bb cc } { expr { $aa*$bb*$cc }} 
   proc triangularprismvolumex {aa bb cc } { expr { $aa*$bb*$cc*.5 }} 
   proc polygonperimeterx {aa bb } { expr { $aa*$bb}} 
   proc rectangleperimeterx {aa bb } { expr {2.*( $aa+$bb)}} 
   proc parallelogramperimeterx {aa bb } { expr {2.*( $aa+$bb)}} 
   proc triangleperimeterx {aa bb cc} { expr { $aa+$bb+$cc }} 
   proc triangletrapezoidx {aa bb cc} { expr { $aa*($bb+$cc)*(1./2.)}}
   #   law of cosines, aa bb cc are three sides of right triangle, here ordered 
   #   as aa small side , bb middle side, cc largest side.
   #   inrad is radius of cirle inscribed in right triangle,
   #   use sides as inrad aa bb cc 
   proc anglecosa  { aa bb cc } { expr {($bb*$bb+$cc*$cc-$aa*$aa)/(2.*$bb*$cc)}}
   proc anglecosb { aa bb cc } { expr {($cc*$cc+$aa*$aa-$bb*$bb)/(2.*$aa*$cc)}}
   proc anglecosc { aa bb cc } { expr {($aa*$aa+$bb*$bb-$cc*$cc)/(2.*$aa*$bb)}}
   #   with examples
   #   for radius of 1
   #   circlediameter 1 
   #   circlearea 1  
   #   circlecircumference 1  
   #   spherediameter 1   
   #   spherevolume 1 
   #   spheresurface 1 
   #   inrad 3 4 5 
   #   anglecosa 3 4 5 
   #   anglecosb 3 4 5  
   #   anglecosc 3 4 5
   #   following include redundant TCL one liner procedures for  sqrt of sum of squares
   #     sqrt of sum of squares and diagonal using expr 
   proc diagonal_1  {aa bb} { expr { sqrt($aa * $aa + $bb * $bb)}}
   #   Usage diagonal 1 1  s  1.4142135623730951
   #   diagonal using math ops
   proc diagonal_2 {aa bb} {[sqrt [+ [* $aa $aa]  [* $bb  $bb] ] ]}
   #   Usage  diagonal_2 1 1 returns 1.4142135623730951
   #   diagonal using math hypot function
   proc diagonal_3{aa bb} {[ hypot $aa $bb ]}
   #   Usage  diagonal_3 1 1 returns 1.4142135623730951
   #   time one liners, but sticking >> [ time { set qq  [ diagonal_1  1 1 ] }  ]
   proc diagonal_1x {aa bb} { [ time [sqrt [+ [* $aa $aa]  [* $bb  $bb] ] ]]}
   proc koch_snowflake_perimeter  { side1 iteration }  {return [ expr { 3.*$side1*((4./3.)**$iteration)}]  }  

    proc koch_snowflake_perimeter  { side1 iteration }  {return [ expr { 3.*$side1*((4./3.)**$iteration)}]  }
    #   Usage using set answer
    set answer3 [ koch_snowflake_perimeter 1. 5. ]
    proc area_eq_triangle { length } { return [ expr { ($length*$length*sqrt(3.))/4.} ] }
    #   area_eq_triangle has to be initial triangle of length XX, if not equilateral triangle of 1.
    #   Usage using set answer
    set area_eq_triangle [ area_eq_triangle 1. ]
    proc koch_snowflake_nth  { iteration area_eq_triangle } {return  [ expr { ($area_eq_triangle / 5.) * (8.-3.*(4./9.)**$iteration)}]}
    #   Usage using set answer
    set area_eq_triangle [ area_eq_triangle 2. ] #   answer = 1.7320508075688772
    set answer2  [ koch_snowflake_nth 1 $area_eq_triangle ] #   answer2 = 2.3094010767585034

  #   suggest maintain spaces near expr statement
  proc emmy  aa  {expr {rand()<.9? 1 : 0 }}
  proc emmy2 aa { if { [ expr { rand() } ] <= .90 } {return 1 }}
  if { [ expr { rand() } ] <= .90 } {set immigrantyear  1 }
  #   try if {    { rand() }  <= .90 } {set immigrantyear  1 } #; should work
  proc plaguex  aa  { expr {rand()<.15? 1 : 0 }}
  if { [ expr { rand() } ] <= .15 } {set plaguethisyear 1 }
  #   try  if { { rand() }  <= .15 } {set plaguethisyear 1 }  #; should work
  #   There is a 15 percent chance of plague this year
  #   with random casualities up to 10 percent of population.
  proc plaguelossx aa {expr {rand()<.15? int($aa*.1*rand()) : 0 }}
  proc ratx  aa  {expr {rand()<.41? 1 : 0 }}
  if { [ expr { rand() } ] <= .41 } {set ratinfestthisyear 1 }  
  #   try if { { rand() } <= .41 } {set ratinfestthisyear 1 }   #; should work
  set liters 1000.; set sumerians 2000.
  set ratliters  [ expr { $liters*.1*rand()   } ]
  set ratliters [ expr { int($ratliters) } ] 
  set sumeriansstarved [ expr { $sumerians*.02*rand()   } ]
  set sumeriansgain aa {expr {rand()<.15? $aa*.1*rand() : 0 }}
  set sumeriansgain   [ expr {  $sumerians  * .10 * rand() } ]  
  set sumeriansgain   [ expr {  int($sumeriansgain) } ] 
  set sumerians [ expr { $sumerians + $sumeriansgain   } ]

      #   logic tests for even,  odd, positive, negative,  conditions of positive  numbers
      #   uses logic inside expr , if positive return 1, if not positive return 0
      proc isPositive x {return [ expr {$x>0}]} #   Richard Suchenwirth RS idea  in Math Sugar
      #   uses logic inside expr, if negative return 1, if not negative return 0
      proc isNegative  x { return [ expr {$x<0}]} #   Richard Suchenwirth RS idea from wiki: Math Sugar
      #   idea by Michael Barth
      #   No error traps or safety nets here for negative and real numbers.
      #   conditional proc  IsOdd,  if N odd, return 1, if N not odd, return 0. 
      proc IsOdd { N }  { return [ expr {$N % 2} ] }
      #   Usage 
      IsOdd 5  #   returns 1 
      #   conditional proc IsEven,  if N even,  return 1. If N not even return 0.
      proc IsEven { N }  { return [ expr { ( $N + 1 ) % 2} ] }
      IsEven 4 #   returns 1 
      #   linear interpolation
      #   See better routines on high quality linear interpolation in  TCLLIB distribution.
      #   points (xx1,yy1) and (xx3,yy3) are picked from a line.
      #   An intermediate point is picked at xx2. Solution is for yy2. 
      proc interlinear {xx1 xx2 xx3 yy1 yy3} {  return [expr {((($xx2-$xx1)*($yy3-$yy1))/($xx3-$xx1))+ $yy1 }]}

    #     following one liners are decimal equivalent to some Babylonian tables
    #     possible cubic problem instances include separate tables for  cubes n*n*n and quasi_cubes
    #     quasi_cube n*n*(n-1), quasi_cube n*(n + 1)*(n + 2), quasi_cube  n*n*(n + 1), quasi_square n*(n+1)   
    #     list_integers is list of positive integers, 1 2 3 4 ... n
    proc list_integers { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  1.]};return $boo}  
    #   usage, list_integers 1 10
    #   1.0  1.0 2.0 2.0 3.0 3.0 4.0 4.0 5.0 5.0 6.0 6.0 7.0 7.0 8.0 8.0 9.0 9.0 10.0 10.0
    #    list_reciprocals is list of 1/1 +1/2 1/3 1/4 ... 1/n
    proc list_reciprocals { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [/  1. $i  ]};return $boo}
    #   usage, list_reciprocals 1 10    
    #   1.0 1.0 2.0 0.5 3.0 0.333 4.0 0.25 5.0 0.2 6.0 0.166 7.0 0.142 8.0 0.125 9.0 0.11 10.0 0.1
    #   list_squares is list of integer squares, 
    proc list_squares { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  $i  ]};return $boo}
    #   usage, list_squares 1 10  
    #   1.0 1 2.0 4 3.0 9 4.0 16 5.0 25 6.0 36 7.0 49 8.0 64 9.0 81 10.0 100
    #   quasi_cube2 is n*(n)*(n-1)
    proc list_quasi_cube2 { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  $i [- $i 1]]};return $boo}
    #   usage, list_quasi_cube2  1 10   
    #   1.0 0 2.0 4 3.0 18 4.0 48 5.0 100 6.0 180 7.0 294 8.0 448 9.0 648 10.0 900
    #   quasi_cube3 is n*(n+1)*(n+2)
    proc list_quasi_cube3 { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  [+ $i 1] [+ $i 2]]};return $boo}
    #   usage list_quasi_cube3   1 10
    #   1.0 6 2.0 24 3.0 60 4.0 120 5.0 210 6.0 336 7.0 504 8.0 720 9.0 990 10.0 1320
    #   quasi_cube4 is n*(n)*(n+1)
    proc list_quasi_cube4 { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  $i [+ $i 1]]};return $boo}
    #   usage, list_quasi_cube4 1 10
    #   1.0 2 2.0 12 3.0 36 4.0 80 5.0 150 6.0 252 7.0 392 8.0 576 9.0 810 10.0 1100
    #   quasi_square2 is  n*(n+1), 
    proc list_quasi_square2 { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  [+ $i 1]]};return $boo}
    #   usage, list_quasi_square2 1 10
    #   1.0 2 2.0 6 3.0 12 4.0 20 5.0 30 6.0 42 7.0 56 8.0 72 9.0 90 10.0 110
    #   list_sum_integers 
    proc list_sum_integers { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [/  [*  $i  [+ $i 1] ] 2. ]};return $boo}
    #   usage, list_sum_integers 1 10
    #   1.0 1.0 2.0 3.0 3.0 6.0 4.0 10.0 5.0 15.0 6.0 21.0 7.0 28.0 8.0 36.0 9.0 45.0 10.0 55.0
    #   list_sum_squares 
    proc list_sum_squares { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [/ [*  $i  [+ $i 1.] [+ [* $i 2.]  1.]] 6.]};return $boo}
    #   usage list_sum_squares 1 10
    #   1.0 1.0 2.0 5.0 3.0 14.0 4.0 30.0 5.0 55.0 6.0 91.0 7.0 140.0 8.0 204.0 9.0 285.0 10.0 385.0

    #   Auxiliary math series used along side B. math problems.
    #   B. math used <x-1/x> as initial square root estimate or  square root component 
    #   in some square root problems and B. triplet algorithms, ref Plimpton 322.
    proc list_bab_sqrt { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [- [* 1. $i] [/ 1. $i]] };$boo}
    #   Usage  list_bab_sqrt 0 10, bb is upper limit, aa is lower limit as set i $aa
    #   output 0.0 1.5 2.666 3.75 4.8 5.83 ...
    proc list_sqrt { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [sqrt $i ] };$boo}
    #   Usage  list_sqrt  0 10, bb is upper limit, aa is lower limit as set i $aa
    #   output 1.0 1.414 1.732 2.0 2.236 2.449 ... standard square roots
    #   B. math used <x+1/x> as initial increment estimate   or  square root component in some B. triplet algorithms, ref Plimpton 322.
    proc list_bab_math { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [+ [* 1. $i] [/ 1. $i]] };$boo}
    proc list_bab_reciprocal_formula2 { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* .5 [- [* 1. $i] [/ 1. $i]]] };$boo}
    #   Usage  list_reciprocal_formula2  0 10, bb is upper limit, aa is lower limit as set i $aa
    #   output 0.0 0.75 1.33  1.875 2.4 2.916  3.42857  ...
    proc list_bab_reciprocal_formula3 { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* .5 [+ [* 1. $i] [/ 1. $i]]] };$boo}
    #   Usage  list_reciprocal_formula3  0 10, bb is upper limit, aa is lower limit as set i $aa
    #   output 1.0 1.25 1.66  2.125 2.6 3.083 ...

    #   triangular_number_ref_quasi_square3 is  n*(n+1)/2,
    proc triangular_numbers_ref_quasi_square3 { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  [+ $i 1]  .5 ]};return $boo}
    #   usage, list_quasi_square2 1 10
    #   1.0 2 2.0 6 3.0 12 4.0 20 5.0 30 6.0 42 7.0 56 8.0 72 9.0 90 10.0 110
    #   usage  < triangular_numbers_ref_quasi_square3 1 10 >
    #   formula for triangular number is  n(n+1)/2
    proc triangular_number_2 {nn} { return [ expr { $nn*($nn+1.)/2. } ]}
    proc tri_triangular_number n { [*  [* $n [+ $n 1] ] .5 ]  }  #   good
    #   sum triangular number TNS = N*(N+1)*(N+2)/6
    proc sum_triangular_number {nn} { return [ expr { $nn*($nn+1.)*($nn+2.)/6. } ]}
    #   omitting return and expr words for brevity
    #   switching to math ops rather than expr
    proc tri_sum_triangular_number n { [/  [* $n [+ $n 1]  [+ $n 2] ] 6 ]  }  #   good
    #   usage  < sum_triangular_number 2 >
    #   sum_triangular_number series 1,4,10,20,35,56,
    #   OEIS A000217 reports triangular numbers as
    #    1, 3, 6, 10, 15, 21, 28, 36, 45, 55 ... ?
    #   OEIS A000292 reports  Tetrahedral (or triangular pyramidal) numbers:
    #   a(n) = C(n+2,3) = n*(n+1)*(n+2)/6.
    #    0, 1, 4, 10, 20, 35, 56, 84, 120, 165 ... ?
    #   some formulas pub. Elie de Joncourt, 1762, Netherlands
    #   triangular number TN = N*(N+1)/2
    #   alternate formula  TN = 0.5*N*(N+1)
    #   check >>  sum of consecutive TN numbers are squares
    #    TN <aa> +  TN <aa+1> = square
    #   Joncourt used TN to calculate square roots and cube roots
    #   Joncourt used mult.  aa * bb = <(aa+bb)**2 -aa**2 -bb**2>/2
    #   term  <(aa+bb)**2 -aa**2 -bb**2> is twice answer
    #   binomial theorem >> a*b = 0.5*{(a+b)**2 -a**2-b**2}.
    #   James Glaisher pub. TN  formula from 1889
    #   TN multiplication aa * bb = TN <aa-1> +  TN <bb> - TN <aa-bb-1>
    #   undefined region and products between -1. > N < 1.
    #   James Glaisher discussed TN and Quarter Square variants
    #   Quarter Square >> a*b = <(a + b)**2 − (a − b)**2> * .25
    #   The TCL procedures use base_10 in calculator.
    #   For comparison, TCL code may include redundant paths & formulas.
    #   alternate one liners programs for lists of working series
    #   based on notes of [antirez] in  [Tcl the Misunderstood]
    proc working_list_squares {} {lmap i {1 2 3 4 5 6 7 8 9} { expr { $i*$i} }}
    #   Usage  working_list_squares returns 1 4 9 16 25 36 49 64 81
    proc working_list_triangular1 {} {lmap i {1 2 3 4 5 6 7 8 9} { expr { $i*($i+1)/2} }}
    #   Usage  working_list_triangular returns 1 3 6 10 15 21 28 36 45
    #   See benefits of using args in following?
    proc working_list_triangular {args} {lmap i $args { expr { $i*($i+1)/2} }}
    #   Usage  working_list_triangular 1 2 3 returns 1 3 6
    #   Usage  working_list_triangular 1 2 3 4 5 6 7 8 9 returns 
    proc working_list_sum_triangular {args} {lmap i $args { expr { $i*($i+1)*($i+2)/6} }}
    #   Usage working_list_sum_triangular 1 2 3 4 5 6 7 8 9 
    #   returns 1 4 10 20 35 56 84 120 165
    #   Usage  time { working_list_sum_triangular 1 2 3 4 5 6 7 8 9} 5000
    #   returns 2.847 microseconds per iteration, fairly fast

        #   formula for two parallel resistors of resistance aa and bb ohms.
        proc parresistor2 {aa bb } { return [ expr (($aa *  $bb )/ ($aa + $bb))]}
        #   usage: set resistor [ parresistor 100 100  ];answer is 50.
        #   formula for three parallel resistors of resistance aa, bb,  and cc ohms.
        proc parresistor {aa bb cc } { return [ expr (($aa *  $bb * $cc)/ ($aa*$bb+$aa*$cc+$bb*$cc))]}
        #   usage: set resistor [ parresistor 100 100 100 ];answer is 33
        #   formula for fet transistor of volttage 0.009 volts and resistance bb ohms.
        proc fetvolts {aa bb } { return [ expr ($aa *  $bb )]}
        #   fet transistor load usage: set fetvolts [ .009 2500 ];answer is 22.5
        #   formula for fet transistor of volttage 0.009 volts, resistance bb ohms, cc and dd volts.
        proc fetdrainvolts {aa bb cc dd } { return [ expr ($aa *  $bb + $cc +  $dd)]}
        #   fet transistor usage: set fetdrainvolts [ .009 2500 7 5 ];answer is 34.5
        #   thin film resistor of dimension aa length and ww width, and sheet resistance cc
        proc thinfilmresistor {aa ww cc } { return [ expr (($aa * $cc)/ ($ww*1.))]}
        #   usage ;thinfilmresistor of length 0.8 cm,   width 0.2 cm, and sheet resistance of 150 ohms
        #   set resistance2 [ thinfilmresistor {.8 .2 100 } ] # answer is 600 ohms
        #   efficiency and output of electric motor with one horsepower for 746 watts.
        proc electrichorsepower  {aa bb cc } { return [ expr (($aa *  $bb * $cc)* (1./746.))]}# horsepower
        #   efficiency as 0.8 no_units, voltage as 25 volts, and input current as 10 amps
        #   The scale factor would be (1./746.) horsepower per watt.
        #   usage:append  details " [ electrichorsepower  .8 25 10  ]  " # answer is 0.268 horsepower
        #   formula for cascaded efficiency for n1 *n2 * n3
        proc   cascadedefficiency  {aa bb cc } { return [ expr (($aa *  $bb * $cc)* (100./1.))]}# 
        #   example for n1 = 85 percent, n2 equals 90 percent,and n3 equals 73 percent and scale factor 100./1.
        #   set  example_problem [ cascadedefficiency   .85 .90 .73    ] #answer is 56 percent.

      #   Lord Kelvin calculated the age of the earth by approximating the cooling of an molten iron sphere.
      #   heating of radioactive elements in earth's crust was not considered.
      #   following assumptions crust thermal defusivity $cc is 1.5E-6 meters/sec*sec,
      #   As a alternate defusivity estimate, Sandstone is about 1.1E-6 meters/sec*sec. 
      #   alpha $dd is 0.04 degrees centigrade per meter
      #   initial temperature $aa was 2500 centgrade degrees ,
      #   final temperature $bb was near zero degrees centigrade.$ee was number seconds in year was 3156000 seconds.
      proc kelvinearthtempage {aa bb cc dd ee} { return [ expr (($aa -  $bb)*($aa -  $bb)/ ( $cc * [pi]*  $dd* $dd*$ee))]}
      #   Kevin estimated a low and high age estimate of 25 million years and 100 million years, respectively.
      #   usage: low estimate: set age_of_earth " [  kelvinearthtempage 2500 .1 .0000015 .04  31536000.  ] "# answer 26 million years
      #   usage: high estimate could be:  set age_of_earth " [  kelvinearthtempage 5100 .1 .0000015 .04  31536000.  ] "# answer 110 million years

      proc fib {n} { if {$n < 2} then {expr {$n}} else {expr {[fib [expr {$n-1}]]+[fib [expr {$n-2}]]} }}
      #   Usage: $x.text insert 1.0 " goo  [  fib 8  ] " or answewr is 21
      #   Usage     set xat [fib 10] or answwer is 55
      #   Usage     set zat [fib 11] or answer is 89
      #   Now, lets define and pseudocode for formula of golden section as
      #   fib N+1 / fib Nth  and substitute fib 11 / fib 10
      #   for rough estimate of golden section: set gat [ expr {    ($zat*1.)   /   ($xat*1.)   } ]
      #   answer was 1.6181818 whereas the exact value was (1+sqrt(5))/2 (approx 1.6180339887)
      #   from the procedure with the exact formula.
      proc gm {args} { expr {.5*(1+sqrt(5))} $args}
      #   Usage on  golden mean,  [gm] returns 1.618033988749895
      #   Usage [gm /4] returns  0.4045084971874737
      #   Usage [gm /8.] returns  "0.20225424859373686"
      #   time { gm /8. } 5000 returns 4.2298 microseconds per iteration
      #   Usage to generate rectangle of golden proportions,
      #   rectangle length equals  golden mean constant * width
      set width 125 ; set length {* $width [gm] } :# for example
      set length [gm *$width ] :# for example  returns 202.254


      #   Now, lets define and pseudocode an error formula either by
      #   [ expr { 1 -(estimated)/( ideal & exact ) } ] or 
      #   if negative and not greater than one,    
      #   set error as [ expr   ( ideal & exact ) /   (estimated) -1. ] 
      
     
        set dat [ expr { (( ($zat*1.) / ($xat*1.)) / [ gm *1. ] -1.) } ]or 0.0000913
       #   Meaning the ratio of the 10 and 11th terms approach the limit by 0.0000913 error 

       proc fib {n} {expr {$n < 2 ? $n : [fib [expr {$n - 1}]] + [fib [expr {$n - 2}]]}}  #   AMG

    proc listfib { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend booboo [ int [ binet $i] ] };return $booboo} 
    proc binet { n} {set n [int $n ]; return [int [*  [/ 1 [sqrt 5]]  [- [**  [/   [+ 1 [sqrt 5]] 2 ] $n ]  [** [/   [- 1 [sqrt 5]] 2 ]  $n ] ] ] ] } 
    # Usage,  set binet1  [ binet 8]  # answer 21,   removing int's will return real numbers
    # Usage,  set fibno  [ listfib 1 8 ], answer 1 1 2 3 5 8 13 21 
    proc fibonacci_approx_for_large_N {n} { set phi [/   [+ 1 [sqrt 5]] 2 ]  ; return [round [/  [** $phi  $n   ] [sqrt 5 ]]] } #   test only, not sure for all N
    listfib 1 20
    1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

       #   wish to grab title of TCL  procs into lists
       #   TCL code into flowchart diagram.
       #   Can one break on the braces?
       #   need to get rid of braces in print out
       string map {\{ "" \} ""} $item #   from Abel Vian, TCL Club
       proc unbrace_string {item } {string map {\{ "" \} ""} $item }
       #   hopefully works without return statement
       #   Usage unbrace_string {REM {WISH} TO USE EXPR MATH}
       #   returns  REM {WISH} TO USE EXPR MATH as a string

        #   following proc session invoke TCLLIB math & math::trig library
        proc pyramid_d {hh bb} { [ acotand [expr (.5*$bb/$hh)  ]]  }
        proc pyra_d {hh bb} { [ acotand [* .5 [/ $bb $hh]  ]]  }
        #   pyramid_degrees 57.692 106.346  answer 47.334157521261254
        #   seked =  (7 * .5 * 360 cubits) / 250 cubits = 5.04 decimal palms
        proc seked_d {hh bb} {  [/ [* 7. .5 $bb ] $hh ] }
        #   usage seked 250. 360. equals 5.04
        #   integral of ramp function (2 * $x) over interval of 0 to 1.
        proc ramp2 {} { [::math::calculus::integralExpr 0 1 100 {2. * $x * 1.}]} 
        #    ramp2  #   returns 1.0
        #   TCLLIB integration of expr expression in x 
        #   of OEIS formula for pi, ref notes on sequence A003881
        proc pie_tcllib {} {set return [::math::calculus::integralExpr 0 100 10000 {(4.* $x)/($x**4 + 1)}]}
        #   Usage pie_tcllib  -> 3.1413926535904273
        #   set return is old fashioned didactic, for brevity may omit set return
        proc pie_pie {} {set return [::math::calculus::integralExpr -100000 100000 1000000 {(1.)/($x*$x + 1.)}]} 
        #    Usage pie_pie #   -> 3.1415726535896074 
        #   integrate f(x) for pi from minus inf to plus inf, but slowly converges 
        #   set return is old fashioned didactic , for brevity may omit set return
         proc pi {} {expr acos(-1)} #   AMG
         expr sqrt([pi]) #   -> 1.7724538509055159 sqrt of pi
         proc pie_sqrt {} { [::math::calculus::integralExpr -100000 100000 1000000 { exp (-$x * $x  )}]} 
        #   Usage pie_sqrt #   -> 1.772453850905516
        #   integrate f(x) for pi sqrt from minus inf to plus inf, but slowly converges 
        proc pie_si {} { [::math::calculus::integralExpr -100000 100000 1000000 { sin($x) / $x }]} 
        #   pie_si #   returns -> 3.1416126408100333  ... ->   pi
        #   integrate f(x) for pi si from minus inf to plus inf, but slowly converges
        #   Aristotle constant 22./7. > pi,   expr {   22./7. - [pi] }  ->  0.0012644
        proc picc {} { [::math::calculus::integralExpr 0 1. 100 { $x**4 * (( 1. - $x )**4) / (1. + $x**2) }]}
        #   Usage picc ->   0.0012644892673427967
        #   proof that Aristotles 22./7. slightly greater than pi
        #   obtain area of unit circle, radius = 1 
        #   x**2 + y**2 = r**2, 2* half circle evaled in $x
        proc pill {} { [::math::calculus::integralExpr -1 1 10000 { 2.* sqrt(1. - $x * $x  )}]} 
        #   Usage    pill    #    return  ->  3.1415921943382195 
        #   accuracy proportionl  to number of points integrated
        #   try 100 points rather than  
        #   10000 points of demo,    100 points    ->   3.141133205339226
        #   end TCLLIB

#  commands and procs below should should be pastable into TCL easy eye Console
package require math::calculus
namespace import math::calculus::*
proc pi {} {expr acos(-1)} #   AMG returns 3.141592653589793
symdiff {acos($x)} x    #   symbolic differentiation into expr expression
(-1.0 / sqrt((1.0 - ($x * $x))))
proc piexx {} { [::math::calculus::integralExpr -1 1 1000 { 2.* sqrt(1. - $x * $x  )}]} 
#  Usage piexx ->   3.1415781302139947 
#  fpoolwing variant from changed limits
proc pied {} { [::math::calculus::integralExpr 0 1 10000 { 4.*( sqrt((1.0 - ($x * $x))))}]} 
#  Usage pied -> 3.141592491220191 
proc pixx {} { [::math::calculus::integralExpr 0 1 10000 { (1.0 / (1.0 + ($x * $x)))}]} 
#  Usage  pixx -> 0.7853981633974438 #   returns pi/4 

       # start TCLLIB Dependency here in Advanced topics
       # Find a Maximum numeric value in list from max on TCL WIKI
       # maybe overkill on setup requirements, but setup is tricky on Windows10 here
       # This is a wiki example anyway, cut and paste what works on your machine.
       package require Tcl 8.6
       package require math::numtheory
       namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
       set tcl_precision 17
       # Found routine for maximum numeric  values in list 
       # suggest control maximum values with index
       # for 4 or 5 maximum numeric values in output.
       set values_list [ list 1 2 3 4 5 10  6 7 8 9 }
       set maximum_values_list [ ::tcl::mathfunc::max {*}$values_list ]
       # returns 10
       # end TCLLIB Dependency here 

        #   proc errorx always returns a positive error. 
        #   Normally assume $aa is human estimate,
        #   assume $bb is divinely exact or textbook standard estimate. 
        proc errorx  {aa bb} {expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*100. : (($bb*1.)/$aa -1.)*100.}}
        #   Usage errorx 3.1 3.14 returns 1.2903 in positive percent
        #   Usage errorx 3.14 3.1 returns 1.2903 in positive percent
        #   Usage errorx 3.03 3.141592 returns 3.6829 in positive percent

        #   Usage from one line programs in Searching Babylonian triplets
        #   Usage comparing accuracy of Heron_method and pythagorean_theorem for opposite side
        #   opposite side (height) =   expr { .5 *(2-(.5/2.)) } = 0.875
        set heron_method [ expr { .5 *(2-(.5/2.)) } = 0.875 ] #   returns  0.875
        set pythagorean_theorem_height [expr { sqrt (1**2-.5**2)   }  #   returns 0.8660 rnd for opposite side
        proc errorx  {aa bb} {expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*100. : (($bb*1.)/$aa -1.)*100.}} 
        set percent_error [ errorx 0.875 0.8660] #   returns 1 percent error rounded

        #   Usage example of errorx as one liner program
        #   in finding percentage errors and average of errors.
        #   The ukullu  or inverse slope   
        #   was expr { triangle side $adjacent/ side $opposite }.
        #   The adjacent side or triangle short side was between
        #   the triplet 19 = 0.501  and triplet 20  = 0.4875 on Plimpton 322 extension 
        #   setting percent errors  of triangle short side .5 between triplet 19 = 0.501
        #   and triplet20  = 0.4875
        set error5 [ errorx .5  0.501 ] #    returns 0.2000 percent relative error
        set error6 [ errorx .5 0.4875 ] #   returns 2.5641 percent relative error
        set average_error_on_2  [ expr { ( $error5 + $error6 ) * 0.5 } ]#  returns 1.38205 average percent relative error

        #   Use one line errorx proc to estimate percent errors in approximate  Elliot Wave Breakpoints
        proc errorx  {aa bb} {expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*100. : (($bb*1.)/$aa -1.)*100.}}
        set grc 1.61803398874989484820 #   golden ratio constant
        set grc .61803398874989484820 #   golden ratio conjugate
        set wave_1a [ expr {  5./8. } ]  #    returns 0.625,  very rough approximate $grc
        set wave_2a [ expr {  8./5. } ]  #    returns 1.6, very rough approximate $gr
        set wave_3a [ { 832040./ 1346269.} ] #   returns 0.6180339887496481 
        set error_1 [ $grc [/ 5. 8. ]      #   returns 1.127  percent error on  very rough approximate $grc
        set error_2 [ $grc [/ 987. 1597. ]  #   returns 2.837e-5  percent  error
        set error_3 [ $grc [/ 832040. 1346269. ]   #   returns 3.992e-11 percent error

        #; Eratosthenes' method to calculate the Earth's circumference has been lost.
        #; Original units were greek_stadia which are converted to meters here.
        #; 1 greek_stadium (really Egyptian unit) is equal to 157.5 meters
        set greek_stadia_length [ expr { 5000.0 * 157.5} ] #   returns 787500.0 meters
        set earth_circumference [ expr { 360. *787500.0 / 7.2} #    returns  39375000.0 meters , convert to 39375. kilometers
        set earth_circumference_error [ errorx   40076.0   39375. ] #   returns 1.78 percent low

    proc timex2  aa { time {puts Hello} $aa } #   [RS]
    #   Usage   timex2  10
    #   Usage timex2  4 returns Hello Hello Hello Hello 751.75 microseconds per iteration
    proc timex2  aa { time {puts Hello} $aa }
    timex2 { expr { 4+5 } } 1000  #     returns 0.268 microseconds per iteration
    timex2 {expr 4+5 } 1000  #    returns 0.104 microseconds per iteration
    #   Need to preserve spaces near expr
    time {  [ + 4 5 ] } 1000  #    should be 0.104 microseconds per iteration
    time {  [ + 4 5 ] } 1000  #    returns 9
    set t0 [clock clicks -millisec]; puts [expr { 1+2 ]; puts stderr "[expr {([clock clicks -millisec]-$t0)/1000.}] sec" #   RS
    time {  for {set i 0} {$i<1000} {incr i} { # empty body}} #   TCL 8.5 TclCmd Manual
    #   returns 512 microseconds per iteration on machine here

    proc timex2  aa { time {puts Hello} $aa } #    RS 
    # output   for  timex2  4
    Hello
    Hello
    Hello
    Hello
    751.75 microseconds per iteration

proc figurate1_oblong {  n } {[ return [ expr {($n+1) }]}                                                                                
proc figurate2_triangular {  n } {[ return [ expr {($n+1)/2}]}                                                                                
proc figurate3_square {  n } {[ return [ expr {$n**2}]}                                                                                
proc figurate4_pentagonal {  n } {[ return [ expr {(3*$n-1)/2}]}                                                                                
proc figurate5_hexagonal {  n } {[ return [ expr {(4*$n-2)/2}]}                                                                                
proc figurate6_heptagonal  {  n } {[ return [ expr {(5*$n-3)/2}]}                                                                                
proc figurate7_octogonal {  n } {[ return [ expr {(3*$n-2)}]}                                                                                
#  *****  2D figurate into 3D figurate $numbers        ******                                                                        
proc figurate8_triangular {  n } {[ return [ expr {($n+1)/2}]}   #   duplicate proc for comparison                                                                            
proc figurate9_tetrahedral {  n } {[ return [ expr {($n+1)*($n+2)/6}]}                                                                                
proc figurate10_hypertetrahedral {  n } {[ return [ expr {($n+1)*($n+2)*($n+3)/24}]}

#  adding extra and redundant spaces in proc expressions 
#  below for wiki readability
#  recommend each proc be math checked by hand on small numbers (2,3,4)
#  recommend each proc be checked for small, medium,  and large numbers
#  in expected range of operation
#  one may leave off return commands and unnecessary spaces for brevity

#  formula for Sum of Squares is k(2) = n*(n+1)*(2*n+1)/6
proc sum_squares  { n } {set res [expr { $n*($n + 1)*(2*$n +1 ) / 6 }]}
#  Usage sum_squares 2 ->  5 
#  check answer expr 2**2 -> 4, 4 + 1 = 5
#  Usage sum_squares 1000000 ->  333333833333500000 

#  formula for Sum of Cubes is k(3) = (n**2)* ((n + 1)**2) / 4 
proc sum_cubes  { n } {set res [expr { ($n**2)* (($n + 1)**2) / 4 }]}
#  Usage sum_cubes 2 ->  9
#  check answer expr 2**3 -> 8, 8 + 1 = 9
#  Usage sum_cubes 1000000 ->  250000500000250000000000 

#  formula sum_4th_power k(4) = n* (n + 1)* (2*n + 1 )* ( 3*n**2 + 3*n -1)/30
#  using integer arithmetic for the long digit answers
proc  sum_4th_power {n} { expr { $n* ($n + 1)* (2*$n + 1 )* (3*$n**2 + 3*$n -1)/30}}
#  Usage sum_4th_power 2  -> 17
#  check answer expr 2**4 -> 16, 16 + 1 = 17
#  Usage sum_4th_power 0  -> 0  #   Usage sum_4th_power 1  -> 1 
#  Usage sum_4th_power 1000  -> 200500333333300
#  Usage  sum_4th_power 200 -> 64802666660
#  Usage sum_4th_power 1000000000
#      -> 200000000500000000333333333333333333300000000
 
#  formula sum_5th_power k(5) = n*n* (n+1)* (n+1 )* (  2*n**2 + 2*n -1)/12
proc sum_5th {n} {return [expr {($n*$n* ($n + 1)*($n + 1 )*(2*($n**2)+2*$n - 1))/12}] }
#  internal ? in expr testing for 2 conditions
proc sum_5th_power  {n} {expr { $n < 1? 0: $n > 1 ? 1 : ($n*$n* ($n + 1)*($n + 1 )*(2*($n**2)+2*$n - 1))/12}}
#  Usage sum_5th_power 0  -> 0  #   Usage sum_5th_power 1  -> 1 
#  Usage sum_5th_power 2  -> 33

#  formula sum_6th_power k(6) =( n*(n + 1)*(2*n + 1 )*(3*(n**4)+(6*(n**3))-(3*n) + 1))/42
proc sum_6th {x} {return [expr {( $x*($x + 1)*(2*$x + 1 )*(3*($x**4)+(6*($x**3))-(3*$x) + 1))/42}] }
#  Usage sum_6th 2 -> 65 
#  check answer expr 2**6 = 64, 1 + 64 = 65 

#  formula sum_7th_power k(7) =( n*n*(n + 1)*(n + 1)*(3*(n**4)+(6*(n**3))-n*n-(4*n) + 2))/24
proc sum_7th {x} {return [expr {( $x*$x*($x + 1)*($x + 1)*(3*($x**4)+(6*($x**3))-$x*$x-(4*$x) + 2))/24}] }
#  Usage sum_7th 2 -> 129 
#  check answer  expr 2**7 = 128, 1+128 = 129

#  adding extra and redundant spaces in expressions  below for wiki readability
#  recommend each proc be math checked by hand on small numbers (2,3,4)
#  recommend each proc be checked for small, medium, and large numbers
#  in expected range of operation
#  one may leave off return commands and unnecessary spaces

#  formula sum_8th_power k(8)=(n/90)*(n+1)*(2*n+1)*(5*n**6+15*n**5+5*n**4-15*n**3-n**2+9*n-3)
proc sum_8th {x} {return [expr {($x / 90)*($x + 1)*(2*$x + 1)*(5*$x**6 + 15*$x**5 + 5*$x**4 - 15*$x**3 - $x**2 + 9*$x - 3)}]}
#  Usage sum_8th 2 -> 257 #   using integer arithmetic
#  check answer expr 2**6 = 256, 1 + 256 = 257  #   using integer arithmetic
#  Usage sum_8th 1000000 -> 
#    111110499995666659999999533338000000222219999999966667 #   using integer arithmetic
#    1.111116111117778e+53  #   add decimal point on integer term (90.) in proc for floating point

#  formula sum_9th_power k(9)= (n**2/20)*(n+1)*(n+1)*(2*n**6+6*n**5+n**4 - 8*n**3+n**2+6*n-3)
proc sum_9th {x} {return [expr {($x**2 / 20.) * ($x + 1)*($x + 1)*(2  * $x**6 + 6*$x**5 + $x**4 - 8*$x**3 + $x**2 + 6*$x - 3)}]}
#  Usage sum_9th 2 -> 513               #   using integer arithmetic
#  check answer expr 2**9 = 512, 1 + 512 = 513  
#  sum_9th 1000000 ->  1.0000050000075e+59  #   proc sum_9th for floating point

#  formula sum_10th_power k(10)= (n/66)*(n+1)*(2n+1)*(3*n**8+12*n**7+8*n**6 - 18*n**5-10*n**4+24*n**3+2*n**2-15*n+5)
proc sum_10th {x} {return [expr {($x / 66. )*($x + 1)*(2*$x + 1)*(3*$x**8 + 12*$x**7 + 8*$x**6 - 18*$x**5 - 10*$x**4 + 24*$x**3 + 2*$x**2 - 15*$x + 5)}]}
#  Usage sum_10th 2 -> 1025  #   using integer arithmetic
#  check answer expr 2**10 = 1025, 1 + 1025 = 1026
#  Usage sum_10th 1000000  ->  9.090959090992425e+64  #   proc sum_9th for floating point

#  commands and procs below should should be pastable into TCL easy eye Console
package require math::calculus
namespace import math::calculus::*
#  symbolic differentiation transformed expression in x into dx as expr expression
#  x subbed for n in formula proc for sum of fifth powers 
proc sum_5thx_power  {x} {expr { $x < 1? 0: $x > 1 ? 1 : ($x*$x* ($x+1)*($x+1 )*(2*($x**2)+2*$x-1))/12}}
symdiff {($x*$x* ($x+1)*($x+1 )*(2*($x**2)+2*$x-1))/12} x
returns ((((((2 * $x) * 2) + 2.0) * ((($x * $x) * ($x + 1)) * ($x + 1))) + (((($x * $x) * ($x + 1)) + ((($x * $x) + (($x + $x) * ($x + 1))) * ($x + 1))) * (((2 * ($x ** 2)) + (2 * $x)) - 1))) / 12)
proc pow5th {m n} { set res [round [::math::calculus::integralExpr $m $n 10000 {  ((((((2 * $x) * 2) + 2.0) * ((($x * $x) * ($x + 1)) * ($x + 1))) + (((($x * $x) * ($x + 1)) + ((($x * $x) + (($x + $x) * ($x + 1))) * ($x + 1))) * (((2 * ($x ** 2)) + (2 * $x)) - 1))) / 12) }]]}
#  Usage pow5th 0 2 -> 33 #   pow5th 0 5 -> 4425
#  pow5th 0 10000 -> 166716670833332389412864

#  symbolic differentiation transformed expression in x into dx as expr expression
symdiff {1+$x**2} x  -> (2 * $x)
symdiff {5+$x**7} x  -> (7 * pow($x, 6))
symdiff {$x**4+5*$x**3+4*$x**2-3*$x+2} x   -> ((((4 * pow($x, 3)) + ((3 * pow($x, 2)) * 5)) + ((2 * $x) * 4)) - 3.0)
symdiff {(1+$x)**3} x   -> (3 * pow((1 + $x), 2))
symdiff {(4+$x)**.5} x  -> (.5 * pow((4 + $x), -0.5))
symdiff {1/(1+$x)} x    -> -(((1 / (1 + $x)) / (1 + $x)))
symdiff {(1+$x)**(1/3)} x  -> (pow((1 + $x), (1 / 3)) * ((1 / 3) / (1 + $x)))

        #   User loaded procs in the ::tcl::mathfunc namespace invoked inside expr, ref TCL 8.5 plus
        #   Apparently considerable computer time saving and effectively extra precision inside the expr w/8.5+
        proc ::tcl::mathfunc::fib n {expr {$n<2? 1: fib($n-2)+fib($n-1)}} ; expr fib(6)
        time {proc ::tcl::mathfunc::fib n {expr {$n<2? 1: fib($n-2)+fib($n-1)}} ; expr fib(6)} 5000
        #   returns  22.4926 microseconds per iteration
        time {expr fib(6) } 5000 #   returns 12.0996 microseconds per iteration
        proc tcl::mathfunc::factorial x {expr {$x < 2? 1: $x * factorial($x-1)}};expr factorial(100)  
        time {proc tcl::mathfunc::factorial x {expr {$x < 2? 1: $x * factorial($x-1)}};expr factorial(100)  } 5000
        expr fac(100) #   returns 
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
        #   time { func factorial 100 } 5000 returns 88.956 microseconds per iteration
        time {expr fib(7) } 5000 #   18.6396 microseconds per iteration
        proc golden_mean_constant_wordy {} { return [expr {.5*(1. + sqrt(5))}] } #   early wordy version
        proc golden_mean_constant {} {expr {.5*(1. + sqrt(5))}} #   improved, but not using tcl::mathfunc on this one
        #   Usage golden_mean_constant returns 1.618033988749895
        #   time { golden_mean_constant} 5000 returns 0.669 microseconds per iteration
        #   using  tcl::mathfunc to generate constant for golden mean 
         proc tcl::mathfunc::golden_mean_constant2 {} {expr  {.5*(1. + sqrt(5))}} 
        #   Usage expr golden_mean_constant2() #   returns 1.618033988749895
        #   Usage time {expr golden_mean_constant2()  } 5000 #   returns 0.6914 microseconds per iteration

     #   for starting the adventure  to infinity and beyond.
     #    Titius-Bode set < Earth = 1 ... > as number assignment scheme for planets
     #   The Asteriod Ceres is included on most number assignment schemes
     #   Ceres represents the Asteriod belt between Mars and Jupiter.
     #   The dwarf planet Pluto  is included on most number assignment schemes.
     proc titius_bode_law_1772  {aa } {expr { (4. + 3 * 2**$aa)*.1 } }  #   #  $nn=l for Earth,2,...
     #   Other planet number schemes are for power laws are available here, < Mercury = 1 ...>
     #   from Gaussin (1880) and Armellini (1921)
     proc gaussin_formula_1880  {nn} {expr {0.2099 * (1.7226 ** $nn)} } #   $nn=l for Mercury,2,...9
     proc armellini_formula_1921  {nn} {expr {0.283 * (1.53 ** $nn)} }  #   $nn=l for Mercury,2,...11
     #   very interesting, Nicolini transformed planet number scheme in  Titius_Bode 
     #   to < Mercury = 1 ...>, refer to Nicolini
     proc nicolini_formula_1957  {nn} {expr {0.4 + 0.075 * (2. ** $nn)} }  #   $nn=l for Mercury,2,... 
     proc basano_hughes_formula_1979  {nn} {expr {0.285 * (1.523 ** $nn)} } #   $nn=l for Mercury, 2,...
     #   Sven-Ingmar Ragnarsson, 1994, modeled Jupiter and the outer planets to Uranus, separately. 
     #   See the  Ragnarsson paper, setting these planet assignment numbers is tricky.
     #   $nn=0 for Jupiter, 2 = Saturn, 3 = Uranus ....
     proc ragnarsson_formula_1979  {nn} {expr {5.203*(((5./2.)**(2./3.))**$nn) )} } #   $nn=0 for Jupiter, 2 = Saturn,...
     proc list_integers { aa bb} { for {set i 1} {$i<=$bb} {incr i} {lappend boo [* 1. $i ] [*  $i  1.]};return $boo}  
     #   usage, list_integers 1 10
     #   set answer_list_integers = [list 1.0  1.0 2.0 2.0 3.0 3.0 4.0 4.0 5.0 5.0 6.0 6.0 7.0 7.0 8.0 8.0 9.0 9.0 10.0 10.0 ]
     proc list_titius_bode  { aa bb} { for {set i 1} {$i<=$bb} {incr i}    {lappend boo [* 1. $i ] [expr { (4. + 3. * 2**$i)*.1}]};if {$i > $bb} {return $boo}}
     #   Usage   list_titius_bode 1 6
     #   set answer [ list 1.0 1.0 2.0 1.6 3.0 2.8 4.0 5.2 5.0 10.0 6.0 19.6]
      proc list_gaussin_formula  { aa bb} { for {set ii 1} {$ii<=$bb} {incr ii} {lappend boo [* 1. $ii ] [expr {0.2099 * (1.7226 ** $ii)} ]};if {$ii > $bb} {return $boo}}
      #   Usage   list_gaussin_formula 1 6
      #   set answer_gaussin [ list 1.0 0.36  2.0 0.62  3.0 1.07  4.0 1.84  5.0 3.18  6.0 5.48 ]
      proc list_armellini_formula  { aa bb} { for {set ii 1} {$ii<=$bb} {incr ii}    {lappend boo [* 1. $ii ] [expr {0.283 * (1.53  ** $ii)}]};if {$ii > $bb} {return $boo}}
      #   Usage  list_armellini_formula 1 7
      #   set answer_armellini [  1.0 0.43 2.0 0.66 3.0 1.013 4.0 1.55 5.0 2.37 6.0 3.63  7.0 5.55 ]

       #   {lmap i {1 2 3 4 5 6 7 8 9} { expr { $i*($i+1)/2}
       set args { 1 2 3 4 5 6 7 8 9}
       if { ![catch {expr $args} result] } { puts "gosh" } #    MG , catch should fill $result???
       proc tester {args} {{![catch {expr $args} result]} ? 0:lmap i {$args} { expr { $i*($i+1)/2}}  #    MG  derived
       #   Usage tester 1 2 3 4 5 6 7 8 9 {lmap i {1 2 3 4 5 6 7 8 9} { expr { $i*($i+1)/2}
       set args { 1 2 3 4 5 6 7 8 9}
       if { ![catch {  expr {$args}} result] } { puts "gosh" }
       #   prints gosh
       #   $result returns " 1 2 3 4 5 6 7 8 9"
       if { ![catch {  expr {$args}} result] } { puts "gosh $result" } { puts "read error called out on $result}  #    MG  derived
       proc isNumeric x {expr ![catch {expr $x*1}]}   #   RS
       if { [regexp {^[$A-Za-z_]} $i]} {set i  $x}    :# RS 
       if {[isNumeric $previous] && [regexp {^[$A-Za-z_]} $i]} {set i  $x}   :#  RS 
       proc whitelist {a} {return [lreplace $term 0 -1]# take list ,return list without blanks}
       #   complex logic in expr operator  ?  in a?b:c>, check of entries of zero in math proc
       #   4 conditions being checked, aa =? 0, bb =? 0,  $aa > $bb ? , else  $aa >| $bb
       proc err  {aa bb} {expr { $aa == 0|| $bb==0 ?  0:  $aa > $bb ? (($aa*1.)/$bb -1.)*100. : (($bb*1.)/$aa 
-1.)*100.}}
       #   Usage examples =>  err 0 7 r> 0, err 7 0 r> 0 err 5 6 r> 19.9, err 6 5 r> 19.9 

#  formula sum_5th_power = n*n* (n+1)* (n+1 )* (  2*n**2 + 2*n -1)/12
#  formula correct in proc but no checks on entries
proc sum_5th {n} {return [expr {($n*$n* ($n+1)*($n+1 )*(2*($n**2)+2*$n-1))/12}] }
#  internal ? in expr testing for 2 conditions
proc sum_5th_power  {n} {expr { $n < 1? 0: $n == 1 ? 1 : ($n*$n* ($n+1)*($n+1 )*(2*($n**2)+2*$n-1))/12}}
#  Usage sum_5th_power 0  -> 0  #   Usage sum_5th_power 1  -> 1 
#  Usage sum_5th_power 2  -> 33
#  test 4 conditionals might work
proc sum_5th_power2  {n} {expr { $n < 0? 0: $n == 0 ? 0: $n == 1 ? 1: $n == 1 ?1 : ($n*$n* ($n+1)*($n+1 )*(2*($n**2)+2*$n-1))/12}}

    #   see Playing with recursion on TCL Wiki
    proc ++   x {incr x }  #    RS 
    proc -+   x  {incr x -1 }
    proc = {m n} {string equal $m $n}  #    RS 
    #   Usage   = 1 2 returns 0
    #   Usage    ++ 2  returns 3
    #   works for strings
    #   Usage = cat cat returns    1
    #   Usage  = cat dog returns  0   
    proc -+   x  {incr x -1 }
    proc ++   x {incr x }  #    RS 
    #   Usage -+ 5 returns 4
    #   Usage -+    [++ 1 ]  returns  1

      proc geoseries1 {aa bb} {expr {abs($bb)<1? $aa/(1.0-$bb) : 0.0}}  #   AM
      #   below, older one liner with  balky  redundant returns and if statement.
      #   proc geoseries2 {aa bb cc} { if {$bb <= -1||$bb >= 1} { return 0} ;return [ expr $aa / ( 1 - $bb ) ]};
      #   27Apr2007,gold,works with etcl
      #   convergent geometric series if $a != 0 and -1 > $r < 1
      #   $a is constant multiplier, $r is fraction under exp.
      #   Series is undefined if r< -1 or r > 1
      #   $cc is optional number of terms in partial sum.
      #   If divergent, proc returns zero,
      #   Usage,set test5 [ geoseries1 15 .2857   ]# test5~~21
      #   Usage,set test5 [ geoseries1 15 -1.2857   ]# test5~~zero
      #   Usage,set test5 [ geoseries1 15 1.2857   ]# test5~~zero
      #   Lets adapt AM's more concise procedure from below 
      #   or the partial sum of a geometric series.
      proc geoseries3 {aa bb {cc -1}} {expr {abs($bb)<1? ($aa/(1.0-$bb))-([expr {$cc>0}]*$aa*pow($bb,$cc))/(1-$bb) : 0.0}}
      #   Usage,set test5 [ geoseries3 15 .2857 1 ]# test5~~15
      #   Usage,set test5 [ geoseries3 15 .2857 4 ]# test5~~20.8597
      #   Now, lets define and pseudocode an error formula as
      #   [ expr { 1 -(estimated)/( ideal & exact ) } ] or 
      #   [ expr {1 - (partial sum of n terms)/(total sum of infinite terms) } ]  
      #   set error [expr {1-[ geoseries3 15 .2857 5 ] / [ geoseries3 15 .2857 ] }]#  using default args on later.
      #   error with 5 terms approaches .002#  error with 7 terms approaches .00015
      #   Vola, more than 7 terms exceeds "slide rule accuracy".     

      #   AM won first place above, gold
      proc geoseries {aa bb} {expr {abs($bb)<1? $aa/(1.0-$bb) : 0.0}}  #   AM

    #   Start pseudocode tally
    #   The  Foo_Bat has 1 sway_back + 2 tails+  3 heads+ 6 horns + 10 legs + 12 big_feet
    #   The  Foo_Bat has 34 parts
    #   End pseudocode tally
    proc thingy name {proc $name args "namespace eval $name \$args"}  #   RS
    proc thingy2 name {interp alias {} $name {} namespace eval $name}  #    MS
    thingy  Foo_Bat
    Foo_Bat set sway_back 1
    Foo_Bat set tails 2
    Foo_Bat set heads 3
    Foo_Bat set horns 6
    Foo_Bat set legs  10
    Foo_Bat set big_feet  12
    Foo_Bat proc corral {x} { expr { $ Foo_Bat::sway_back + $ Foo_Bat::tails +  $ Foo_Bat::heads + $ Foo_Bat::horns + $ Foo_Bat::legs + $ Foo_Bat::big_feet }}
    Foo_Bat::corral 1  #   returns 34
    puts "  Foo_Bat has $ Foo_Bat::sway_back sway_back + $ Foo_Bat::tails tails+  $ Foo_Bat::heads heads+ $ Foo_Bat::horns horns + $ Foo_Bat::legs legs+ $ Foo_Bat::big_feet big_feet"
    #   The  Foo_Bat has 1 sway_back + 2 tails+  3 heads+ 6 horns + 10 legs + 12 big_feet
    puts "  Foo_Bat has [ Foo_Bat::corral 1 ] parts "
    #   The  Foo_Bat has 32 parts
    #   End of  Foo_Bat source code, 
    #   but the Foo_Bat may still lurking
    #   inside console until session end

    source Easy_Eye_Testbed_V3_for_Thingy_RS.tcl
    puts "*******************************************************"
    puts " Foo_Bat(s) begin nesting here "
    puts "*******************************************************"
    Foo_Bat proc  thingy name {proc $name args "namespace eval $name \$args"}
    Foo_Bat::thingy Baby_Foo_Bat
    Foo_Bat::Baby_Foo_Bat proc pi {} {expr acos(-1)}
    Foo_Bat::Baby_Foo_Bat::pi
    puts " Foo_Bat::Baby_Foo_Bat::pi returns  [ Foo_Bat::Baby_Foo_Bat::pi ]  "
    puts "pi and thingy procs both inside the nested namespace Foo_Bat::Baby_Foo_Bat"

        # pretty print from autoindent and ased editor
        # Timing Equivalent One Liners V2
        # written on Windows 10 on eTCL
        # working under TCL version 8.6
        # gold on TCL Club , 8/20/2020
        # Ref. WIKI BOOKS, Tcl_Programming_Introduction
        # Book Section  contrasts one liners
        # versus  traditional procedural  approach
        # below contains redundant procs
        package require Tk
        package require math::numtheory
        package require math::constants
        package require math::trig
        package require math
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory math::trig math::constants }
        set tcl_precision 17
        proc pie {} {return [expr acos(-1)]}
        console show
        console eval {.console config -bg palegreen}
        console eval {.console config -font {fixed 20 bold}}
        console eval {wm geometry . 40x20}
        #  uses join, but computer time on some?
        proc mean_1  list {expr double([join $list +])/[llength $list]}
        # math operators exposed as commands, and the expand operator
        proc mean_2  list {expr {[tcl::mathop::+ {*}$list]/double([llength $list])}}
        #  import the tcl::mathop operators
        proc mean_3 list {expr {[+ {*}$list]/double([llength $list])}}
        #  import the tcl::mathop operators from <Summing a list>
        # list add ladd or summing a list
        proc ladd_1 {listx} {::tcl::mathop::+ {*}$listx}
        # using join in ladd_2 from RS
        proc ladd_2 {listx} {expr [join $listx +]+0} #   RS
        # using expr including non integers from PYK 2016-04-13
        proc ladd_3 {listx} {set total 0.0; foreach nxt $listx {set total [expr {$total + $nxt}]}; return $total}
        set limit 12
        puts "%|table| | printed in|TCL format |% "
        puts "&| session| proc &  mean value| elements in list  | comment, if any|& "
        for { set i 0 } { $i <= $limit }  { incr i } {
            set lister { 1 2 4 5 6 7 8 9 10 }
            lappend lister  [* $i [pie]]
            puts "&|$i | ladd_1   [ ladd_1  $lister ] |  $lister | proc timer [ time { set qq  [ ladd_1  $lister ]} 5000 ]  |&"
            puts "&|$i | ladd_2   [ ladd_2  $lister ] |  $lister | proc timer [ time { set qq  [ ladd_2  $lister ]} 5000 ]  |&"
            puts "&|$i | ladd_3   [ ladd_3  $lister ] |  $lister | proc timer [ time { set qq  [ ladd_3  $lister ]} 5000 ]  |&"
            puts "&|$i | mean_1   [ mean_1  $lister ] |  $lister | proc timer [ time { set qq  [ mean_1  $lister ]} 5000 ]  |&"
            puts "&|$i | mean_2   [ mean_2  $lister ] |  $lister | proc timer [ time { set qq  [ mean_2  $lister ]} 5000 ]  |&"
            puts "&|$i | mean_3   [ mean_3  $lister ] |  $lister | proc timer [ time { set qq  [ mean_3  $lister ]} 5000 ]  |&"
            puts "&|$i | ::math::mean  [::math::mean  1  2  4  5  6  7  8  9  10 [* $i [pie]]] |  $lister | proc timer [ time { set qq    [ ::math::mean  1  2  4  5  6  7  8  9  10 [* $i [pie]] 5000 ]}  ]  |&"
        }
        #end        

        # pretty print from autoindent and ased editor
        # Easy Eye Testbed V3 for Thingy_RS and Other One Liner Programs
        # easy eye calculator V3, large black type on green
        # used as testbed for one liners programs
        # written on Windows 10 on TCL
        # working under TCL version 8.6
        # base calculator derived from RS & FR
        # added cosmetics and extensions for "paper tape"
        # gold on TCL WIKI , 10Sep2020
        package require Tk
        package require math::numtheory
        package require math::constants
        package require math::trig
        package require math
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory math::trig math::constants }
        package provide calculatorliner 1.0
        namespace path {::tcl::mathop ::tcl::mathfunc}
        set tclprecision 17
        namespace eval liner {
            console show
            proc initdisplay {} {
                pack [entry .e -textvar e -width 50 ]
                # suggest maintain dead spaces and air gaps near expr, brackets, etc
                bind .e <Return> {puts $e;catch {expr  [string map {/ *1./} $e]   } res; set e $res;puts $res} #   RS & FR
            }
        }
        proc linershell {} {
            namespace import liner::*
            liner::initdisplay
            .e configure -bg palegreen
            .e configure -fg black
            .e configure -font {helvetica 50 bold}
            .e configure -highlightcolor tan -relief raised -border 30
            focus .e
            wm title . "Easy Eye Calculator  >> Numeric Display Window "
            #. configure -background orange -highlightcolor brown -relief raised -border 30
            proc pi {} {
                expr acos(-1)
            }
            proc > {args}  {
                global e
                set e $args}
            proc e> {args} {
                global e
                set e ""}
            proc q> {args} {
                exit}
        }
        bind Label <1> {focus %W}
        
        bind Label <FocusIn> {
            %W configure -background SystemHighlight -foreground SystemHighlightText
        }
        bind Label <FocusOut> {
            %W configure -background SystemButtonFace -foreground SystemButtonText
        }
        bind Label <Control-c> {
            clipboard clear
            clipboard append [%W cget -text]
        }
        bind Label <Control-p> {
            #clipboard clear
            clipboard append [%W cget -text]
        }
        bind Label <Control-q> {
            #clipboard exit
            clipboard append [%W exit]
        }
        linershell
        # end of initial deck
        # add cosmetics below to bottom of file
        # added statements above for math ops and TCLLIB library
        console show
        console eval {.console config -bg palegreen}
        console eval {.console config -font {fixed 20 bold}}
        console eval {wm geometry . 40x20}
        console eval {wm title . "  easy eye console, screen grab and paste from console 2 to texteditor"}
        console eval {. configure -background orange -highlightcolor brown -relief raised -border 30}
        console eval { proc self_helpx {} {
                set msg "in TCL, large black type on green
                from TCL,
                self help listing
                Conventional text editor formulas grabbed
                from internet screens can be pasted
                into green console
                # testbed  for one liner programs
                # loading math ops, TCLLIB components
                # suggest maintain dead spaces and air gaps near expr, brackets, etc
                # Note spaces near expr statement must be maintained 
                # or program deck will not work.
                # blanks _b must be there
                # namespaces liner and Foo_Bat
                # creating 4 new commands inside namespace liner
                # 1) > moves arguments to numerical display window
                # example > 1/9. ;
                # console transfer entries to numerical display window
                # should be dead space between > and entry
                # 1b) left mouse tap on numerical display window
                # evals numerical display window to console
                # 1c) tap in entry 1/9. on numerical display window
                # left mouse tap on numerical display window
                # left mouse tap to transfer eval to console pad
                # 1d) example transfer text to numerical display window
                # from green easy eye console  
                # > maintain dead spaces and air gaps
                # 2) example e> erase numerical display window                  
                # 3) q> conventional exit issued inside liner
                # example q> :# invokes exit and quits program
                # 4) exit>  conventional exit issued inside liner
                # example exit> :# invokes exit and quits program
                # example also bare exit on console quits program
                # > (2*3)+(3*3)
                # console transfer entries to numerical display window
                # should be dead space between > and entries
                # Start pseudocode tally
                # The  Foo_Bat has 1 sway_back + 2 tails+  3 heads
                # + 6 horns + 10 legs + 12 big_feet
                # The  Foo_Bat has 34 parts
                # console session >> thingy loads Foo_Bat into new namespace or corral
                #  thingy  creating 4 new commands inside Foo_Bat corral
                # 1)  Foo_Bat::> moves arguments to numerical window
                # 2)  Foo_Bat::q> conventional exit issued inside Foo_Bat corral
                # 3)  Foo_Bat::exit>  conventional exit issued inside Foo_Bat corral
                # 4)  Foo_Bat::e>  erase numerical display window
                # cmd  Foo_Bat::> \$Foo_Bat::big_feet moves obj to numerical display window
                # example <thingy  Foo_Bat>  creates namespace Foo_bat
                # example <Foo_Bat set tails 2> creates variable \$Foo_Bat::tails
                # example <Foo_Bat set heads 3> creates variable \$Foo_Bat::heads 
                # example <Foo_Bat set horns 6> creates variable \$Foo_Bat::horns 
                # example <Foo_Bat set big_feet 12> creates variable \$Foo_Bat::big_feet 
                # example <Foo_Bat Foo_Bat proc corral {x} {body} > creates  proc Foo_Bat::corral "
                tk_messageBox -title "self_helpxx" -message $msg } }
        console eval {.menubar.help add command -label Self_help -command self_helpx }
        puts "*******************************************************"
        puts " console session >>   thingy loads Foo_Bat into corral or namespace "
        puts "*******************************************************"
        proc thingy name { proc [uplevel 1 namespace current]::$name args "namespace eval $name \$args" } #   RS
        proc thingy2 name {interp alias {} $name {} namespace eval $name}  #    MS
        thingy  Foo_Bat
        # creating 4 new commands inside FooBat
        # 1) $Foo_Bat::> moves arguments to numerical display window
        # 2) $Foo_Bat::q> conventional exit issued inside Foo_Bat
        # 3) $Foo_Bat::exit>  conventional exit issued inside Foo_Bat
        # 4) $Foo_Bat::e>  erase numerical display window
        Foo_Bat proc > {args}  { global e;  set e $args}
        Foo_Bat proc q> {args} {exit}
        Foo_Bat proc exit> {args} {exit}
        Foo_Bat proc e> {args} { global e; set e ""}
        Foo_Bat set sway_back 1
        Foo_Bat set tails 2
        Foo_Bat set heads 3
        Foo_Bat set horns 6
        Foo_Bat set legs  10
        Foo_Bat set big_feet  12
        Foo_Bat proc corral {x} { expr { $Foo_Bat::sway_back + $Foo_Bat::tails +  $Foo_Bat::heads + $Foo_Bat::horns + $Foo_Bat::legs + $Foo_Bat::big_feet }}
        Foo_Bat::corral 1  #   returns 34
        puts "  Foo_Bat has $Foo_Bat::sway_back sway_back + $Foo_Bat::tails tails +  $Foo_Bat::heads heads + $Foo_Bat::horns horns + $Foo_Bat::legs legs + $Foo_Bat::big_feet big_feet"
        # The  Foo_Bat has 1 sway_back + 2 tails +  3 heads + 6 horns + 10 legs + 12 big_feet
        puts "  Foo_Bat has [ Foo_Bat::corral 1 ] parts "
        # The  Foo_Bat has 34 parts
        # end of  Foo_Bat thingy_OO code  
        # but still lurking inside console until session end
        puts "*******************************************************"
        puts " Foo_Bat(s) begin nesting here "
        puts "*******************************************************"
        Foo_Bat proc  thingy name {proc $name args "namespace eval $name \$args"} 
        Foo_Bat::thingy Baby_Foo_Bat 
        Foo_Bat::thingy Teenage_Foo_Bat
        Foo_Bat::thingy Doggie_Foo_Bat
        Foo_Bat::thingy Cat_Foo_Bat
        Foo_Bat::Baby_Foo_Bat proc pi {} {expr acos(-1)}
        Foo_Bat::Baby_Foo_Bat::pi
        puts " Foo_Bat::Baby_Foo_Bat::pi returns  [ Foo_Bat::Baby_Foo_Bat::pi ]  "
        puts "pi and thingy procs are both inside "
        puts " the nested namespace Foo_Bat::Baby_Foo_Bat"
        puts "*******************************************************"
        puts "    >>  Observe Caution  << "
        puts " Nesting Foo_Bats in Namespace Foo_Bat::Baby_Foo_Bat"
        puts "*******************************************************"
        Foo_Bat::Baby_Foo_Bat proc  thingy name {proc $name args "namespace eval $name \$args"} 
        puts "  commands present in Foo_Bat [info commands ::Foo_Bat::* ]  "
        proc ::Foo_Bat::Baby_Foo_Bat::pie {} {return  3.14159}
        puts "  commands present in Baby_Foo_Bat [info commands ::Foo_Bat::Baby_Foo_Bat::*]"

     source tiny_basic_RS.tcl
     basic { 10 n=2/7. : 20 print n} #   returns 0.2857
     basic { 10 n=[/ 2 7. ]: 20 print n} #   returns 0.2857
     basic { 10 n={2/ 7.}: 20 print n}: 20 print n}  #   returns 0.2857