One Liners Programs Compendium and TCL demo examples calculations, numerical analysis

One Liners Programs Compendium and TCL demo examples calculations, numerical analysis

This page is under development. Comments are welcome, but please load any comments in the comments section at the bottom of the page. Please include your wiki MONIKER and date in your comment with the same courtesy that I will give you. Aside from your courtesy, your wiki MONIKER and date as a signature and minimal good faith of any internet post are the rules of this TCL-WIKI. Its very hard to reply reasonably without some background of the correspondent on his WIKI bio page. Thanks, gold 26Sep2020


Title: One Liners Programs Compendium

Preface

gold 26Sep2020 Here is extension of article on One Liners Programs written for Wikipedia. Trying to boil down some advice to me over 15 years of TCL Wiki membership. This page is intended to progress from simple questions to complex questions. Socrates held that wisdom was not current knowledge, but asking the right questions.


Introduction



There is a gold mine of One Liners Programs and content in the Tool Control language TCL 8.6 core distribution, TCL manual pages, and TCLLIB library that can be adapted or recast into brief one liners programs. These one liners programs or procedures can be pasted into the TCL 8.6 console window for quick results, reference the TCL Wiki. Some one liners programs use the return statement, return $value, or return 1 to return the results to the program line. Although many TCL programmers just rely on the last computation being returned by the one liner procedure in the TCL console window. There is some room in the Wiki publications for programming style differences. But it is usually best to put usage, credits, or TCL documentation references for the one liners procedures on separate comment lines. The random rand procedures make use of the random function and do not return the same answer every time. Dependence on math operator notation, helper procedures, math check examples, and special library functions should be noted in the comment lines.


The terms program, routine, subroutine, procedure, and proc are used interchangeably in this article. Recognize that the TCL nomenclature uses the exceptional term procedure and proc, but the internet search engines and general public do not accept or pull the terms procedure and proc as equitably with respect to the other computer languages using terms subroutine and program.


There are pros and cons to one liner programs in TCL. One may contrast the approach to one liners programs in problem solving versus the traditional procedural approach. There are better routines and methods in faster language constructs in the current TCL core distribution and TCLLIB. Working with recursion, primes, text search, and timing the procedures will quickly show the warts on the one liners programs. To gain speed and shorter computation times, one will generally have to access the TCL core distribution and TCLLIB. Since the TCL interpreter collapses the carriage returns, skips, blank lines, and dead space of traditional written procedures into a single line of machine code, is not every script a one liner program to the parser? As grandfather remarked, the gourmet omelet, beef mulligan stew, and farm buttermilk all go to the same place.


The analogy of using a one liners program to control the large TCL language is like sticking an Apple computer for the human operator in front of a Cray computer. The human mind probably can only understand and use a limited set of instructions.So an interface in hardware or TCL language as a limited set of instructions or limited window of interaction might be useful. After all, the human mind was designed to chase rabbits. Reference the article on Little L Programming Language, Let's assign with let, and the L-Language pdf L , by Larry McVoy: See article on using Apple computers with Cray designer in Apple Cray Computer [L1 ].


Equivalent One Liners V2


Beginning in the sixties, the one liner program was typed input to the command line of an operating computer system terminal so that the one line command performs some useful function in a single one line of terminal input. Some of the original one liner commands were limited to a 60 character display on especially the early Basic terminals or to a 72 characters on the Fortran punched cards. Of course, the hit return to send, terminal flashing bulbs, and automatic answer back were silently understood as part or supporting the one liner program. Some of the line lengths in some computer languages were later extended to 120 characters and so on. The definition and use of the one liner program has been widened to include program source for any language that does something useful in one line. On batch programs, controlling and setting variable statements like RETURN, STOP, END, extra terminal prompts, and setting initial variables were used in Fortran systems. Of course, a very good feature of TCL is that new variables as number types do not have to be initialized prior to use and no subroutine RETURN and END statements are necessary, vis the older Fortran and Basic dogmas in moldy textbooks. Repeating, setting a new number variable to 0 or 1 is not necessary prior to using the variable. Good programming practice holds that one partial goal of computer programming is to produce human readable code. So it is permissible on the published console batch programs here to retain some vestigial stages to aid human comprehension. As a friendly challenge, the user is free to pare down the one liners programs even more. Meaning the user may omit the return statements, modify or omit the expr statements, switch to math operations mode, switch to TCLLIB precompiled code, and pull extra brackets for his own TCL version and setup.


Philosophy On One Liners Programs


I remember when my teenage sister would ask about a math problem. I would lead up and carefully explain this and that algebra proposition. But my sister would say " I just want the answer!" In most engineering problems, there is an advantage in finding the answer in an approximate solution, say slide rule accuracy or 4 significant places. For example, using the old slide rule, one would make a preliminary pencil calculation and approximate answer to set the decimal point, before using the slide rule accuracy to 4 significant places. If one thinks of TCL as primarily as a graphical gui language, then the one liners programs are best used to check the preliminary math concepts. One liners programs and initial console programs are often used to check the math concepts and generate testcases before loading the calculator gui shell.


In planning any software, it is advisable to gather a number of testcases to check the results of the graphical user interface gui program. The results of the testcases are estimated using the hand calculations and then checked in the TCL gui calculator. Pseudocode and equations are developed from the hand calculations and theory. One liners procedures and small console programs are written to check or proof the alternate subroutines or procedures, rather than keeping the unblessed code and comment lines in the main gui calculator. Finally the improved or alternate subroutines are loaded into the gui calculator. The TCL gui or slot calculator is effectively a shell program to input entries, host calculation routines, maintain housekeeping procedures, and display results. Additional significant figures are used to check the TCL calculator, not to infer the accuracy of inputs and product reports.


Reposted Tips from AMG & GWM & Wiki for One Liners Programs


The beginner TCL procedure on the pi circle constant was corrected to proc pi {} {expr acos(-1)} ;# AMG. One Liners Programs should avoid using temporary variables like {set temp 3.14:if {$temp=3.14} {return 1};return $temp}. Temporary variables may cause more time delay, more complication, and possible confusion to reader. 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. If one insists on temporary variables, be aware that it is perfectly legal for a proc and a variable to have the same name. You could have said "set pi [pi]". For safety and efficiency, always be sure to brace your expr-essions! Heh, I neglected to brace my expression in [pi], but that's one of the extremely rare cases where it won't matter: no spaces, no substitutions. Bracing does two things: One, when the entire expression is a single word (single argument), it can be bytecode-compiled. Two, if substitutions are performed by expr only and not Tcl itself, injection attacks are prevented. Since the expr command has an internal if conditional, ? in a?b:c sic, try using the internal if <?> in expr rather than a separate IFstatement. Avoid using separate if statements and temporary variables for brevity. The args variable is also useful tool in one liners programs for inputting multiple data or lists of words. Another strategy is to keep track of possible error checks and testcases for low, middle, and high values over the range of operation of the oneliners program. An initial check for zero division or series start at one may be installed in the expr ? conditional. A simple credit for a one liner program may use a semicolon with comment sign <;#> at statement end, which should not degrade program execution. Using the time function in TCL will give even more insights into one liners programs, also see Time. In One liners Programs Pie in the Sky, one can see the advice of GWM on the importance of timing your code and procedures. Usually, invoking math ops, TCLLIB library, and other precompiled libraries can save an average of 1/3 time over big data chores. The time savings are not always obvious on small quantities of data. Performance of one liners programs may suffer degradation due to lengthy recursion calls and limits on the number of procedure recursion calls. The shorter the script, the faster and more reliable is the script. Dependence on math operator notation, helper procedures, math check examples, degradation due to lengthy recursion calls, and special library functions should be noted in the comment lines. The examples on this wiki page include code lines that might be incompatible, inefficient, or redundant if installed in the same program. As discussed, the local math procedures in scripts and one-line procedures may not be as fast and efficient as importing mathop , mathfunc, and math, so check with the precompiled code in the TCL core and TCLLIB libraries first, then homebrew your one-line programs and scripts.



Examples for Reposted Tips

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


Continuing Reposted Tips from Wiki. Not all problems have sufficient information or initial conditions to solve the problem. However, the analysis may develop low, high, and breakpoint constraints with a bag of assumptions from similar problems and testcases. The most consistent error check should be that the sum of the shares should equal the original total. The analogy of the process is ( egg >> chicken >> return to egg). In writing pseudocode: 1) need test cases for small,medium, giant metrics, 2) need testcases within range of expected program operation, and 3) are there any cases too small or large to be solved in the current constraints? With TCL/Tk canvas and Tk graphical capability, a graphical solution is usually a good alternative. At least, a graphical solution will give one some assurance on the math. In the case that several one liners programs are available or possible to solve a similar problem, a time averaging, weighted, or piecemeal solution can produce surprising and robust results towards a problem solution. Thanks to the Heisenberg's uncertainty principle, some solutions exist as a band or cloud of values between a lower limit or upper limit. The solution band for a double false position solution DFPP would be between < set false1 expr $guess * 3/5 and <set $false2 expr $guess * 4/5>. The center line between lower and upper solution bounds would be <false1 & false2> /2. For some tuffies with no obvious linear solutions, see [L2 ], [L3 ], [L4 ], and [L5 ]


gold 10/26/2020. Note from Ask13 [L6 ]. I have collected some tips on faster code for you. I have not seen your code. But Reposted Tips from AMG & GWM & Wiki and Continuing Reposted Tips from Wiki may be of help. One would almost have to do a time analysis of individual subroutines and individual lines to find the "core hogs" with the time command. See [L7 ] It is sometimes advantageous to write and divide the script into smaller subroutine chunks, organized and structured data code subsections for easier detection of "core hogs. See model [L8 ]. A "core hog" in a heap of straw and spaghetti code is more difficult to find, from experience here. Most programmers find it convenient to test or dry run a new subroutine or one liner program inside a testbed or separate console program. The new subroutine is exercised separately without invoking the whole main program or gui, graphical user interface. Some commercial testbeds are set with speed and performance markers. See sections Easy Eye Testbed and Timing Equivalent One Liners V2 below. Also refer to wiki page on Easy Eye Calculator and Playing Recursion V2 [L9 ].


Pseudocode For Problem Setup


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


if, if, and iffy Table


See section Noise Words of if by AMG. Seemed to call for a table, if one is studying recursion on one liner programs.


table printed inTCL format
elementsshort hand for if long hand for if comment, if any
2if a b ;# if {a} then {b}
3if a b c ;# if {a} then {b} else {c};# 2*n+1 elements odd
4if a b c d ;# if {a} then {b} elseif {c} then {d}
5if a b c d e ;# if {a} then {b} elseif {c} then {d} else {e};# 2*n+1 elements odd
***** alternate expressions for expr ****
8 if a b c ...c1,c2,c3... d e;# if {a} then {b} elseif {c} ...elseif {c1} elseif {c2} elseif {c3} .... then {d} else {e}maybe multiple successive elseif?, but not seen example
3 a?b:c expr equivalent;# if {a} then {b} else {c} ;# 2*n+1 elements odd expr command has an internal if conditional ? in a?b:c
5 a?b:c?d:e expr equivalent ;# 2*n+1 elements odd expr command has an internal if conditional ? in a?b:c
7 a?b:c?d:e?f:g expr equivalent ;# 2*n+1 elements odd expr command has an internal if conditional ? in a?b:c
9 a?b:c?d:e?f:g?h:i expr equivalent ;# 2*n+1 elements odd expr command has an internal if conditional ? in a?b:c
11 a?b:c?d:e?f:g?h:i?j:k expr equivalent ;# 2*n+1 elements odd expr command has an internal if conditional ? in a?b:c



Timing in Console programs as Conclusion


A console program has been modified to check the results and timing of one liner procedures in the script at bottom of page. The user can add new algorithms by adding a new one liners program in the source code. One add a number line to the if statement that controls the algorithm selection in the console program. The one liner procedures and solutions can also be pasted into the TCL console easily. There are some series for 1/N*N and 1/N*N*N*N which gives fractions of pi. Other functions for testing include Eulers double prime probability , pi generating series, the Monte Carlo random algorithms, and the strip integral of a quadrant. The accuracy of these individual solutions varies with the number of trials and some algorithms used are fairly slow, even glacial closers. Most of the one liners programs and usage examples should be pastable into the TCL console. Usually recommend the easy eye console with green screen and large type. A similar approach to timing one liners procedures may be seen in Oneliner's Pie in the Sky and Counting characters in a string.


Precompiled Code saves Computation Time over One Liners Programs


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

Important Note


{gold] 15Sep2020. Important Note. This page is not a replacement for the current TCL core and TCCLIB with much improvement since TCL4 and other <faster> language constructs. See better routines and current methods for angle reduction, sin, cos, pi, etc in the TCL core distribution and TCLLIB. As of Jul2018, the TCLLIB has developed code for trig angles in degrees, trig inverse, and hyper functions in degrees, and angle reduction in radians and degrees. This supplemental trig.tcl, trigtest.tcl, and trig.man code is posted on the TCLLIB website. This math::trig.tcl seems really exciting work, which will keep TCL in pace with some of the other brand name languages (math oriented, I mean). Some of the TCL library code is posted as pending on the TCLLIB website, and sometimes not really published in the main TCL distribution yet, so its worthwhile to investigate and run searches on the pending TCLLIB code also.


Rule of 72 for Doubling Money


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

Random Integer


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

Centigrade to Degrees Fahrenheit


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

Draft One Liners Spares


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

Draft Interest Rates



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

Borrowed One Liners from TCL Wiki


Reference FW and RS on Plain string substitution in Bag of algorithms, also Example Scripts Everybody Should Have


   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

One Liners from www.codecodex.com/wiki

        #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

Testing One Liners Programs for list_twin_primes V2


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

Table Results on Twin Primes for 2,4,6,10 Separators


table Twin Primes for 2,4,6,10 Separators printed inTCL format
result lower limit upper limit separator integer comment, if any
elements in list lower limit upper limit separator integer comment, if any
3 5 5 7 11 13 17 19 3 25 2
3 7 7 11 13 17 19 23 3 25 4
5 11 7 13 11 17 13 19 17 23 23 29 3 25 6
3 13 7 17 13 23 19 29 3 25 10

Bits and Pieces, Testing One Liner Programs


        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.        


Fortran Like "Call" Procedure


gold Here are one line procedures for fortran like "call" in TCL, mostly altered proc from LV on Wiki page of Salt and Sugar. See also Call Procedure Like Fortran Example


  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]


Circle Area and Law of Cosines


gold Here are some one line procedures for circle area and law of cosines. See tcl::mathfunc cos pi constants Functions ::math::constants::constants and ::math::fibonacci are available in the TCLLIB. Most of these one liner programs were revamped on the advice of AMG. Most one liners should be pastable into the TCL console for further testing.

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

"Chance of" and rand() Conditions


gold Here are some one liners for "chance of" conditions. The "chance of" procedures make use of the random function and do not return the same answer everytime. The random function was used in the Random Walk Equation Slot Calculator Example. Chances of weather and other conditionals were used in Game Kingdom of Strategy. Weather and other conditionals are especially important in games and military strategy. See also rand random tcl::mathfunc.

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


Decimal Equivalents to some Babylonian Math Tables



gold Following one liners are decimal equivalents to some Babylonian math tables, using mathop here from Babylonian Cubic Equation Problem and eTCL demo example calculator, numerical analysis. Mostly, these one liners programs are returning lists of numbers.

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

Some fragmented Babylonian tables known as n*n*(n+1) tables were used in solving some cubic equations, ref Joran Friberg. The equations were of the form n*n*(b*n+1) = c. The eTCL calculator could generate the expected tables of n*n*(n+1). Other Babylonian tables known as n*(n + 1)*(n + 2) and n*n*(n – 1) tables have been identified, but no abundant use has been cited from the known Babylonian math problems. Although not clear, tables of the n*(n + 1) might have existed. From modern theory, n · (n + 1)/2 = sum of integers (1,2,3,4...) and n*(n + 1)*(n + 2) /6 = sum of squares (1,4,9....). Possibly, the Seleucid math problem used an n*(n + 1)*(n + 2) table. Possibly, the tables for n*(n + 1)*(n + 2) and n*n*(n – 1) could have been used for cubic equations. The Seleucid method for sum of squares can be factored for sum of integers term and can be restated as a quasi_cube, ((1/3)(1+2 *n) ) * ( n(n+1)/2.) = (1/6)* n(n+1)(2n+1) = (1/6)*quasi_cube term. Another possible form for the quasi_cube (1/6)* n(n+1)(2n+1) with 2 factored out is expression 2*(1/6)* n(n+1)(n+(1/2)) . Problems for sum of squares and sum of rectangles go far back through the Selucid and Old Babylonian math, although Old Babylonian math may not demonstrate complete knowledge. At least in referring to TCL procs, the Babylonian table known as n*(n + 1)*(n + 2) is not that far from the sum of squares and triangular numbers as n*(n + 1)*(n + 2)/6.


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


Functions ::math::constants::constants, ::math::random, math::combinatorics, math::specialfunctions, and ::math::fibonacci are available in the TCLLIB. Also see Triangular Numbers [L10 ]

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


Electrical Procs


        ;# 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  exampleproblem [ cascadedefficiency   .85 .90 .73    ] #answer is 56 percent.


Age of the Earth from Lord Kelvin, history of science


gold Here is the one liner program approach to the age of the earth. These calculations of Lord Kelvin are mainly of historic interest and have been superseded by modern theory.

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

Historical Kelvin Earth Cooling and eTCL Slot Calculator Demo Example , numerical analysis edit


One Liner Approach to the Fibonaci series



gold Here is the one liner approach to the Fibonaci series. However, the algorithms are limited to positive numbers only. Performance may suffer degradation due to lengthy calls and limits on the number of procedure recursion calls. See Fibonacci numbers, Additional math functions, and math::constants. Functions ::math::constants::constants and ::math::fibonacci are available in the TCLLIB.

      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 

AMG: Here's another implementation, using expr's ?: operator instead of if:

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

gold Here is mathops & mathlib follow-on to the one liner approach to the Fibonaci series, using Binet formula for fibonacci (N). See Fibonacci numbers. The library call is ::math::Fibonacci (N).

    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

Proc Titles into Lists


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

Advanced Topics, Dependent on TCLLIB Math library


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

Looking for methods to transform other formulas and known functions? See Symbolic Differentiation of known functions math::calculus::symdiff , pade rational number approximations, and horner expressions.Evaluating polynomial functions & [L11 ] & [L12 ]


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


Simple Error as Percentage


gold Here is one liner procedure developing simple error as percentage. There are one liner procedures for various error function approximations in Oneliner's Pie in the Sky, though "not ready for the mars shot" and dependent on helper procs. Functions ::math::special::erf and ::math::special::erfc are available in the TCCLIB math library. See TCLLIB.


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


Time on One Liner Programs


See Time


    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

Advanced Topics: Polynomials, Sums of Powers, Symbolic Differentiation & Integration in Tcllib Calculus


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

Ref. CRC Standard Mathematical Tables and Formulae [L13 ]


Symbolic Differentiation & Integration in Tcllib Calculus


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


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

Advanced Topics: Math Functions and Constants


Apparently there is considerable computer time saving and effectively extra precision inside the expr w/8.5+. In addition to the predefined expr functions, expr has applications that may define additional math functions and constants by using proc (or any other method, such as interp alias or Tcl_CreateObjCommand to define new commands in the tcl::mathfunc namespace. In addition, an obsolete interface named Introduction_CreateMathFunc() in Tcl C API is available to extensions that are written in >> C++ <<. See [L14 ] & TCL Programming Expr, 2009 & tcl::mathfunc & Additional math functions.


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

Draft for One Liner Program Approach to Validation


gold 10/26/2020. Complex subject may have to start out with some helper procs. See string is and ycl


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

Advanced Topic, Recursion with Logic


See Playing with recursion by RS on TCL Wiki.


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



Advanced Topic, Sum of Infinite Geometric Series



gold Here is a one liner procedure for sum of infinite geometric series, though the explanation and examples take up more than one line.

      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 This can be compacted even more:

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

Advanced Topics, Extra Credit, But Cited for Public Domain


        ;#  picks random element in list, useful for picking random colors & numbers
        ;#   Wiki Books Tcl Programming Examples 2005 by Richard Suchenwirth
        proc random_list lister {lindex $lister [expr {int(rand()*[llength $lister])}]}  ;# RS cited  Public Domain
        ;#  Usage  random_list { TCL must avoid unbalanced quotes or braces }
        ;#  Usage  random_list { blue black red yellow violet green blue }
        proc fac x {expr {$x<2? 1: $x*[fac [incr x -1]]}}   ;# Cameron Laird  cited Public Domain
        ;#  Usage lengthy recursion calls possible,
        ;#  Usage number results can rapidly  exceed  computer operating domain
        ;#  Usage fac 5 returns 120
        ;#  Usage fac 7 returns  5040       
        proc pow10 x {expr {pow(10,$x)}}             ;# RS cited  Public Domain
        proc log10 x {expr {log10($x)}}              ;# RS cited  Public Domain
        proc -log10 x {expr {-log10($x)}}            ;# RS cited  Public Domain
        proc by100 x {expr {$x/100.}}                ;# RS cited  Public Domain 
        ;# Start pseudocode and formulas
        ;#  pseudocode  log2 N =~ 1.442695 * ln N
        ;#  pseudocode  log2 N =~ 3.321928 * log10 N
        ;#  pseudocode  log2 defined as  ln N / ln 2
        ;#  pseudocode  log(base)  N defined exactly as  ln N / ln base
        ;#  end pseudocode 
        proc log2 {nn} {  expr {1.*log( $nn) / log (2) } } ;# DeWi cited Public Domain
        ;# Usage  log2 2  returns   1.0
        ;# Usage log2 16 returns   4.0
        proc log_any_base {nn base} {  expr {1.*log( $nn) / log ($base) } }    ;# DeWi cited Public Domain
        ;# Usagel og_any_base 2 2 returns 1.0
        ;# Usage log_any_base 10 10 returns 1.0
        ;# Usage log_any_base 5 10 returns 0.69897
        ;#  simple lambda in TCL  is 2 adjacent strings as < operator variable>  number
        ;# K comparator is sort of an  inverse fork as selector, choice, or decision
        proc K {a b} {set a}           ;# RS cited  Public Domain, K comparator
        ;# proc lammbda invokes the K comparator in proc K
        proc lambda {argl body} {K [set n [info level 0]] [proc $n $argl $body]}    ;# RS cited  Public Domain
        regsub -all {\d(?=(\d{3})+($|\.))} 1234567.89 {\0,}       ;# RS derived & cited  Public Domain
        ;# Usage time { regsub -all {\d(?=(\d{3})+($|\.))} 9999999999999999.99 {\0,} } 5000
        ;# 26.829 microseconds per iteration
        proc commified { nn } {regsub -all {\d(?=(\d{3})+($|\.))} $nn {\0,}}   ;# RS cited  Public Domain
        ;# Usage commified 123456789 returns  123,456,789
        ;# Usage commified  9999999999999999.99  returns  9,999,999,999,999,999.99
        ;# time {commified 9999999999999999.99} 5000 returns 27.217 microseconds per iteration
        ;# Overhead for wrapping commified was [-  27.217 26.829]  or  0.3879 microseconds per iteration        

Advanced Topic, One Liners Program Approach to OO Object Orientation system


We need a one liners program to trap the maddened Foo_Bat into a large corral. The Foo_Bat has 1 sway_back , 2 tails, 3 heads, 6 horns, 10 legs, and 12 big feet, listed in pseudocode tally. The Foo_Bat has 34 parts in our pseudocode tally. But the command Foo_Bat has been not defined in our console in the current TCL session. There should be a OO command that defines a namespace Foo_Bat. The namespace Foo_Bat should allow instance variables , procedures, commands, evals, and methods. One may set variables and define procs inside the Foo_Bat namespace or Foo_Bat corral. The states of these variables would define the existing Foo_Bat inside the namespace. Such a one liners program would effectively be a wrapper or Foo_Bat sugar for the creation of a namespace. Henceforth, the inside variables would be branded as Foo_Bat:variable_name and the inside procs would be addressed or called as Foo_Bat:proc_name. See Thingy: a one liner program OO Object Orientation System Thingy: a one-liner OO system and Namespace resolution Namespace resolution on unknown command.


A version of the easy eye calculator was loaded with thingy_OO by RS as a testbed for OO Object Orientation methods and other one liner programs in the One Liner Compendium. Also, the modified easy eye calculator has a new self_help instruction window. Aside from pasting one liners programs into the easy eye console during the trial sessions, there was interest in moving instance variables , procedures, commands, evals, and methods between the two separate namespaces and the globals for the console window and the numerical display window.The thingy_OO may be a sugar or crutch for namespaces and moving instance variables across the easy eye windows, but thingy_OO was very robust in the trials of one liners programs on the easy eye calculator. See Easy Eye Calculator and A little calculator & Thingy: a one-liner OO system from RS. Note: The two liners in A little calculator from RS is backed by the incredible power of the entire TCL 8.6 language. If one has helper procs for the display windows and invokes the compiled code and math ops notation in the TCL core and the TCLLIB library.


As understood here with the command <thingy Foo_Bat>, the easy eye calculator now has two separate namespaces, the original liner namespace and the Foo_Bat namespace. We set a new proc for global declaration < Foo_Bat proc > {args} { global e; set e $args}>. In the console display the value of $Foo_Bat::big_feet is 12. But one wishes to move $Foo_Bat::big_feet to the numerical display window. Now $big_feet is non existent in the outer program, but available inside the Foo_Bat namespace. So {Foo_Bat::> $Foo_Bat::big_feet } declares the variable to global, evaluates to 12, and move 12 to the numeric display. Hitting return on the numerical display window returns the value of 12 in two times to the console window.


Easy Eye Testbed Session with thingy_RS & OO


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

When more than one Foo_Bat is trapped or nesting inside the namespace or corral, one may begin observe the proliferation habits of Foo_Bats. In other words nested or stacked namespaces for Foo_Bats should be possible. The task in pseudocode would be 1) introduce thingy_RS into the namespace Foo_Bat, 2) use the thingy program inside Foo_Bat to create a new baby namespace, 3) load the baby namespace with instance variables and procedures. For task 1), thingy is just another procedure, so Foo_Bat proc thingy name {,...} should load a procedure called Foo_Bat::thingy. If one has Foo_Bat::thingy, the next step 2) would be to load a baby namespace as Foo_Bat::thingy Baby_Foo_Bat. Now for task 3) the namespace Baby_Foo_Bat has come into existent, one can load the baby namespace with variables and procs. For example, load the pi function of AMG into Baby_Foo_Bat as <Foo_Bat::Baby_Foo_Bat proc pi {} {expr acos(-1)}>. In the easy eye console, the command Foo_Bat::Baby_Foo_Bat::pi should return 3.14 rounded.


Observe Caution : Nesting Foo_Bats in Namespace Foo_Bat::Baby_Foo_Bat

    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"

Figure 1 : Maddened Foo_Bat in Corral


One Liners Programs Compendium FooBat pix


Figure 2 : thingy_OO action in Easy Eye Console Session screenshot 1


One Liners Programs Compendium thingy_OO screenshot one


Figure 3 : thingy_OO action in Easy Eye Console Session screenshot 2


One Liners Programs Compendium thingy_OO TWO


Figure 4 : Nesting Foo_Bats in Easy Eye Console Session screenshot 3


One Liners Programs Compendium nesting Foo_Bats


Figure 5 : Refer to TCLLib section, Following Session is Dependent on TCLLIB Math library



Chart for SI function, Sin(x) / x


One Liners Programs Compendium Si & Ci chart


Draft One Liner Credits




Credits on One Liner Programs





Appendix TCL programs and scripts


Timing Equivalent One Liners V2

        # 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        

Table of Timing 4 Procs

table printed inTCL format
session proc & mean value elements in list comment, if any
0 ladd_1 52.0 1 2 4 5 6 7 8 9 10 0.0 proc timer 2.3273999999999999 microseconds per iteration
0 ladd_2 52.0 1 2 4 5 6 7 8 9 10 0.0 proc timer 5.6311999999999998 microseconds per iteration
0 ladd_3 52.0 1 2 4 5 6 7 8 9 10 0.0 proc timer 4.3941999999999997 microseconds per iteration
0 mean_1 5.2000000000000002 1 2 4 5 6 7 8 9 10 0.0 proc timer 13.053599999999999 microseconds per iteration
0 mean_2 5.2000000000000002 1 2 4 5 6 7 8 9 10 0.0 proc timer 3.0369999999999999 microseconds per iteration
0 mean_3 5.2000000000000002 1 2 4 5 6 7 8 9 10 0.0 proc timer 2.3805999999999998 microseconds per iteration
0 ::math::mean 5.2000000000000002 1 2 4 5 6 7 8 9 10 0.0 proc timer 22 microseconds per iteration
1 ladd_1 55.141592653589797 1 2 4 5 6 7 8 9 10 3.1415926535897931 proc timer 1.7847999999999999 microseconds per iteration
1 ladd_2 55.141592653589797 1 2 4 5 6 7 8 9 10 3.1415926535897931 proc timer 7.3037999999999998 microseconds per iteration
1 ladd_3 55.141592653589797 1 2 4 5 6 7 8 9 10 3.1415926535897931 proc timer 1.7285999999999999 microseconds per iteration
1 mean_1 5.5141592653589795 1 2 4 5 6 7 8 9 10 3.1415926535897931 proc timer 8.3374000000000006 microseconds per iteration
1 mean_2 5.5141592653589795 1 2 4 5 6 7 8 9 10 3.1415926535897931 proc timer 2.2898000000000001 microseconds per iteration
1 mean_3 5.5141592653589795 1 2 4 5 6 7 8 9 10 3.1415926535897931 proc timer 2.1674000000000002 microseconds per iteration
1 ::math::mean 5.5141592653589795 1 2 4 5 6 7 8 9 10 3.1415926535897931 proc timer 6 microseconds per iteration
2 ladd_1 58.283185307179586 1 2 4 5 6 7 8 9 10 6.2831853071795862 proc timer 1.7618 microseconds per iteration
2 ladd_2 58.283185307179586 1 2 4 5 6 7 8 9 10 6.2831853071795862 proc timer 6.6627999999999998 microseconds per iteration
2 ladd_3 58.283185307179586 1 2 4 5 6 7 8 9 10 6.2831853071795862 proc timer 4.0709999999999997 microseconds per iteration
2 mean_1 5.8283185307179588 1 2 4 5 6 7 8 9 10 6.2831853071795862 proc timer 8.5307999999999993 microseconds per iteration
2 mean_2 5.8283185307179588 1 2 4 5 6 7 8 9 10 6.2831853071795862 proc timer 2.1261999999999999 microseconds per iteration
2 mean_3 5.8283185307179588 1 2 4 5 6 7 8 9 10 6.2831853071795862 proc timer 2.3512 microseconds per iteration
2 ::math::mean 5.8283185307179588 1 2 4 5 6 7 8 9 10 6.2831853071795862 proc timer 5 microseconds per iteration
3 ladd_1 61.424777960769376 1 2 4 5 6 7 8 9 10 9.4247779607693793 proc timer 1.9702 microseconds per iteration
3 ladd_2 61.424777960769376 1 2 4 5 6 7 8 9 10 9.4247779607693793 proc timer 7.1285999999999996 microseconds per iteration
3 ladd_3 61.424777960769376 1 2 4 5 6 7 8 9 10 9.4247779607693793 proc timer 2.6114000000000002 microseconds per iteration
3 mean_1 6.1424777960769372 1 2 4 5 6 7 8 9 10 9.4247779607693793 proc timer 8.5581999999999994 microseconds per iteration
3 mean_2 6.1424777960769372 1 2 4 5 6 7 8 9 10 9.4247779607693793 proc timer 2.1989999999999998 microseconds per iteration
3 mean_3 6.1424777960769372 1 2 4 5 6 7 8 9 10 9.4247779607693793 proc timer 2.4533999999999998 microseconds per iteration
3 ::math::mean 6.1424777960769372 1 2 4 5 6 7 8 9 10 9.4247779607693793 proc timer 5 microseconds per iteration
4 ladd_1 64.566370614359172 1 2 4 5 6 7 8 9 10 12.566370614359172 proc timer 1.7842 microseconds per iteration
4 ladd_2 64.566370614359172 1 2 4 5 6 7 8 9 10 12.566370614359172 proc timer 10.103400000000001 microseconds per iteration
4 ladd_3 64.566370614359172 1 2 4 5 6 7 8 9 10 12.566370614359172 proc timer 1.9608000000000001 microseconds per iteration
4 mean_1 6.4566370614359174 1 2 4 5 6 7 8 9 10 12.566370614359172 proc timer 8.8523999999999994 microseconds per iteration
4 mean_2 6.4566370614359174 1 2 4 5 6 7 8 9 10 12.566370614359172 proc timer 2.0948000000000002 microseconds per iteration
4 mean_3 6.4566370614359174 1 2 4 5 6 7 8 9 10 12.566370614359172 proc timer 2.2736000000000001 microseconds per iteration
4 ::math::mean 6.4566370614359174 1 2 4 5 6 7 8 9 10 12.566370614359172 proc timer 5 microseconds per iteration
5 ladd_1 67.707963267948969 1 2 4 5 6 7 8 9 10 15.707963267948966 proc timer 3.6421999999999999 microseconds per iteration
5 ladd_2 67.707963267948969 1 2 4 5 6 7 8 9 10 15.707963267948966 proc timer 10.6218 microseconds per iteration
5 ladd_3 67.707963267948969 1 2 4 5 6 7 8 9 10 15.707963267948966 proc timer 2.3553999999999999 microseconds per iteration
5 mean_1 6.7707963267948967 1 2 4 5 6 7 8 9 10 15.707963267948966 proc timer 8.4225999999999992 microseconds per iteration
5 mean_2 6.7707963267948967 1 2 4 5 6 7 8 9 10 15.707963267948966 proc timer 2.1343999999999999 microseconds per iteration
5 mean_3 6.7707963267948967 1 2 4 5 6 7 8 9 10 15.707963267948966 proc timer 2.1093999999999999 microseconds per iteration
5 ::math::mean 6.7707963267948967 1 2 4 5 6 7 8 9 10 15.707963267948966 proc timer 5 microseconds per iteration

Pretty Print Version

Easy Eye Testbed for Thingy_RS and Other One Liner Programs


Here is some starter code for an easy eye calculator as a testbed for one liners programs. The easy eye calculator includes large black font on green background. The human eye is peaked for yellow/green and various ergonomic studies have shown that black font on green background is one of the easiest to read. My small notepad has a linked script and icon for easy eye calculator, posted on the windows desktop of small screen, 22 by 12 cm. One advantage of the easy eye calculator is that the calculations are posted to a console window as a sort of paper tape. The easy eye calculations and text can be cut and paste, saved to a word processor. The easy eye calculator is a compilation of several eval calculators on the TCL Wiki, especially A little calculator from RS. Note: The two liners in A little calculator from RS has the incredible power of the entire TCL 8.6 language. if one has helper procs for the displays and invokes the compiled code and math ops notation in the TCL core and the TCLLIB library. Also see Easy Eye Calculator and eTCL Slot Calculator Demo Example, Numerical Analysis


A version of the easy eye calculator was loaded with thingy_OO by RS as a testbed for OO methods and other one liner programs in the One Liner Compendium. Also, the modified easy eye calculator has a new self_help instruction window. Aside from pasting one liners programs into the bottom of the easy eye console during the trial sessions, there was interest in moving instance variables , procedures, commands, evals, and methods between the two separate namespaces and the globals for the console window and the numerical display window. See Easy Eye Calculator and eTCL Slot Calculator Demo Example, Numerical Analysis and A little calculator from RS. Note: The two liners in A little calculator from RS has the entire incredible power of the entire TCL 8.6 language, if one has helper procs for the displays and invokes the compiled code and math ops notation in the TCL core and the TCLLIB library.


        # 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::*]"
        # Disclaimers: This page, screenshots, and TCL source code
        # is copyrighted under the TCL/TK license terms. 
        # Editorial rights and disclaimers retained under the TCL/TK license terms
        # and will be defended as necessary in court. My understanding
        # is that the TCL/TK copyright is intended to retain editorial control rights.


Equivalent One Liners Programs using tiny_basic_RS.tcl


     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 

Disclaimers and License


gold This page is copyrighted under the TCL/TK license terms, this license .

Disclaimers: This page, screenshots, and TCL source code is copyrighted under the TCL/TK license terms. Editorial rights and disclaimers retained under the TCL/TK license terms and will be defended as necessary in court. My understanding is that the TCL/TK copyright is intended to retain editorial control rights , and there is no disagreement with that intention here. As understood here, referencing the TCL/TK copyright pertains to legal notice maintaining the copyright as required by USA law. The Tcl Wiki has international content and other countries may have different rules.


{gold] 10/23/2020 Per Wikipedia entry of single article. The Wikipedia Senior Page editors (not gold) for Wikipedia One Liner Programs will not add above contents to Wikipedia page without the GNU/Wikipedia Commons statements below. [L23 ] I will spare the reader the back and forth from non-lawyers like me. The editor comments on [L24 ] are available on Wikipedia with W. member login. Note: The phrase "One-liner program" is used in the original Wikipedia article with the other computer languages.


{gold] 9/30/2020. This original work and single Tcl/TK Wiki page is also released under the Wikipedia:Text of the GNU Free Documentation License [L25 ] and the Wikipedia:Text of Creative Commons Attribution-ShareAlike 3.0 Unported License [L26 ] in addition to the license or licenses it is already licensed under. Refer to Wikipedia:Licensing update from Wikipedia, the free encyclopedia [L27 ]. As legal precedence, the previous TCL/TK content and example scripts in the Wiki Books TCL Programming by Richard Suchenwirth may have relevance, circa 2005 [L28 ]. """Most of these previous 2005 example scripts first appeared in the Tclers' Wiki""" Also reference 2005 pdf from [L29 ] and later 2018 pdf from Wiki Books version [L30 ]. This release action applies only to the one and only page here and should not be attributed to the rest and other pages of the TCL Wiki and global internet.


Hidden Comments Section


 ** Hidden Comments Section **

Please place any comments here with your moniker, Thanks.


  test for hidden comments stop

test! seems to work


  ** Hidden Change Log Section **

gold 11/17/2020. added sum of powers procs.