collatz_sequence_head (27, 4 ) evals  27 82 41 124
collatz_sequence_head (27, 3 ) evals  27 82 41  
collatz_sequence_head (27, 2 ) evals  27 82  
collatz_sequence_head (27, 1 ) evals  27    , initial entry 
collatz_sequence_head (10, 3 ) evals  5 16 8 
collatz_sequence_tail (27, 4 ) evals 8 4 2 1
collatz_sequence_tail (27, 3 ) evals 4 2 1
collatz_sequence_tail (27, 2 ) evals  2 1
collatz_sequence_tail (27 , 1 ) evals   1, final entry
collatz_sequence_tail (10 , 3 ) evals  4 2 1   
collatz_sequence_tail (27, 4 ) evals 8 4 2 1
collatz_sequence_max_sequence_value (27)  evals  9232?
collatz_sequence_max_sequence_value (10)  evals  6
collatz_sequence_length (10)  evals 6
collatz_sequence_length (27)  evals 111?
collatz_sequence_generate  (10) evals  5 16 8 4 2 1 
collatz_sequence_generate  (27) evals 27 82 41 124 62 31 ....

Babylonian Sexagesimal Notation for Math on Clay Tablets in Console Example
Binomial Probability Slot Calculator Example
Biruni Estimate of Earth Diameter Slot Calculator eample
Chinese Fortune Casting Example Demo
Chinese Sun Stick Accuracy for Console Example
Command Line Calculator in Namespace Package Example
Crater Production Power Law Slot Calculator Example
Drake Intelligent Life Equation Slot Calculator Example
Easy Eye Calculator and eTCL Slot Calculator Demo Example, Numerical Analysis 
Ellipse Properties Slot Calculator Example
Fuel Cost Estimate Log Slot Calculator Example
Generic Calculator Namespace Package Example
Heat Engine Combustion and Calculator Demo Example
Human Language Root Words & Lexicostatistics Calculator and eTCL Slot Calculator Demo Example, numerical analysis
Mahjong_Style_Deletion
Oil Molecule Length Calculator and eTCL Slot Calculator Demo Example, numerical analysis
Oneliner's Pie in the Sky
Paper & Felt Rolls and eTCL Slot Calculator Demo Example
Penny Packing Calculator and eTCL Slot Calculator Demo Example, numerical analysis
Piece wise Profits and eTCL Slot Calculator Demo Example 
Planet Mass Calculator and eTCL Slot Calculator Demo Example, numerical analysis
Poker Probability and Calculator Demo Example
Random Walk Equation Slot Calculator Example
Rectangular Radio Antenna and etcl Slot Calculator Demo Example
Sanskrit Number Words Handling in Formulas and Demo Calculator Example
Sea Island Height Slot Calculator Example
Seaching for Babylonian Triplets Slot Calculator Example
Simple Reliability Slot Calculator Example
Slot_Calculator_Demo
Stonehenge Circle Accuracy Slot Calculator Example
Stratographic Years Slot Calculator Example, Age of Earth
Sumerian Equivalency Values, Ratios, and the Law of Proportions with Demo Example Calculator
Sumerian Beveled Bowl Volume and eTCL Slot Calculator Demo Example 
Sumerian Circular Segment Coefficients and Calculator Demo Example
Sumerian Coefficients at the Bitumen Works and eTCL Slot Calculator Demo Example edit
Sumerian Coefficients at the Weavers Factory and eTCL Slot Calculator Demo Example 
Sumerian Coefficients in the Pottery Factory and Calculator Demo Example
Sumerian Construction Rates and eTCL Slot Calculator Demo Example
Sumerian Paint & Bitumen Coating and eTCL Slot Calculator Demo Example 
Sumerian Population Density and eTCL Slot Calculator Demo Example 
Tonnage of Ancient Sumerian Ships and Slot Calculator Demo Example

Sumerian Pottery Vessel Mass Calculator, can not find in new wiki system
Babylonian Square rule for Trapezoid Area and eTCL demo example calculator, numerical analysis
Indian Math Bhaskara (1) Sine formula and extensions, history of math
Kahan compensated summation algorithm and Neumaier variant summation algorithm, numerical analysis
Sumerian Counting Boards, multiplication operation placement strategy, and eTCL demo example, numerical analysis
Babylonian Combined Work Norm Algorithm and eTCL Slot Calculator Demo Example, numerical analysis 
Stonehenge Circle Accuracy Slot Calculator Example
Drake Intelligent Life Equation Slot Calculator Example
Sumerian Equivalency Values, Ratios, and the Law of Proportions with Demo Example Calculator
Piece wise Profits and eTCL Slot Calculator Demo Example
Sumerian Sheep and Herd Animal Calculator and eTCL Slot Calculator Demo Example, numerical analysis
Electronic Failure Rate FITS and eTCL Slot Calculator Demo Example
Sumerian Seeding Rates and eTCL Slot Calculator Demo Example , numerical analysis 
Command Line Calculator in Namespace Package Example
Example Linear Interpolation Calculator
Sumerian Equivalency Values, Ratios, and the Law of Proportions with Demo Example Calculator
Sumerian Beveled Bowl Volume and eTCL Slot Calculator Demo Example 
Population Density Rectangular City Calculator and eTCL Slot Calculator Demo Example
Sales Optimal Lot Order Size and eTCL Slot Calculator Demo Example
Over-21 Game Shell and eTCL Slot Calculator Demo Example , numerical analysis
Sumerian Beer Ingredients and eTCL Slot Calculator Demo Example , numerical analysis
Easy Eye Calculator and eTCL Slot Calculator Demo Example, Numerical Analysis
Paper & Felt Rolls and eTCL Slot Calculator Demo Example
Human Language Root Words & Lexicostatistics Calculator and eTCL Slot Calculator Demo Example, numerical analysis
Sumerian Workday Time & Account Calculator and eTCL Slot Calculator Demo Example, numerical analysis 
Old Babylonian Interest Rates and eTCL demo example calculator
Capsule Surface Area & Volume and eTCL demo example calculator
Babylonian Square rule for Trapezoid Area and eTCL demo example calculator, numerical analysis
Sumerian Coefficients at the Weavers Factory and eTCL Slot Calculator Demo Example
Sumerian Population Density and eTCL Slot Calculator Demo Example

  listPrimePairs 
  listPrimeProgressions

TCLLIB ticket 5af6381a8be0d5a87505d7e28203fe69fa2b3019 in que, dated 7/3/2021
Title:        Quadratic Equation Solution, 2 reals from Muller's method

                # pseudocode on Babylonian triplets
                2m, m**2 - 1, m**2 + 1  Babylonian triplet
                twin prime number.
                twin prime numbers separated by 2,4,6 ...?
                c**2= a**2 + b**2
                c**2= a**2 + 1        normalized Babylonian triplet
                a**2  = c**2 -1       normalized Babylonian triplet
                some b and c are both primes.
                some b and c are not both primes.
                The reciprocal pair relationship.
                (X+1/X)**2 - (X+1/X)**2 = 4  ,    divide equation by 4 
                normalized triplet, < (1/4)* ((X+1/X)**2 ) , 1 ,(1/4)* ((X+1/X)**2) >
                0 < X-1/X < 2
                1< X-1/X < 1+sqrt(2)     ~~ approximate limit of 2.4 
                The Babylonian regular numbers between 0 and 60 have a limited set of triplets that
                satisfy 1< X-1/X < 1+sqrt(2) which appears to be the role of Plimpton 322.
                The limit 1< X-1/X < 1+sqrt(2) may explain the 1<X<2 limit on the Late  Babylonian
                many place reciprocal tablets.
                d=6 even number, l = divisor of d**2 with integer result, Babylonian triplet method
                a=l+b
                b= d+ (d**2)//(2*l)
                c= d+l+(d**2)/(2*l)
                # supposed to work for all even d

                # Pretty print version from autoindent
                # and ased editor
                # Possible Bias of base 2 and 3 in near field?
                # written on Windows 10 on TCL
                # working under TCL version 8.6
                #   on TCL Club , 18aug2020
                # relative frequency of indiv. "throw" over all "throws".
                # pi mantissa used here
                # proc base and frombase by RS
                package require Tk
                console show
                # proc base by RS
                proc base {base number} {
                    set negative [regexp ^-(.+) $number -> number] ;# (1)
                    set digits {0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N
                        O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p
                        q r s t u v w x y z}
                    set res {}
                    while {$number} {
                        set digit [expr {$number % $base}]
                        set res [lindex $digits $digit]$res
                        set number [expr {$number / $base}]
                    }
                    if $negative {set res -$res}
                    set res
                }
                  # proc base by RS
                proc frombase {base number} {
                    set digits {0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N
                        O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p
                        q r s t u v w x y z}
                    set negative [regexp ^-(.+) $number -> number]
                    set res 0
                    foreach digit [split $number ""] {
                        set decimalvalue [lsearch $digits $digit]
                        if {$decimalvalue<0 || $decimalvalue >= $base} {
                            error "bad digit $decimalvalue for base $base"
                        }
                        set res [expr {$res*$base + $decimalvalue}]
                    }
                    if $negative {set res -$res}
                    set res
                }
                proc calculation {  facen }  {
                    # prob. subroutines for mimic sequence of bronze
                    # prob. is throw combos of eg. "7" over all possible throws
                    # set lister [split {14159265358979323846} ""] 
                    # in base 3        10111100001122100002122202221020002210001 
                    # in base 2  1100010001111111110100001101001100110010011101001101011111000110 
                    set target [ base 3 14159265358979323846 ]
                    set lister [split { 1100010001111111110100001101001100110010011101001101011111000110  } ""]                   
                    set ee [llength  $lister ]
                    set kk [ llength [ lsearch -all $lister $facen ] ]
                    set prob [ expr { ($kk*1.) / $ee  } ]
                    return $prob
                }
                set limit 12
                puts "%|table| printed in|TCL format |% "
                puts "&| quantity| value| comment, if any|& "
                for { set i 0 } { $i <= $limit }  { incr i } {
                    lappend listxxx $i
                    lappend listxxx [ calculation  $i ]
                    puts " &| $i | [ calculation  $i ] |  |&"
                }
                #end
               puts " [ base 2 14159265358979323846 ] "

        # adapted from tcl-wiki Stats 2011-05-22, arithmetic mean  [RLE]
        #
        # ::math::quantity_into_ratios --
        #
        # Return the division of quantity by  two or more given ratios
        #
        # Arguments:
        #    val  first value is quantity
        #    args other values are two or more given ratios
        #
        # Results: parts of quantity divided  by ratios
        #
        proc ::math::quantity_into_ratios {quantity args} {
            set sum 0.
            set N [ expr { [ llength $args ] + 1 } ]
            if { $N == 1  } { return 0 }
            foreach val $args {
                set sum [ expr { $sum + $val } ]
            }
            foreach val $args {
                lappend answer [ expr { $quantity * ($val/$sum) } ]
            }
            set answer
        }
        #puts "  ::math::quantity_into_ratios ( 84 2 2 2  )  answer 12.0 24.0 48.0    "
        #puts " [ ::math::quantity_into_ratios 84 1 2 4  ]  "
        #puts " [ ::math::quantity_into_ratios 84 ] for (::math::quantity_into_ratios 84) returns zero "

        # adapted from tcl-wiki Stats 2011-05-22, arithmetic mean  [RLE]
        #
        #  sqrt_sum_of_squares --
        #
        # Return the sqrt_sum_of_squares by  one or more
        #
        # Arguments:
        #
        #    args other values are one or more
        #
        # Results: sqrt_sum_of_squares
        #
        proc sqrt_sum_of_squares { args} {
            set sum 0.
            set N [ expr { [ llength $args ] + 1 } ]
            if { $N == 1  } { return 0 }
            foreach val $args {
                set sum [ expr { $sum + $val*$val } ]
            }
            set answer [ expr { sqrt($sum) } ]
        }
        #puts "  ::math::sqrt_sum_of_squares (  2 2 2  )  answer [sqrt 12 ]
        #  3.4641016151377544
        #puts " [ ::math::sqrt_sum_of_squares   1 2 4  ]  "
        #puts " [ ::math::sqrt_sum_of_squares 2 ] for ( ) returns zero "
        console show
        console eval {.console config -bg palegreen}
        console eval {.console config -font {fixed 20 bold}}
        console eval {wm geometry . 40x20}
        puts "  sqrt_sum_of_squares  2 2 2 equals [ sqrt_sum_of_squares  2 2 2 ]"
        puts "  sqrt_sum_of_squares  1 1 1 equals [ sqrt_sum_of_squares  1 1 1 ]"
        puts "  sqrt_sum_of_squares  1 1  equals [ sqrt_sum_of_squares  1 1  ]"
        puts "  sqrt_sum_of_squares  1  equals [ sqrt_sum_of_squares  1  ]"
        puts "  sqrt_sum_of_squares  0  equals [ sqrt_sum_of_squares  0  ]"

  sqrt_sum_of_squares  2 2 2 equals 3.4641016151377544
  sqrt_sum_of_squares  1 1 1 equals 1.7320508075688772
  sqrt_sum_of_squares  1 1  equals 1.4142135623730951
  sqrt_sum_of_squares  1  equals 1.0
  sqrt_sum_of_squares  0  equals 0.0

        # coro_discrete_events.tcl --
        #     Experiment with SIMULA/DEMOS like modelling - using coroutines
        # from Discrete event modelling with coroutines
        # Author : Arjen Markus (21 april 2009) 
        # Discrete event modelling is a way of modelling all manner of systems
        package require Tcl 8.6
        # acquire --
        #     Acquire resources and wait if that does not succeed
        #
        # Arguments:
        #     name        Name of the resource
        #     amount      Amount to acquire
        #
        # Returns:
        #     None
        #
        # start modifications 
            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 tclprecision 17
            console show
            # following dresses up console output to easy eye
            console eval {.console config -bg palegreen}
            console eval {.console config -font {fixed 20 bold}}
            console eval {wm geometry . 40x20}
            console eval {.console config -background palegreen -highlightcolor tan -relief raised -border 30 }
            # changes: shifted text, removed empty lines, added easy eye console to deck.
            # changes: ran text through autoindent of ASED  TCL editor
        # end modifications
        proc acquire {name amount} {
            upvar 1  objectID ID
            upvar #0 $name resource_name
            puts "Acquiring $amount of $name for $ID ..."
            if { $resource_name >= $amount } {
                set resource_name [expr {$resource_name - $amount}]
            } else {
                puts "Waiting for $name -- $ID"
                while {1} {
                    set ::queue($name) [linsert $::queue($name) 0 $ID]
                    yield [list acquire $name $ID]
                    puts "Checking $name ..."
                    if { $resource_name >= $amount } {
                        set resource_name [expr {$resource_name - $amount}]
                        break
                    }
                    puts "Wait again - $name - $resource_name -- $amount ..."
                }
            }
            puts "Acquired $amount of $name for $ID"
        }
        # release --
        #     Release resources
        #
        # Arguments:
        #     name        Name of the resource
        #     amount      Amount to release
        #
        # Returns:
        #     None
        #
        proc release {name amount} {
            upvar 1  objectID ID
            upvar #0 $name resource_name
            set resource_name [expr {$resource_name + $amount}]
            puts "Releasing $amount of $name for $ID"
            if { [llength $::queue($name)] != 0 } {
                set hid   [lindex $::queue($name) 0]
                set ::queue($name) [lrange $::queue($name) 1 end]
                set ::events [linsert $::events 0 [list $hid acquire 0.0]]
            }
            puts "Released $amount of $name for $ID"
        }
        # resource --
        #     Create a named resource
        #
        # Arguments:
        #     name        Name of the resource
        #     amount      Amount to create
        #
        # Returns:
        #     None
        #
        proc resource {name amount} {
            upvar #0 $name resource_name
            set resource_name $amount
            set ::queue($name) {}
        }
        # hold --
        #     Advance the time for the given object in the simulation
        #
        # Arguments:
        #     delay       Time to advance
        #
        # Returns:
        #     None
        #
        proc hold {delay} {
            upvar 1 objectID object
            lappend ::events [list $object "hold" [expr {$::time+$delay}]]
            puts "Holding for $delay seconds ... $object"
            yield
            puts "Done"
        }
        # object --
        #     Create an object and schedule it's coming alive
        #
        # Arguments:
        #     procedure      Name of the procedure holding the life cycle
        #     time           Time at which it comes alive
        #
        # Returns:
        #     Structure representing the object
        #
        proc object {procedure time} {
            set obj [list $procedure $::objectno]
            lappend ::events [list $obj "init" $time]
            incr ::objectno
            return $obj
        }
        # handleEvents --
        #     Handle the events that were scheduled
        #
        # Arguments:
        #     None
        #
        # Returns:
        #     None
        #
        proc handleEvents {} {
            global time
            global events
            while { [llength $events] > 0 } {
                set count 0
                set found 0
                foreach event $events {
                    foreach {obj type eventTime} $event {break}
                    if { $eventTime <= $time } {
                        set events [lreplace $events $count $count]
                        set found  1
                        break
                    }
                    incr count
                }
                if { ! $found } {
                    foreach {obj type eventTime} [lindex $events 0] {break}
                    set events [lrange $events 1 end]
                }
                if { $time < $eventTime } {
                    set time $eventTime
                }
                if { $type == "init" } {
                    coroutine [lindex $obj 1] {*}$obj
                }
                if { $type == "hold" } {
                    puts "Releasing hold: $obj"
                    $obj
                }
                if { $type == "acquire" } {
                    puts "Continue acquiring: $obj"
                    $obj
                }
            }
        }
        # startSimulation --
        #     Start the simulation
        #
        # Arguments:
        #     None
        #
        # Returns:
        #     None
        #
        proc startSimulation {} {
            if { [llength $::events] == 0 } {
                return
            } else {
                handleEvents
            }
        }
        # boat --
        #     Simulate a boat that requires several tugs to get into the harbour
        #
        # Arguments:
        #     objectID             ID of the object (required name!)
        #
        # Returns:
        #     None
        #
        proc boat {objectID} {
            acquire tugs 2
            hold 10
            release tugs 2
        }
        # main --
        #     Simulate two objects that need the same resources
        #
        # Initialise simulation system
        set objectno 0
        set time   0.0
        set events {}
        # The simulation itself
        resource tugs 3
        set b1 [object boat 1.0]
        set b2 [object boat 4.0]
        startSimulation

        # 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        

      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.            

# start advice file.
AMG: The return value of a Tcl procedure is inherited from the return value of the last command to execute within that procedure. Therefore, many uses of the [return] command are redundant. For example, this procedure:

proc anglecosa {a b c} {return [expr {($b*$b+$c*$c-$a*$a)/(2.*$b*$c)}]}
can be written more simply:

proc anglecosa {a b c} {expr {($b*$b+$c*$c-$a*$a)/(2.*$b*$c)}}
Also, the conditional arguments to [if], [while], [for] are already expr-essions, so there's no need to nest a call to [expr]. For example,

proc emmy2 {} {if {[expr {rand()}] <= 0.9} {return 1}}
can be simplified quite a lot:

proc emmy2 {} {if {rand() <= 0.9} {return 1}}
#end of advice file

        # TCL source code follows
        # ASED autoindent applied
        # Trial Console Program  brackets and quotes.
        # written on Windows XP on TCL
        # working under TCL version 8.6
        # gold on TCL Club, 12Dec2018
        console show
        puts " result value is [expr { 1+3} ] ";
        puts [expr { 1+3} ];
        # creating list
        set lister1 [ list  dog cat lizard ] ;
        puts $lister1;
        set lister2 {" dog cat lizard" };
        puts $lister2;
        #  $lister2 is really a string of 3 items
        # but some list coomands lappend and lindex may
        # interpret $lister2 as list
        set lister3 {" dog cat”  lizard };
        puts $lister3;
        set lister4 " dog cat lizard" ;
        $lister4;
        # note outputs are similar
        # for $lister1 and $lister4
        # gold on TCL Club, 12Dec2018
           

      # The easy way is to start with proper list command
      set list_fruit [ list apple pear orange grape ]
      lappend $list_fruit peach
      # The hard way is to start with individual strings of characters
      set a1 apple
      set a2 pear 
      set a3 orange
      set a4 grape
      set a5 peach
      set list_fruit_assembly [ list $a1 $a2 $a3 $a4 ]  
      lappend list_fruit_assembly $a5   
      # begin code for TCL wiki table format 
      proc wiki_table_format  { start finish  } {
      # TCL wiki table format  
      # set numers in TCL wiki table format  
      # use equivalent TCL procedure all the time for tables in wikis            
      set first $start 
      set last $finish
      set list_numbers [ list &| ]
      while {$first < $last } {
      lappend list_numbers entry No. $first =  $first |
      incr first
      } 
      lappend list_numbers comments  |&
      puts  $list_numbers
      # &| entry No. 1 = 1 | entry No. 2 = 2 | entry No. 3 = 3 | entry No. 4 = 4 | entry No. 5 = 5 | entry No. 6 = 6 | entry No. 7 = 7 | entry No. 8 = 8 | entry No. 9 = 9 | comments |& }
       wiki_table_format   1 10  
      # &| 8191 24574 12287 36862 :|  collatz_sequence_head   : |  | |& /
      &| 8 4 2 1 :|  collatz_sequence_tail :  |  | |& /
      &| 159 :|  collatz_sequence_length: |  | |&

      proc near_above_power_of_2x  num {set pow 1; while {$pow<$num} {set pow [expr { $pow*2} ]}; return $pow}
      proc near_above_power_of_2  num {set pow 1; while {$pow<$num} {set pow [expr { $pow*2} ]}; return $pow}
      proc ld x "expr {log(\$x)/[expr log(2)]}" ;# RS
            [pow 2 [+ [int 2.8] 1]]= "8.0"
      proc zap x "[pow 2 [+ 1 [expr {log(\$x)/[expr log(2)]}]"
      proc zap x "pow 2 [+ [int 2.8] 1]"

        #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
        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 26
        # ::tcl::mathfunc::isqrt 26  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 ]"

   proc pi {} {expr {acos(-1)}}  #from AMG see below
   proc degtoradiansconst {} {return [ expr {180./[pi]}  ]}
   proc degz {} {return [ expr {180./[pi]}  ]}
   proc degx {aa} {return [ expr { [degz]*acos($aa) }  ]}
   proc inrad {a b c} {return  [expr {(sqrt(($a+$b+$c)*($a+$b-$c)*($a-$b+$c)*($b+$c-$a)))/(2.*($a+$b+$c)) } ] }
   proc circlediameter {radius} { return [ expr { 2.* $radius } ] }
   proc circlearea {radius} { return  [  expr { [pi]*($radius**2) }]}
   proc circlecircumference   {radius} {return [ expr {2.*[pi]*$radius }]}
   proc spherediameter  {radius}  {return  [ expr { 2.* $radius }]}
   proc spherevolume   {radius}  { return [ expr { (4./3.)*[pi]*($radius**3) }]}
   proc spheresurface    {radius} { return [ expr { 4.*[pi]*($radius**3) }]}
   proc cubevolume {aa}  { return [ expr { 1.*$aa*$aa*$aa } ] }
   proc squarearea  {aa}  { return [ expr { 1.*$aa*$aa } ] }
   proc ellipsoidvolume {aa bb cc} { return [ expr { 1.*(4./3.)*[pi]*$aa*$bb*$cc } ] }
   proc ellipsearea1 { aa bb } {return [ 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  } { return [ expr { 1.*(4./3.)*[pi]*$aa*$aa*$aa } ] }
   proc spheroidvolumex {aa cc } { return [ expr { 1.*(4./3.)*[pi]*$aa*$aa*$cc } ] }
   proc torusvolumex {aa bb }  { return [ expr {(1./4.)  *[pi]*[pi] * ($aa + $bb) * ($aa - $bb)*2.}] }
   proc torussurfacex {aa bb }  { return [ expr { [pi]*[pi] *  ($aa*$aa - $bb*$bb) }] } 
   proc conesurfacex {aa rr }  { return [ expr { [pi]*$rr*$aa}] }
   proc cylindersurfacesidex {aa rr }  { return [ expr {2.* [pi]*$rr*$aa}] }   
   proc cylinderwholesurfacesidex {aa rr }  { return [ expr {2.* [pi]*$rr*$aa +2.*[pi]*$rr*$rr}] }   
   proc cylindervolumesidex {aa rr }  { return [ expr { [pi]*$rr*$rr*$aa}] } 
   proc conevolumex {aa rr }  { return [ expr { (1./3.)*[pi]*$rr*$rr*$aa}] } 
   proc pyramidvolumex {aa bb cc }  { return [ expr { (1./3.)*$aa*$bb*$cc  }] } 
   proc rectangularprismvolumex {aa bb cc }  { return [ expr { $aa*$bb*$cc  }] } 
   proc triangularprismvolumex {aa bb cc }  { return [ expr { $aa*$bb*$cc*.5  }] } 
   proc polygonperimeterx {aa bb }  { return [ expr { $aa*$bb}] } 
   proc rectangleperimeterx {aa bb }  { return [ expr {2.*( $aa+$bb)}] } 
   proc parallelogramperimeterx {aa bb }  { return [ expr {2.*( $aa+$bb)}] } 
   proc triangleperimeterx {aa bb cc}  { return [ expr { $aa+$bb+$cc }] } 
   proc triangletrapezoidx {aa bb cc}  { return [ 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 } {return [ expr {  ($bb*$bb+$cc*$cc-$aa*$aa)/(2.*$bb*$cc) }]}
   proc anglecosb { aa bb cc }  {return [ expr {  ($cc*$cc+$aa*$aa-$bb*$bb)/(2.*$aa*$cc) }]}
   proc anglecosc { aa bb cc } { return [ 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 returns  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] ] ]]}

        # Sample of TCL One Liner Procedures  V2
        # written on Windows 10 on TCL 8.6
        # working under TCL version 8.6
        # gold on TCL Club , 9/20/2020
        # Ref. WIKI BOOKS, Tcl_Programming_Introduction pdf
        # Book Section  contrasts one liners procedures
        # versus  traditional procedural  approach.
        # Below contains redundant One Liner procedures
        # to contrast alternate techniques and constructs
        # start modifications
        package require Tcl 8.6
        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 tclprecision 17
        console show
        # following dresses up console output to easy eye
        console eval {.console config -bg palegreen}
        console eval {.console config -font {fixed 20 bold}}
        console eval {wm geometry . 40x20}
        puts "Admiral begins operations "
        # changes: shifted text, removed empty lines, added easy eye console to deck.
        # end modifications
        console show
        console eval {.console config -bg palegreen}
        console eval {.console config -font {fixed 20 bold}}
        console eval {wm geometry . 40x20}
        namespace path {::tcl::mathop ::tcl::mathfunc}
        # contains redundant procs for testing one liner procedures V2
        proc pi {} {expr {acos(-1)}}
        # 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
        # maturity value of loan using TCL 8.6 math ops, 10Sep2020
        # similar formula for time in days divide years by 360.
        # similar formula for interest rate in percent, divide interest by 100.
        # should work with any currency and just use consistent units.
        # maintain isolating spaces in TCL math ops
        proc maturity_value_loan { principal interest years} { [*  $principal  [+ 1. [* 1. $interest $years ]]] }
        # Usage  maturity_value_loan 100. .05 1. returns 105.
        proc maturity_value_loan_percent { principal percent_i years} { [*  $principal  [+ 1. [* 1. [/  $percent_i 100.]  $years ]]] }
        # Usage  maturity_value_loan_percent 100. 5. 1. returns 105.
        proc maturity_value_loan_days { principal interest days} { [*  $principal  [+ 1. [* 1. $interest [/ $days 360. ]]]] }
        # Usage  maturity_value_loan_days 100. .05 360. returns 105.
        # following proc session invoke TCLLIB math::trig library
        proc pyramid_d {hh bb} { [ acotand [expr (.5*$bb/$hh) ]] }
        proc pyra_d {hh bb} { [ acotand [* .5 [/ $bb $hh] ]] }
        # Usage pyramid_degrees 57.692 106.346 answer 47.334157521261254
        # hh is height of pyramid, units cancel out
        # bb is base length of pyramid
        # seked = (7 * .5 * 360 cubits) / 250 cubits = 5.04 decimal palms
        proc seked_d {hh bb} { [/ [* 7. .5 $bb ] $hh ] }
        # usage seked_d 250. 360. equals 5.04
        # end TCLLIB
        # hbA1c_convert_to_average_blood_glucose mg/dl  HbA1c
        proc a1c hbA1c {  expr { 35.6*$hbA1c -77.3} }
        # convert mg/dl to mmol/L average 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 } }
        # *************************************8
        #  mean_speed_1 is defined as apparent velocity
        # of Jupiter along Zodiac in degrees per day
        # mean_speed_1 = [ expr { .5 * (velocity_1 - velocity_0 )} ]
        proc mean_speed_1 {velocity_1  velocity_0} {  expr { .5 * ($velocity_1 - $velocity_0 )}   }
        # Usage  mean_speed_1 1.5 .5 for 1.5 and 0.5 speeds in degrees per day returns 1. 
        # *******************************
        # adding_two_fractions aa/bb + cc/dd = 
        # ((aa *dd*1.))+(bb*cc*1.))/(bb*dd*1.),
        # but must insert 1. factor to return real numbers in TCL math ops
        proc adding_two_fractions { aa bb cc dd } {  [/ [+  [*  $aa $dd 1. ]  [* $bb $cc 1. ]] [* $bb $dd 1.] ] }
        # suggest maintain spaces in math ops
        # Usage adding_two_fractions 1.0 1.0 1.0 1.0 returns   2.0
        # Usage adding_two_fractions 1 1 1 1  returns   2.0
        # Usage adding_two_fractions 1. 2. 1. 2. returns   1.0 
        # subtracting_two_fractions aa/bb - cc/dd = 
        # ((aa *dd*1.))-(bb*cc*1.))/(bb*dd*1.),
        # but must insert 1. factor to return real numbers in TCL math ops
        proc subtracting_two_fractions { aa bb cc dd } {  [/ [-  [*  $aa $dd 1. ]  [* $bb $cc 1. ]] [* $bb $dd 1.] ] }
        # subtracting_two_fractions 1. 2. 1. 4. returns 0.25
        # subtracting_two_fractions 1. 1. 1. 1. returns 0.0
        # subtracting_two_fractions 1 1 1 1 returns 0.0
        # multiplying_two_fractions  
         proc multiplying_two_fractions { aa bb cc dd } { [/  [* $aa $cc 1. ]   [* $bb $dd 1. ] ] }
        # multiplying_two_fractions 1. 2. 1. 2. returns  0.25
        # multiplying_two_fractions 1. 1. 1. 1. returns 1,0 
        # multiplying_two_fractions 1 1 1 1 returns  1.0
        # dividing_two_fractions
        # but must insert 1. factor to return real numbers in TCL math ops
        proc dividing_two_fractions { aa bb cc dd } { [/  [* $aa $dd 1. ]   [* $bb $cc 1. ] ] }
        # dividing_two_fractions 1. 1. 1. 2. returns 2.  
        # dividing_two_fractions 1. 1. 1. 1. returns 1.0 
        # dividing_two_fractions 1 1 1 1 returns 1.0 
        # ********************************
        proc bodes_law_1  { nn } {  return [+ 0.4 [* 0.3 [pow 2 $nn]]] }
        # Usage bodes_law_1 1 returns   1.0 Astronomical units for planet Earth
        # Usage bodes_law_1 2 returns   0.7 AU for planet Venus
        # Usage bodes_law_1 3 returns   1.6 AU for planet Mars
        proc bodes_law_2 {} { foreach nn {0 1 2 3 4 5 6 7} { lappend planets [+ 0.4 [* 0.3 [pow 2 $nn]]]};return $planets}
        # Usage  bodes_law_2  returns  list  0.7 1.0 1.6 2.8 5.2 10.0 19.59 38.8 
        puts " out  " 

    # pretty print from autoindent and ased editor
    # One Liners Procedures V2
    # written on Windows 10 on  TCL
    # working under TCL version 8.6
    # gold on TCL Club , 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 }
    set tclprecision 17
    # following dresses up console output to easy eye
    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 . " One Liners Report , screen grab and paste from console 2 to texteditor"}
    console eval {. configure -background orange -highlightcolor brown -relief raised -border 30}
    # blank table addition
    puts "%|table |printed in| tcl wiki format|% "
    puts "&| quantity| value| comment, if any|& "
    puts "&| testcase number:|   |&"
    puts "&| value  |quantity 1 |   |&"
    proc pi {} {expr {acos(-1)}}
    # proc pi from AMG see below
    # ******surface and area calculations ******
    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
    # *****    simple interest  section *******
    # maturity value of loan using TCL 8.6 math ops, 10Sep2020
    # similar formula for time in days divide years by 360.
    # similar formula for interest rate in percent, divide interest by 100.
    # should work with any currency and just use consistent units.
    # maintain isolating spaces in TCL math ops
    proc maturity_value_loan { principal interest years} { [*  $principal  [+ 1. [* 1. $interest $years ]]] }
    # Usage  maturity_value_loan 100. .05 1. returns 105.
    proc maturity_value_loan_percent { principal percent_i years} { [*  $principal  [+ 1. [* 1. [/  $percent_i 100.]  $years ]]] }
    # Usage  maturity_value_loan_percent 100. 5. 1. returns 105.
    proc maturity_value_loan_days { principal interest days} { [*  $principal  [+ 1. [* 1. $interest [/ $days 360. ]]]] }
    # Usage  maturity_value_loan_days 100. .05 360. returns 105.
    # ****** relative error in percent *****************************************
    #  error in percent is  < attested value>  over <calculated value>  times 100.  percent.
    #  for relative error without percent,  
    #  < attested value>  over <calculated value>  times 1.0
    #  for relative error without percent,  swap factor 100.0  to 1.0
    proc percent_errorx  {aa bb} {   expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*100. : (($bb*1.)/$aa -1.)*100.}}
    # Effectively  percent_errorx is returning an absolute value of error in percent
    # Usage percent_errorx  1.2 1.0  returns 19.99 percent
    # Usage percent_errorx   1.0 1.2  returns 19.99 percent
    # Usage percent_errorx   1.5 1.0  returns  50.0 percent
    proc error_relative  {aa bb} {   expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*1. : (($bb*1.)/$aa -1.)*1.}}
    proc error_relative  {aa bb} {   expr { $aa > $bb ?   (($aa*1.)/$bb -1.)*1. : (($bb*1.)/$aa -1.)*1.}}
    # Usage error_relative  1.2 1.0  returns 0.199
    # Usage error_relative  1.0 1.2  returns 0.199
    # Usage error_relative  1.5 1.0  returns 0.50
    puts " out  "

    # 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

WIKI BOOKS,  Programming_Examples pdf
WIKI BOOKS, Tcl_Programming_Introduction pdf
license https://creativecommons.org/licenses/by-sa/3.0/legalcode
creativecommons.org/licenses/by-sa/3.0/
en.wikibooks.org/wiki/Tcl_Programming_Introduction
Sample Math Programs, item 2, RS
TCLLIB math::mean is quicker by a third over some homebrew code.
Additional math functions
https://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix-That-is-what-is-your-favorite-one-liner-command-that-handles-a-task-usually-delegated-to-a-much-more-verbose-program-written-in-a-high-level-language
http://www.codecodex.com/wiki
SOURCE CODE SEARCH ENGINES, INCLUDE TCL????
Google Code Search
Koders
Krugle
Google Code Search
Koders
Krugle
Protecode
REFERENCES
http://www.codecodex.com/wiki
https://www.openhub.net/p?ref=homepage&query=tcl
https://en.wikipedia.org/wiki/Portal:Computer_programming
https://en.wikipedia.org/wiki/Portal:Free_and_open-source_software
https://en.wikipedia.org/wiki/Protecode
https://en.wikipedia.org/wiki/List_of_search_engines#Source_code
https://blog.robertelder.org/don-libes-expect-unix-automation-tool/

    # conventional expr math operation
    # factor 1. forces expression to floating point
    proc commission { commission sales }   {expr {1.* $commission  * $sales}}
    # Usage  commission   .10 100. returns 10.0
    # Using math operations notation for speed
    proc commission_2 { commission sales }   {*  1.  $commission  $sales }
    # Usage commission_2  .1 100   returns 10.0
    # *******************************   
    # commission_rate = commission over sales
    set commission_rate {expr {1.*$commission / $sales}}
    # conventional expr math operation
    proc commission_rate { commission sales } {expr {1.* $commission  / $sales}}
    #  using math operations notation
    proc commission_rate_2 { commission sales } [/ [* 1. $commission ]  $sales ]
    proc commission_rate_2  100. 10.
    proc commission_sales_2 { commission sales }   {expr {1.* $commission   *$sales}}

        # pretty print from autoindent and ased editor
        # Parametric Model Vaporware   V2
        # written on Windows 10 on TCL
        # working under TCL version 8.6
        # gold on  TCL Club, 4Oct2020
        # charting based on rotated ellipse by Gerard Sookahet
        # gold added push buttons calculatorand housekeeping 
        # using dummy calculations for parametric eq. calc.    
        package require Tk
        package require math::numtheory
        # added statements for TCLLIB library
        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 }
        # Tried to keep clean GS  code in upper section
        set tcl_precision 17
        proc pie {} {expr acos(-1)} ;# AMG
        # Section EllipseRotate.tcl 
        # Section proc EllipseRotate Author:      Gerard Sookahet
        # Date:        09 March 2019
        # Version:     0.1
        # Description: Simple graphical example of parametric equation of rotated ellipse
        #
        # xo,yo : center of the ellipse
        # angle : rotation angle from 0 to 7 with the scalebar
        # a : major radius
        # b : minor radius
        # t : parameter
        bind all <Escape> {exit}
        # Section proc Author:      Gerard Sookahet
        proc EllipseRotate {xo yo a b angle t} {
            global side1 side2 side3 side4 side5
            global side6 side7 side8
            set cosa [expr {cos($angle)}]
            set sina [expr {sin($angle)}]
            set cost [expr {cos($t)}]
            set sint [expr {sin($t)}]
            set x [expr {$xo + $a*$cosa*$cost - $b*$sina*$sint}]
            set y [expr {$yo + $a*$sina*$cost + $b*$cosa*$sint}]
            return [list $x $y]
        }
        proc EllipsePlot {w xo yo a b pi angle} {
            $w delete all
            lassign [EllipseRotate $xo $yo $a $b $angle 0] x2 y2
            for {set p 0} {$p <= 720} {incr p} {
                set t [expr {$pi*$p/360}]
                lassign [EllipseRotate $xo $yo $a $b $angle $t] x1 y1
                .c create line $x1 $y1 $x2 $y2 -fill blue -width 3
                set x2 $x1
                set y2 $y1
            }
        }
        # fallback settings
        #set width 600
        #set height 400
        set width 800
        set height 500
        set pi 3.1415926
        set xo [expr {$width/2}]
        set yo [expr {$height/2}]
        set a 200
        set b 100
        set angle [expr {$pi/6}]
        #pack [canvas .c -width $width -height $height -background black]
        #pack [scale .sc -from 0 -to 7 -length 240 -resolution .1 \
                -orient horiz -bd 1 -showvalue true -variable angle \
                -command {EllipsePlot .c $::xo $::yo $::a $::b $::pi}]
        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 {{} {parameter 1:} }
        lappend names {parameter 2:}
        lappend names {parameter 3:}
        lappend names {parameter 4:}
        lappend names {parameter 5:}
        lappend names {parameter 6:}
        lappend names {parameter 7:}
        lappend names {parameter 8:}
        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 Parametric Model Vaporware   V2
            from TCL ,
            # gold on  TCL Club, 10Jul2020 "
            tk_messageBox -title "About" -message $msg }
        proc self_help {} {
            set msg "Calculator for Parametric Model Vaporware V2
            from TCL ,
            # self help listing
            # 4 givens follow.
            1) parameter 1:
            2) parameter 1:
            3) parameter 1: 
            4) parameter 1:            
            # Recommended procedure is push testcase and fill frame,
            # change first three entries etc, push solve,
            # and then push report. Report allows copy and paste
            # from console to conventional texteditor. For testcases
            # testcase number is internal to the calculator and
            # will not be printed until the report button is pushed
            # for the current result numbers.
            # This posting, screenshots, and TCL source code is
            # copyrighted under the TCL/TK 8.6 license terms.
            # Editorial rights retained under the TCL/TK license terms
            # and will be defended as necessary in court.
            # gold on  TCL Club, 2Oct2020 "
            tk_messageBox -title "About" -message $msg }
        #  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
        # 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>
        proc table_calc {value} {
        # computer drag time sensitive on limit variable
        set limit 3
        # should apply to at my parametric model
        # a list of values (w_list) with cycle for.
        # In each step the code must set 3 coefficients (k1,k2,k3)
        # copy original format internet query
        set w_list [list  0.12   0.14   0.16   0.18   0.20 ];
        set k1_list [list {1.080} {1.101} {1.123} {1.144} {1.166}];
        set k2_list [list {1.116} {1.213} {1.260} {1.309} {1.360}];
        set k3_list [list {1.915} {2.157} {2.402} {2.649} {2.898}];
        # gold does not use braces around list elements, left as original 
        # copy of original format in internet query
        # setting table of dummy calculations
        # with data supplied in internet query
        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 } {
            # may leave redundant or fallback statements in draft program
            # set lister { 1 2 4 5 6 7 8 9 10 }
            set lister { 0.12   0.14   0.16   0.18   0.20 }
            lappend lister  [* $i [pie]]
            puts "&|$i | mean_1   [ mean_1  $lister ]| $lister |  $k1_list |   [ mean_1  $k1_list ]  |&"
            puts "&|$i | mean_2   [ mean_2  $lister ]| $lister |  $k2_list |   [ mean_2  $k2_list ]  |&"
            puts "&|$i | mean_3   [ mean_3  $lister ]| $lister |  $k2_list |   [ mean_3  $k3_list ]  |&"
        }}
        proc calculate {     } {
            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 side5 1.
            set side6 1.
            set side7 1.
            set side8 1.
            table_calc 1
            set w_list [list  0.12   0.14   0.16   0.18   0.20 ] 
            set velocity_0 $side1
            set velocity_1 $side2
            set base_line [ expr { abs (  $side4 - $side3 )} ]
            set calculation_1 [ expr { .5 * ( $side1 + $side2 ) * 60. } ]
            set bisection_1 [ expr { .5 * $calculation_1 } ]
            set bisection_velocity_c [ expr {  ((($velocity_0)**2 +($velocity_1)**2)/2.)**.5 }]
            set bisection_time_c [ expr { $base_line * (  $velocity_0 -  $bisection_velocity_c  ) /  ( $velocity_0 -  $velocity_1  )  }]
            set side5 $bisection_velocity_c
            set side6 $bisection_1
            set side7 $bisection_time_c
            set side8 $calculation_1
            set side1 [* $side1 100. ]
            set side2 [* $side2 100. ]
            set side3 [* $side3 100. ]
            set side4 [* $side4 100. ]
            set side5 [* $side5 100. ]
            set side6 [* $side6 100. ]
            set side7 [* $side7 100. ]
            set side8 [* $side8 100. ]
        }
        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;
            console eval {.console config -bg palegreen}
            console eval {.console config -font {fixed 20 bold}}
            console eval {wm geometry . 40x20}
            console eval {wm title . " Parametric Model Vaporware  V2 Report , screen grab and paste from console 2 to texteditor"}
            console eval {. configure -background orange -highlightcolor brown -relief raised -border 30}
            puts "%|table $testcase_number|printed in| tcl format|% "
            puts "&| quantity| value| comment, if any|& "
            puts "&| $testcase_number:|testcase_number | |&"
            puts "&| $side1 :|parameter 1: |   |&"
            puts "&| $side2 :|parameter 2: | |& "
            puts "&| $side3 :|parameter 3: | |& "
            puts "&| $side4 :|parameter 4: | |&"
            puts "&| $side5 :|parameter 5:| |  |&"
            puts "&| $side6 :|parameter 6:| |  |&"
            puts "&| $side7 :|parameter 7:| |  |&"
            puts "&| $side8 :|parameter 8:| |  |&"
            
        }
        frame .buttons -bg aquamarine4
        ::ttk::button .calculator -text "Solve" -command { calculate   }
        ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 1.080 1.101 1.123  1.144  1.116 1.0  1.0  1.0 }
        ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 1.116 1.213  1.260  1.309  1.360 1.0  1.0  1.0 }
        ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 1.915 2.157 2.402  2.649  2.649 1.0  1.0  1.00  }
        ::ttk::button .clearallx -text clear -command {clearx }
        ::ttk::button .about -text about -command {about}
        ::ttk::button .self_help -text self_help -command {self_help}
        ::ttk::button .console2 -text report -command { reportx }
        ::ttk::button .exit -text exit -command {exit}
        canvas .c -width $width -height $height -background black
        scale .sc -from 0 -to 7 -length 240 -resolution .1 \
                -orient horiz -bd 1 -showvalue true -variable angle \
                -command {puts " display scale $side1 $side2 $side3 $side4 [pie]"; EllipsePlot .c $side1 $side2 $side3 $side4 [pie]}
        pack .c .sc .calculator -in .buttons -side top -padx 10 -pady 5 
        pack  .clearallx .console2 .self_help .about .exit .test4 .test3 .test2   -side left -in .buttons
        grid .frame .buttons -sticky ns -pady {0 10}
        . configure -background aquamarine4 -highlightcolor brown -relief raised -border 30
        wm title . " Parametric Model Vaporware V2"
        # gold on TCL Club, 8Jul2020
        # This posting, screenshots, and TCL source code is
        # copyrighted under the TCL/TK 8.6 license terms.
        # Editorial rights retained under the TCL/TK license terms
        # and will be defended as necessary in court.
        # end of file
       

     ;# 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 ]

;# puts  taylor tangent series into pade tangent
;# of rational numbers ratio into horners form
;# num/denum=(1/45*$x**9 - 22*$x**7 + 3003*$x**5 - 105105*$x**3 + 765765*$x)/($x**8 - 308*$x**6 + 21021*$x**4 - 
360360*$x**2 + 765765)
;# num=1/45*(((($x**2 - 990)*$x**2 + 135135)*$x**2 - 4729725)*$x**2 + 34459425)*$x
;# denum=((($x**2 - 308)*$x**2 + 21021)*$x**2 - 360360)*$x**2 + 765765
symdiff {(1/45.*$x**9 - 22*$x**7 + 3003*$x**5 - 105105*$x**3 + 765765*$x)} x
((((((9 * pow($x, 8)) * (1 / 45.)) - ((7 * pow($x, 6)) * 22)) + ((5 * pow($x, 4)) * 3003)) - ((3 * pow($x, 2)) * 105105)) + 765765.0)
symdiff {($x**8 - 308*$x**6 + 21021*$x**4 - 360360*$x**2 + 765765)} x
((((8 * pow($x, 7)) - ((6 * pow($x, 5)) * 308)) + ((4 * pow($x, 3)) * 21021)) - ((2 * $x) * 360360))

       # Functional math system for integers from RS
        # Playing with recursion
        # Richard Suchenwirth 2004-10-24
        # two functions should be enough to derive all arithmetics
        proc func {name argl body} {proc $name $argl [list expr $body]}
        proc '  x    {incr x}
        proc = {m n} {string equal $m $n}
        func pred   n    {[pred2 $n 0]}
        func pred2 {n m} {[= [' $m] $n]? $m: [pred2 $n [' $m]]}
        proc = {m n} {string equal $m $n}
        proc test args {
            foreach {case expected} $args {
                catch {uplevel 1 $case} res
                if {$res != $expected} {error "$case->$res, expected $expected"}
            }
        }
        func + {m n} {[= $n 0]? $m: [+ [' $m] [pred $n]]}
        #-- the product
        func * {m n} {[= $n 0]? 0: [+ $m [* $m [pred $n]]]}
        #-- the difference (defined only for m >= n)
        func - {m n} {[= $n 0]? $m: [- [pred $m] [pred $n]]}
        #-- the inequality predicate <=
        func <= {m n} {[= $m 0]? 1: [= $n 0]? 0: [<= [pred $m] [pred $n]]}
        #-- leading to the strict inequality <
        func < {m n} {[= $m $n]? 0: [<= $m $n]}
        #-- Integer division goes like this:
        func / {m n} {[< $m $n]? 0: [' [/ [- $m $n] $n]]}
        #-- Integer division remainder (% in expr)
        func rem {m n} {[< $m $n]? $m: [rem [- $m $n] $n]}
        #-- Divisibility of a number n by a number m
        func | {m n} {[= $n 0]? 1: [< $n $m]? 0: [| $m [- $n $m]]}
        func prime   n    {[= $n 0]? 0: [= $n 1]? 0: [prime2 $n 2]}
        func prime2 {m n} {[= $m $n]? 1: [| $n $m]? 0: [prime2 $m [' $n]]}
        func gcd {m n} {[<= $n $m]?        [gcd $n $m]:
            [= [rem $n $m] 0]? $m:
            [gcd [rem $n $m] $m]}

            #  pretty print from autoindent and ased editor
            #  Collatz_Sequences (3*N+1) in Console Example Demo for TCL V2
            #  Console program example demo
            #  written on Windows 10 on  TCL
            #  working under TCL version 8.6
            #  gold on TCL Club , 11sep2021
            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 tclprecision 17
            #  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
            # 
            #  Results: collatz_sequence
            # 
            #  Return the collatz_sequence from positive integer
            # 
            #  Arguments:
            #     number first value is number
            #     iteration second value is iteration
            # 
            # 
            #  Note: This program can easily generate an endless loop.
            #         iteration number is a stop or limit to iteration
            #  By custom, the end of collatz_sequence is 1 or start of repetition
            proc collatz_sequence {number iteration} {
                #  Rewritten by HE on TCL WIKI
                #  Check parameter
                if {!([string is wideinteger $number] && $number > 0)} {
                    error "Number '$number' is not positive integer!"
                }
                if {!([string is wideinteger $iteration] && $iteration > 0)} {
                    error "Iteration '$iteration' is not positiv integer!"
                }
                #  Initialisation
                set sequence [list $number]
                
                #  Interations
                for {set n 0} {$n <= $iteration} {incr n} {
                    if {$number == 1} {
                        return $sequence
                    }
                    if {$number % 2} {
                        #  Odd
                        set number [expr {(3 * $number) + 1}]
                    } else {
                        set number [expr {$number / 2}]
                    }
                    lappend sequence $number
                }
                #  After value reach 1 it is a endless sequence of 4 2 1 4 2 1 ...
                #  If we reach not 1 during the given ammount of iteration
                #  we raise an error to signal that number of iterations are to small
                #  or we reach the case all looking for.
                #  this error crops with large lists > 15 elements
                #  error "Number of iteration '$iteration' reached without getting 1!"
            }
            console show
            puts "  Console wrapper for solution proc"
            puts "  ***************************"
            puts "  ***************************"
            puts "collatz_sequence 31 130 collatz_sequence [collatz_sequence 31 130]"
            puts "collatz_sequence 11 15 collatz_sequence [collatz_sequence 11 15]"
            puts "collatz_sequence 10 15 collatz_sequence [collatz_sequence 10 15]"
            puts "collatz_sequence 9 20 collatz_sequence [collatz_sequence 9 20]"
            puts "collatz_sequence 8 15 collatz_sequence [collatz_sequence 8 15]"
            puts "collatz_sequence 7 20 collatz_sequence [collatz_sequence 7 20]"
            puts "collatz_sequence 6 15 collatz_sequence [collatz_sequence 6 15]"
            puts "collatz_sequence 5 15 collatz_sequence [collatz_sequence 5 15]"
            puts "collatz_sequence 4 15 collatz_sequence [collatz_sequence 4 15]"
            puts "collatz_sequence 3 15 collatz_sequence [collatz_sequence 3 15]"
            proc table_format_out  n {
                set sum 0
                #  initial  level
                set count 1
                puts "%| table|  | printed in|TCL format |% "
                puts "%| number | iteration |partial Collatz_Sequences  |comment, if any|% "
                #  adapted proc from <RS>
                #  printout in TCL WIKI format table
                for { set i 1 } { $i <= $n } { incr i } {
                    incr count
                    puts "&| $count | 120   | [ collatz_sequence $count 120 ]| |&"
                    incr sum $i
                }
                return $sum
            }
            table_format_out 31
            #  following dresses up console output to easy eye
            #  end of working deck
            #  add cosmetics below to bottom of file
            console eval {.console config -bg palegreen}
            console eval {.console config -font {fixed 20 bold}}
            console eval {wm geometry . 40x20}
            console eval {wm title . " Report for Collatz_Sequences (3*N+1) Calculator V2  "}
            console eval {. configure -background orange -highlightcolor brown -relief raised -border 30}    

Section 8 for Math Geeks
----
Sample math problems loaded into search engines.
-----
Collecting test problems for future calculator
----
Search engine math >>>> ( (88+98+91+92+91+ 93) / 5.) + 46.7) / 28.7
5.48083624 correct
----
Online conversion of average glucose to A1c:
https://professional.diabetes.org/dia...
Formula to convert estimated glucose to A1c: A1C(%) = (Estimated average glucose(mg/dL) + 46.7) / 28.7
----
Sample problem
----
Sum of 5 readings over a day.
Search engine math >>>>[88+98+91+92+91+ 93]
= 462 correct
sum over a day,
----
Search engine math >>>>
( 88+98+91+92+91+ 93 ) / 5
= 92.4 correct sum

----
Search engine math >>>> ( (88+98+91+92+91+ 93) / 5.) + 46.7) / 28.7
----
5.48083624 correct
*****
Note. This formula uses average BG readings from a home glucometer, not as accurate as lab blood test. But useful as a check on home glucometer results

----
Sample problem 2
----
Search engine math >>>>( (81+77.4+73.8 +81+73.8)) / 5.) + 46.7) / 28.7

4.32404181 correct
----
Results from 72 hour Sardine Challenge. Subject to interpretation
----
Kickstart Metabolism In 3 Days With Sardines
----
notes. 
(81+77.4+73.8 +81+73.8)/5=
----
((((81 + 77.4) + 73.8) + 81) + 73.8) / 5= 77.4 Avg BG
----
77.4 Avg BG ~ 4.2 = A1C
----
Note. Now that I am impressed, looks like the Sardine Team has cleared up a keto block within 3
days.
----
Note. Additional significant figures are used to check the TCL calculator, not to infer the accuracy of inputs and product reports. 
Meaning here, round to nearest tenth 0.1. 
----

     #pseudocode can be developed from rules of thumb.
     #pseudocode: some problems can be solved by proportions (rule of three), to some order of magnitude
     #pseudocode: enter quantity1,  quantity2, quantity3 and expected output (quantity4) for testcases.
     #pseudocode: enter time in years, number of remaining items
     #pseudocode: output fraction of (remaining items) over (items at time zero)
     #pseudocode: ouput remaining items as fraction or percent
     #pseudocode: output fraction of (quantity4 ) over ( quantity1 at time zero)
     #pseudocode: output fraction of (quantity2) * (quantity3 ) over (quantity1 at time zero)
     #pseudocode: outputs should be in compatible units.
     #pseudocode: rules of thumb can be 3 to 15 percent off, partly since g..in g..out.
     #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?
     #; Terence Tao realized that the Collatz conjecture was similar to partial differential equations.
     #;  The Tao starting sample weighs  toward numbers that
     #; have a remainder of 1 after being divided by 3,
     #; and away from numbers that have a remainder of 2 after being divided by 3.
     #;  TCL pseudocode
     #;  remove all numbers divisible by 3 on a list of integers, 
     #;  find all numbers that have a remainder of 1, when divided by 3.

        proc table_format_out  n {
            set sum 0
            # initial  level
            set count 0.0
            set glucose 100.
            puts "%| table|  | printed in|TCL format |% "
            puts "%| homa_IR_2 units | insulin units |glucose units  |comment, if any|% "
            # adapted proc from <RS>
            # printout in TCL WIKI format table
            for { set i 1 } { $i <= $n } { incr i } {
                set count [+ $count .1]
                set insulin $count
                set homa_IR_2 [ HOMA_IR2 $insulin $glucose  ]
                set insulin [ precisionx 3 $insulin ]
                set glocose [ precisionx 3 $glucose ]
                puts "&| [ precisionx 3  $homa_IR_2  ] |  $insulin  | $glucose | |&"
                incr sum $i
            }
            return $sum
        }
        table_format_out 90 
=====   
----
*** Subroutine for table in TCL Wiki format***
----
Adapted proc from [RS]
----

proc dice_sides_N { dice_sides } {
    if {[dict exists $memoized $dice_sides]} {
        return [dict get $memoized $dice_sides]
    }
    set result [expr { 1 + int(rand()*$dice_sides)}]
    dict set memoized $dice_sides $result
    return $result
}

proc optimum_N { dice_sides } {
    if {[dict exists $memoized $dice_sides]} {
        return [dict get $memoized $dice_sides]
    }
    set result [expr { int(1.718281828 *$dice_sides) }]
    dict set memoized $dice_sides $result
    return $result
}

    Test on   printing list of dice throws
    # still checking here.
proc cast_dice {num_sides number_dice} {
    set num_throws 0
    set total 0
    while {$num_throws < $number_dice} {
        set total [expr $total + [expr { int($num_sides*rand())+1 } ]]
        incr num_throws
    }
    return $total
}
proc cast_dice_set {num_sides num_dice number_throws} {
    set all {}
    set num_throws 0
    while {$num_throws < $number_throws } {
        lappend all [cast_dice $num_sides $num_dice ]
        incr num_throws
    }
    return $all
}
puts " throws [ cast_dice_set 6 10 5 ] "

    # Test on   printing list of dice throws
puts " throws [ cast_dice_set 6 10 5 ] " # 6 sides, 10 dice, 5 throws.
throws 27 35 40 36 30            #  6 sides, 10 dice, 5 throws.
puts " throws [ cast_dice_set 6 1 5 ] " # 6 sides, 1 die, 5 throws.
throws 6 4 1 4 6 
puts " throws [ cast_dice_set 6 2 5 ] "  # 6 sides, 2 dice, 5 throws.
throws 11 10 4 5 4 
puts " throws [ cast_dice_set 4 2 10 ] " 
# For 2 4-sided dice, max should be 8, 
# min should be 2,
# 10 throws are counted here
throws 6 5 6 6 8 2 3 7 6 6 
puts " throws [ cast_dice_set 2 6 15 ] "
throws 10 8 9 7 8 7 6 8 9 11 10 9 8 6 10 
puts " throws [ cast_dice_set 2 6 30 ] "
throws 9 7 9 7 10 10 10 10 7 10 8 10 10 11 9 8 9 8 10 8 10 10 8 9 9 9 11 9 10 11 

global theta
set theta 1.3063778838630806904686144926
proc mills_constant_tester {limit} { global theta;
expr {  int( [ expr {($theta**(3**$limit))} ] )}}
puts " mills_constant [ mills_constant_tester 1 ]      "
puts " mills_constant [ mills_constant_tester 2 ]     "
puts " mills_constant [ mills_constant_tester 3 ]   "
puts " mills_constant [ mills_constant_tester 4 ]   "
# mills_constant 2      
# mills_constant 11     
# mills_constant 1361   
# mills_constant 2521008886
# big numbers evaled and large significant figures in constant, results limited quickly in most setups. 

Notes on 13Feb2024.
4 yes-no binary sticks equals 2**4 combinations or 16 combinations. Probability of single cast 1/(2**4) or 1/16. Space = 16 items
5 yes-no binary sticks equals 2**5 combinations or 32 combinations. Probability of single cast 1/(2**5) or 1/32. Space = 32 items
6 yes-no binary sticks equals 2**6 combinations or 64 combinations. Probability of single cast 1/(2**6) or 1/64. Space = 64 items
7 yes-no binary sticks equals 2**7 combinations or 128 combinations. Probability of single cast 1/(2**7) or 1/128. Space = 128 items

 

The three most frequently occurring characters are:
吉 auspicious
无咎 no misfortune
凶 ominous

Thinking in Bullet Points
There are a total of 384 lines in the I Ching Oracle Book
There are roughly 100 lines with character "mistake", Chinese "Liu"
100/384 = 0.2604 probability of mistake Liu appearing
(384-100)= 284 number of lines without mistake Liu appearing
284/384= 0.7396 probability of mistake Liu not appearing
The probability of casting a line with the character "mistake" is 0.2604, roughly 1/4 or 0.25
The probability of casting a line with no character "mistake" is 0.7396, roughly 3/4 or 0.75
The probability of casting a line with or without character "mistake" is 0.2604 + 0.7396 = 1
One might conclude the I Ching Oracle Book is rigged not to cast a character "mistake".