# testing negative logic for =! and ne
# procs =! and ne work on strings too
proc =! {m n} { if {[string equal $m $n]} then {return 0} else {return 1} }
# Usage liner::=! 5 5 r> 0, liner::=! 5 6 r> 1
# Usage time {liner::=! 5 5 } 5 returns 8.6 microseconds per iteration
proc ne {m n} { abs [string compare $m $n]} 
# Usage liner::ne 5 5 r> 0, liner::ne 5 6 r> 1
time {liner::ne 5 5 } 5 returns 12.6 microseconds per iteration
proc fie {m n} { abs [string compare $m $n]} 
time {fie b b } 5 ;# returns 1.6 microseconds per iteration
proc fibber {m n} { if {[string equal $m $n]} {return 0} {return 1} }
# fibber works on strings but slow 
time {fibber b b } 5  ;# returns 8.0 microseconds per iteration
# gold standard proc for eq in global space
# liner::= is same proc  in namespace liner::
proc eq {m n} {string equal $m $n}  ;# RS
time {eq 1 1 } 1000  returns 0.608 microseconds per iteration in global space
time { liner::= 1 1} 1000 returns 0.436 microseconds per iteration in namespace ::liner

              proc IsOdd { N }  { return [ expr {$N % 2} ] }
              proc IsEven { N }  { return [ expr { ( $N + 1 ) % 2} ] }
              proc IsNegative { x } { return [ expr {$x<0}]}
              proc IsPositive { x } {return [ expr {$x>0}]}

#  **********Extensions from gold **********
source playing_recursion_V2.tcl
# Suggest maintain air gaps, dead spaces, brackets;#--  >= greater than or equal to logic function
func >= {m n} {[= $n 0]? 1: [= $m 0]? 0: [>= [pred $m] [pred $n]]}
#--  >  greater than logic function
func > {m n} {[= $m $n]? 0: [>= $m $n]}
proc flipper n { [expr {$n * -1 } ] }
# func abs n { [> $n 0]? $n: [< $n 0]? [ flipper $n]:0}
set sgn5 [expr {$x>0? 1 : $x<0? -1 : 0}]    ;# RS
proc sgn5 x {set temp [expr {$x>0? 1 : $x<0? -1 : 0}]} ;# RS
proc sgn x {expr {($x>0) - ($x<0)}}  ;# RS & rmax
proc sgn7 nn { if {$nn>0} { return  1 } elseif {$nn<0} { return -1 } else { return  0 }}
time { sgn7 7   } 5000 ;# 0.4554 microseconds per iteration.
#-- triangular number. Tricky code 
#   and Suggest maintain air gaps, spaces, brackets
func tri  { n} {[< $n 2]? 1: [/  [* $n [+ $n 1] ] 2 ]}
test {tri 3} 6 {tri 2} 3 {tri 5} 15  
#-- factorial recursion, but quickly exceeds domain
#   fac is recursion limited, & excessive time beyond factorial 7
func fac n {$n<2? 1: [* $n  [fac  [pred $n ]]]}
#-- min, max, basic integer funcions
#  but may need some error checks
#  for entry zeros and equality, $m = $n
func min {m n} {$m<$n? $m: $n}
func max {m n} {$m>$n? $m: $n}
# zero_killer function swaps points of zero
# for 0.0000001 in observed data to avoid 
# computer division by zero
func kzero { n } {[= $n 0]? 0.0000001: [= $n 0.]? 0.0000001: $n }
#  ******* end extensions ************

    # under Pseudocode Section
namespace eval ::liner {
            namespace export math
        }
proc ::liner::convert {  } {  ;# before  Playing Recursion deck
    #   yada yada  }         ;# after   Playing Recursion deck
*****  enter >::liner::convert< for invoking namespace ********** 
*****  enter >::liner::demo< for code test **********  
*********  but considerable lengthy recursions **** 
(System) 1 % ::liner::convert
(System) 2 % ::liner::demo
example >>  gcd 12 24 -> 12, & expected was 12
example >>  gcd 12 18 -> 6, & expected was 6   ;# ommitted lengthy reply here
info commands ::liner::*

(System) liner::func square  { n} {[< $n 2]? 1:  [* $n  $n  ] }
    # liner::square has lengthy recursion and too many nested evaluations beyond 30
(System) 4 % liner::square 5 ;# returns 25
(System) 4 % liner::square 30 ;# returns 900
    # liner::cube has lengthy recursion and too many nested evaluations beyond 10
(System) 8 %  liner::func cube  { n} {[< $n 2]? 1: [* [* $n  $n  ]  $n ]}
(System) 9 % liner::cube 2  ;# returns 8
(System) 10 % liner::cube 4 ;#returns 64
(System) 11 % liner::cube 5 ;# returns 125
    # func rectangle_area is test of redundant logic with 5 elements
liner::func rectangle_area {l w} {[= $l 0]? 0: [= $w 0]? 0: [* $l $w]}
(System) 13 % liner::rectangle_area 5 10  ;# returns 50
    # constant for golden section, have to exactly name sqrt inside mathfunc::
liner::func gm  { n} {[< $n 2]? 1:    [expr  (1 + [::tcl::mathfunc::sqrt 5] )*.5]}
liner::test {liner::gm 4 } 1.618033988749895
example >>  liner::gm 4  -> 1.618033988749895, & expected was 1.618033988749895
   # Playing Recursion was written originally for integers.
   # But now passing pointing point calculations thru ::liner::func
   # The global namespace is recognizing the func liner::gm.
set rook  [liner::gm 4] ;# returns 1.618033988749895  
   # guess could put in a switch for ::liner::func to pass on floating points?
   # or manually swap function calls
liner::func rectangle_area2 {l w} {[= $l 0]? 0: [= $w 0]? 0: [::tcl::mathop::* $l $w]}
(System)  set house [ liner::rectangle_area2 5.2 10.1 ] ;# returns 52.52
# reciprocal func r!  has several exceptions , [= $mm 0]? avoid division by zero
# reciprocal r! has exception , [= $mm 1]? defaults to 1
# exception tests performed before main calculation of 1/$mm
#  maybe case liner::r! -2 -> -1 on negative integers has problem?
liner::func r! {mm} {  [= $mm 0]? 0:  [= $mm 1]? 1: [::tcl::mathop::/ 1  $mm] }
# Usage liner::r! 1  -> 1 ;# liner::r! 0 -> 0 ;# liner::r! 0.000001 -> 1000000.0
# liner::r! 0.000001 ->  1000000.0 ;# liner::r! -2. -> -0.5 

# AMG proc w/a?b.c recast to func inside namespace liner::
proc fib2 {n} {expr {$n < 2 ? $n : [fib2 [expr {$n - 1}]] + [fib2 [expr {$n - 2}]]}}  ;# AMG
# func has little different notation but understandable
func fib  { n } {[< $n 2 ]? $n: [+ [fib [- $n 1 ]] [fib [- $n 2 ]] ]}
# Usage fib  2 ;# returns 1 fib  5 ;# returns 5
# Usage fib  10 ;# returns 55

#  AMG proc w/a?b.c recast to func inside namespace liner::
proc fib2 {n} {expr {$n < 2 ? $n : [fib2 [expr {$n - 1}]] + [fib2 [expr {$n - 2}]]}}  #  AMG
time { fib2 10 } 1000 #   fib2 10  ->   65.842 microseconds per iteration
proc fib3 {n} {expr {$n < 2 ? $n : [fib3 [- $n 1]] + [fib3 [- $n 2]]}}  #  AMG 
time { fib3 10 } 1000  #   fib3 10  ->   64.722 microseconds per iteration
#  using mathop in part of the proc does save about 1 microsecond
#  func has little different notation from the liner:: rules but understandable
liner::func golden { n }  { [::tcl::mathop::/ [fib $n]  1. [fib [- $n 1]]  ]}
#  liner::golden 10 #   -> 1.6176470588235294, liner::golden 18 #  -> 1.6180338134001253
#  but the liner::golden was recursion limited to 18, 
#  analysis went back to a proc in global space to further check  the solution
proc golden2 { n }  { [/ [fib3 $n]  1. [fib3 [- $n 1]]  ]}
#   golden2 20  #  ->  1.6180339631667064
golden2 38  #  -> 1.618033988749894 was highest fib($n)/fib($n-1) without cobwebs on programmer
#  installing  the reciprocal '''fib(n-1)/ fin(n)''' into   liner::func golden and proc golden2
liner::func golden_ratio_conjugate { n }  { [::tcl::mathop::/ [fib [- $n 1]] 1. [fib $n]   ]}
#  Usage liner::golden_ratio_conjugate 18 -> 0.6180340557275542
proc golden2_ratio_conjugate  { n }  { [/ [fib3 [- $n 1]]  1. [fib3  $n ]  ]}
#  Usage golden2_ratio_conjugate 18 #  -> 0.6180340557275542 reasonable time delay
#  Usage golden2_ratio_conjugate 38  #  -> 0.6180339887498951 cobwebs falling

#  procs below should should be pastable into TCL Console
proc pi {} {expr acos(-1)} #  AMG  
#  Usage pi #  returns 3.141592653589793 correct 
#  expr 4.* sqrt (0.618) ->  3.1445190411253674 phi conjugate formula
proc approx_pie2 { }  {expr 4.* sqrt (.618033988749894) }
#  Usage approx_pie2 #;   3.144605511029691 approximate pi to 2 decimal places
#  Note approx_pie2 number slightly above correct answer?
proc approx_pie { n }  { [* [/ 6. 5] [** [/ [fib3 $n]  1. [fib3 [- $n 1]]] 2]]}
#  Usage approx_pie 20 #  -> 3.141640 approximate pi to 3 decimal places 
#  Note approx_pie number slightly above correct answer?
proc pix  { } {return  [expr { (4. * ( [atan  .5] + [atan [/ 1 3.] ]))}]}
#  exact double atangent formula from Euler
#  Using expr methods on *,+,& atan  archtangent
proc pieatan2  { } {return  [expr { (4. * ( atan(.5) +  atan(1/ 3.) ))}]}
#  using mathop method on *&+ and mathfunc method on atan  
proc pieatan  { } { return [* 4.   [+ [atan  .5]  [atan [/ 1 3.] ] ]  ]}
#  Usage proc pieatan  { } #  returns 3.141592653589793  exact 
time {pieatan} 5000  #  1.1686  microseconds per iteration, 
#  fairly fast using both mathop and mathfunc calls
#  pi formula from Jorge Xerxes
[* 2 [+ [atan [/ 1. [sqrt .618033988749894]]]   [atan  [sqrt .618033988749894]] ]]
#  returns  3.141592653589793 
#  piex passes through namespace liner::
liner::func piex {} {[* 2. [::tcl::mathfunc::+ [::tcl::mathfunc::atan [/ 1. [::tcl::mathfunc::sqrt .618033988749894]]]   [::tcl::mathfunc::atan  [::tcl::mathfunc::sqrt .618033988749894]] ]]}

#  following under test
#  proc fib3 has to be loaded first
proc fib3 {n} {expr {$n < 2 ? $n : [fib3 [- $n 1]] + [fib3 [- $n 2]]}}  #  AMG 
proc pie5 {} {expr {4* (atan(1./[fib3 3]) + atan(1./[fib3 4]))}}
#  Usage pie5 #     3.141592653589793  #  2 terms for atan(1./[fib3 $n] series
#  checking  terms for infinite series atan(fib(2*$n+1)]
proc fix2 {n} {expr {$n < 2 ? $n : [fix2 [expr 4* (atan(1./[fib3 [expr 2*$n+1]]))]]}}
#  Usage fix2 3   -> 0.30708756507911217   terms  of  infinite series 
proc fix3 {n} {expr {$n < 2 ? $n :[- [fix [expr 4* (atan(1./[fib3 [expr 2*$n+1]]))]]  [fix [expr 4* (atan(1./[fib3 [expr 2*$n+1+2]]))]]  ] }}
foreach i {1 2 3 4 5 6 7 8 9} {lappend rook [fix $i] };$rook' set rook {}
proc vik {n} { return [expr { 8./ ((4.*$n+1. )*( 4.*$n+3. ))}]}
#  Usage  vik 7 -> 0.008898776418242492 #  individual terms for pi series
foreach i {1 2 3 4 5 6 7 8 9} {lappend rook " [vik $i] + " };$rook ;  set rook {}
#  following is experimental kludge combination,
#  but some of the atan series for pi have
#  2,3,4, or more terms, which can be 
#  zeroed out or fill in the blanks. 
proc fix {n} {expr {$n < 2 ? $n : [fix  [expr {.000001* atan ( 1. / (2.*$n-1) )+ .0000001* atan ( 1. / (2.*$n-1) )}]] +  [- [* 16. [atan [/ 1. 5]]] [* 4. [atan [/ 1. 239]]  ] ]}}
#  Usage  fix 3 #  -> 3.1415928509853535
#  Chinese fractions for pi from Zu Chongzhi, fifth century, 429-500 CE
#  Jiu zhang suanshu,  Nine chapters of the mathematical art 
liner::func pie_poly2 {} {[::tcl::mathop::/ 355. 113. ] } #  liner:: namespace use
proc pie_poly {} {[/ 355. 113.]}  #  global namespace use
#  Usage  pie_poly #  -> 3.1415929203539825 accurate to 6 places
#  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
proc piez {} {[expr {4.*atan (1./sqrt(2))+2.*atan(1./sqrt(8))}]}
#  Usage piez #  returns 3.141592653589793

#  base functions loaded into namespace liner::
proc eq {m n} {string equal $m $n}  #  RS
proc succ x {incr x}  #  RS
#   liner:: has shorter symbolic names
#   for the two basic functions:
proc '  x    {incr x}    #  RS 
proc = {m n} {string equal $m $n}  #  RS
#  formula for Sum of Integers is n*(n+1)/2
#  initial sum of integers code
#  reporting endless loops with w/4 terms
liner::func sum_int  { n} {[< $n 2]? 1:    [expr [/ [* $n [succ $n ]] 2 ]]}
#  Usage liner::sum2 3 #   -> 6 correct for sum 1  + 2 + 3
#  helper functions 2X and 3X,
#  following liner:: rules
liner::func int_2x  { n} {[< $n 1]? 1:    [expr  [* $n  2 ]]}
liner::func int_3x  { n} {[< $n 1]? 1:    [expr  [* $n  3 ]]}
#  formula for Sum of Squares is n*(n+1)*(2*n+1)/6
liner::func sum_squares  { n} {[< $n 1]? 1:    [expr [/ [* [* $n [succ $n ]]  [succ [int_2x $n] ]   ] 6 ]]}
#  Usage liner::sum_squares 3  #  -> 14 correct for sum 1 + 4 + 9

# formula for Sum of Cubes is (n**2) ((n + 1)**2) / 4 
func sum_cubes { n} {[< $n 1]? 0:[=  $n 1]?   1: [expr [/ [* [* $n $n]  [* [succ $n] [succ $n] ]   ] 4 ]]}
# defined for positive integers, two ? conditionals in expr
# Usage sum_cubes 0 -> 0, sum_cubes 1 -> 1, sum_cubes 2 -> 9

#  formula sum_4th_power = 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 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
func helper   {n } {  [ +   [ int_3x [square $n] ]    [pred  [ int_3x $n ]]]}
func helper2 {n}     { [* $n [*  [ succ $n ] [succ [int_2x $n ]]]] }
func sum_4th_power2 { n} {[< $n 1]? 0:[=  $n 1]?   1: [expr [/ [* [helper $n]  [helper2 $n] ] 30 ]]}
proc tester_4x {n} {
if { [< $n 1]  } { set res 0; break}
if { [= $n 1]  } { set res 1; break}
set term1 [helper $n]
set term2 [helper2 $n]
set res [expr { ($term1 * $term2 ) / 30 } ]
}
#  Usage liner::tester_4x 5 -> 979
#  reporting nested evals after 5

# formula sum_5th_power = 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

#   TNX =  aa * bb = TN <aa-1> +  TN <bb> - TN <aa-bb-1>
#  may need some helper functions inside liner:: if n>m
#  for now, m > n
liner::func max {m n} {$m>$n? $m: $n}
# -- the difference (defined only for m >= n)
func - {m n} {[= $n 0]? $m: [- [pred $m] [pred $n]]}
#  test {- 12 7} 5 {- 1 1} 0 {- 0 0} 0
liner::func first_term  {m n} { [+ [tri [pred $m ]] [tri $n]] }
liner::first_term 5 3  #  -> 16
liner::func third_term  {m n} {  [tri [- [- $m  $n ] 1 ]  ]  }
liner::third_term 5 3  #    ->  1
liner::func trix {m n} { [- [+ [tri [pred $m ]] [tri $n]]  [tri [- [- $m  $n ] 1 ]  ]    ]}
#  Usage liner::trix 5 3 -> 15   #  m > n because subtraction call for this
#  Usage liner::trix 30 5 -> 150   #  m > n  
#  but too many  nested evals beyond m = 30

            # pretty print autoindent from ased editor
            # trial console operation
            # Playing Recursion V2
            # demo examples for one liner programs 
            # written on Windows 10 on ActiveTcl
            # working under TCL version 8.6
            # gold on TCL Club , 05ct2020
            # console has large black type on green
            # used as testbed for integer arithmetic
            # Playing with Recursion V2 ???
            # Playing with Recursion is TCL wiki page by RS
            # < positive integers > function procs written by RS
            # gold added cosmetics in console deck
            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 }
            namespace path {::tcl::mathop ::tcl::mathfunc}
            set tclprecision 17
            # RS main deck
            proc succ { x } {incr x} 
            # Note. procs succ and proc eq loaded in both decks
            # for global and namespace ::liner::
            # equality of integers in canonical form can,
            # without using expr, be had as
            proc eq {m n} {string equal $m $n}  
            # proc eq  works with strings and numbers 
            # McCarthy advocates "conditional expressions",
            # alternating sequences of {condition} {result} like
            #  A B C D ...
            # which can in Tcl (and many other languages)
            # be implemented as variables & conditionals
            # if $A then $B elseif $C then $D ...
            # or more compactly with expr's ?: ternary operator:
            # $A? $B: $C? $D: ...
            # using expr in these experiments only for the ?: operator
            # before  Playing Recursion deck
            # begin namespace liner
            namespace eval ::liner {
            namespace export math
            namespace path {::tcl::mathop ::tcl::mathfunc}
            # before  Playing Recursion deck RS
            proc eq {m n} {string equal $m $n}  
            proc succ { x } {incr x} 
            proc func {name argl body} {proc $name $argl [list expr $body]}
            # here's a tiny multi-case tester:  -RS
            # added puts for console result to original proc test1
             proc test1 args {
                foreach {case expected} $args {
                    catch {uplevel 1 $case} res
                    if {$res != $expected} {error "$case->$res, expected $expected"}
                }
            }
            proc test args {
                foreach {case expected}  $args  {
                    catch {uplevel 1 $case} res
                    if {$res != $expected} {error "$case->$res, expected $expected"}
                    puts "example >>  $case -> $res, & expected was $expected" 
                }
            }
            proc demo {} {
            test {gcd 12 24} 12 {gcd 12 18} 6 {gcd 17 19} 1
            test {' 0} 1 {' 42} 43
            test {= 0 0} 1 {= 0 42} 0 {= 42 42} 1
            test {pred 42} 41 {pred 1} 0
            test {+ 3 4} 7
            test {* 3 4} 12
            test {- 12 7} 5 {- 1 1} 0 {- 0 0} 0
            test {<= 1 2} 1 {<= 2 2} 1 {<= 3 2} 0
            test {< 1 2} 1 {< 2 2} 0 {< 3 2} 0
            test {/ 1 2} 0 {/ 2 2} 1 {/ 3 2} 1 {/ 42 2} 21
            test {rem 1 2} 1 {rem 2 2} 0 {rem 3 2} 1
            test {| 2 42} 1 {| 2 43} 0 {| 2 3} 0
            test {prime 2} 1 {prime 3} 1 {prime 4} 0 {prime 5} 1 {prime 6} 0 {prime 7} 1  
            test {flipper 2} -2 {flipper -5} 5 {flipper 111} -111 {flipper 1} -1
            test {kzero 2 } 2 {kzero -5 } -5 {kzero 0 } .0000001 {kzero 5 } 5
            }           
            # Following McCarthy's notation,  use  from RS
            # shorter symbolic names for the two basic functions:
            proc ' { x }   {incr x}   
            # test {' 0} 1 {' 42} 43
            proc = {m n} {string equal $m $n} 
            # RS main deck
            proc succ { x } {incr x}
            # equality of integers in canonical form can,
            # without using expr, be had as
            proc eq {m n} {string equal $m $n}  
            # proc eq  works with strings and numbers 
            # McCarthy advocates "conditional expressions",
            # alternating sequences of {condition} {result} like
            #  A B C D ...
            # which can in Tcl (and many other languages)
            # be implemented as variables & conditionals
            # if $A then $B elseif $C then $D ...
            # or more compactly with expr's ?: ternary operator:
            # $A? $B: $C? $D: ...
            # using expr in these experiments only for the ?: operator
            # before  Playing Recursion deck
            # Following McCarthy's notation,  use   -RS
            # shorter symbolic names for the two basic functions:
            proc ' { x }   {incr x}   
            # test {' 0} 1 {' 42} 43
            proc = {m n} {string equal $m $n} 
            # test {= 0 0} 1 {= 0 42} 0 {= 42 42} 1
            # The partial converse of the successor function is the predecessor
            # "the non-negative integer before"),
            # where the auxiliary function pred2 uses recursion
            #  - it calls itself (as most of the following will).
            # The next definitions are a mechanical
            # transcription to Tcl of McCarthy's:
            func pred  { n }   {[pred2 $n 0]}
            func pred2 {n m} {[= [' $m] $n]? $m: [pred2 $n [' $m]]}
            # test {pred 42} 41 {pred 1} 0
            #-- This allows us to define the sum:
            func + {m n} {[= $n 0]? $m: [+ [' $m] [pred $n]]}
            # test {+ 3 4} 7
            #-- the product
            func * {m n} {[= $n 0]? 0: [+ $m [* $m [pred $n]]]}
            # test {* 3 4} 12
            #-- the difference (defined only for m >= n)
            func - {m n} {[= $n 0]? $m: [- [pred $m] [pred $n]]}
            # test {- 12 7} 5 {- 1 1} 0 {- 0 0} 0
            #-- the inequality predicate <=
            func <= {m n} {[= $m 0]? 1: [= $n 0]? 0: [<= [pred $m] [pred $n]]}
            # test {<= 1 2} 1 {<= 2 2} 1 {<= 3 2} 0
            #-- leading to the strict inequality <
            func < {m n} {[= $m $n]? 0: [<= $m $n]}
            # test {< 1 2} 1 {< 2 2} 0 {< 3 2} 0
            #-- Integer division goes like this:
            func / {m n} {[< $m $n]? 0: [' [/ [- $m $n] $n]]}
            # test {/ 1 2} 0 {/ 2 2} 1 {/ 3 2} 1 {/ 42 2} 21
            #-- Integer division remainder (% in expr)
            func rem {m n} {[< $m $n]? $m: [rem [- $m $n] $n]}
            # test {rem 1 2} 1 {rem 2 2} 0 {rem 3 2} 1
            #-- Divisibility of a number n by a number m
            func | {m n} {[= $n 0]? 1: [< $n $m]? 0: [| $m [- $n $m]]}
            # test {| 2 42} 1 {| 2 43} 0 {| 2 3} 0
            # Primeness of a number uses another auxiliary helper function.
            func prime  { n }   {[= $n 0]? 0: [= $n 1]? 0: [prime2 $n 2]}
            func prime2 {m n} {[= $m $n]? 1: [| $n $m]? 0: [prime2 $m [' $n]]}
            # test {prime 2} 1 {prime 3} 1 {prime 4} 0 {prime 5} 1 {prime 6} 0 {prime 7} 1
            #-- Greatest common denominator, according to Euclid's algorithm:
            func gcd {m n} {[<= $n $m]?        [gcd $n $m]:
                [= [rem $n $m] 0]? $m:
                [gcd [rem $n $m] $m] }
            #  **********Extensions from gold **********
            # Suggest maintain air gaps, dead spaces, brackets
            proc IsOdd { N }  { return [ expr {$N % 2} ] }
            proc IsEven { N }  { return [ expr { ( $N + 1 ) % 2} ] }
            proc IsNegative { x } { return [ expr {$x<0}]}
            proc IsPositive { x } {return [ expr {$x>0}]}
            #--  >= greater than or equal to logic function
            func >= {m n} {[= $n 0]? 1: [= $m 0]? 0: [>= [pred $m] [pred $n]]}
            #--  >  greater than logic function
            func > {m n} {[= $m $n]? 0: [>= $m $n]}
            # proc kzero  { n }   { return [expr $n ] }
            func kzero  { n }   {[= $n 0]? 0.0000001: [= $n 0.]? 0.0000001: $n }
            proc flipper { n } { return [expr {$n * -1 } ] }
            # func abs { n } {[< $n 0]? $n:[ flipper $n } ]}
            proc sgn { x } {expr {($x>0) - ($x<0)}
            #-- triangular number. Tricky code 
            #   and Suggest maintain air gaps, spaces, brackets
            func tri  { n } {[< $n 2]? 1: [/  [* $n [+ $n 1] ] 2 ]}
            # test {tri 3} 6 {tri 2} 3 {tri 5} 15  
            #-- factorial recursion, but quickly exceeds domain
            #   fac is recursion limited, & excessive time beyond factorial 7
            func fac  { n } {$n<2? 1: [* $n  [fac  [pred $n ]]]}
            #-- min, max, basic integer funcions
            #  but may need some error checks
            #  for entry zeros and equality, $m = $n
            func min {m n} {$m<$n? $m: $n}
            func max {m n} {$m>$n? $m: $n}
            # zero_killer function swaps points of zero
            # for 0.0000001 in observed data to avoid
            # computer division by zero
            # testing funcs here
            # func kzero  { n }   {[= $n 0]? 0.0000001: [= $n 0.]? 0.0000001: $n }
            # func kzero  { n }   { return $n }
            # computer division by zero
            #  ******* end extensions ************
            # critical bracket end of namespace, must be present
            }
            # but if gone, hard to spot from dire consequences  
            #   yada yada inside namespace ::liner::  =}      
            # after   Playing Recursion deck
            proc !! {} {info commands ::liner::* }
            proc $$ {} {puts " namespace ::liner:: activated , info commands is !! " }
            proc && {} {puts " namespace ::liner::demo activated  " ; ::liner::demo }
            puts " *****  enter   to invoke namespace ::liner::* or $$    "
            puts " *****  enter  liner::func_name to invoke single func **********  "
            puts " *****  list cmds with info commands ::liner::* or !! "
            puts " *****  enter  liner::demo  for code test *** or &&   "
            puts " *******  but considerable lengthy recursions **** "   
            puts " ***** Self_Help under Help button of ActiveTcl Console ***    "                 
            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 . "  Playing with Recursion V2, 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 Wiki,
                self help listing
                Conventional text editor formulas grabbed
                from internet screens can be pasted
                into green console
                # testbed & demo_recursion_functional_programming
                # demo command is demo 
                # suggest maintain dead spaces and air gaps
                # near expr, brackets, etc in following statements
                # written on Windows 10 on TCL
                # working under TCL version 8.6
                # gold on TCL Club , 05ct2020
                # easy eye console has large black type on green
                # used as testbed for integer arithmetic
                # Playing with Recursion V2 
                # Playing with Recursion is TCL wiki page
                # < positive integers > function procs written by RS
                # gold added cosmetics
                # some extension funcs and procs experiment with reals
                # equality of integers in canonical form can,
                # without using expr, be written
                # proc eq  is TCL string function
                # McCarthy advocates <conditional expressions>,
                # alternating sequences of {condition} {result} 
                # which can in Tcl (and many other languages)
                # be implemented as variables & conditionals
                # if \$\A then \$\B elseif \$\C then \$\D ...
                # or more compactly with expr's ?: ternary operator:
                # \$\A\? \$\B\: \$\C\? \$\D\: ...
                # using expr in these experiments only 
                # for the ?: operator
                # The partial converse of the successor function is the predecessor
                # the non-negative integer before,
                # where the auxiliary function pred2 uses recursion
                # meaning it calls itself (as many here will).
                # There's a tiny multi-case tester:  from RS
                # after   Playing Recursion deck
                # proc !!  info commands ::liner::*  
                # proc $$   puts   namespace ::liner:: activated ,
                # info commands is !!   
                # proc && puts namespace ::liner::demo activated 
                #   ; ::liner::demo 
                # list cmds with < info commands ::liner::* >  or !! 
                # \demo   added puts result to original proc test1
                # demo integer functions  from RS, TCL Wiki "
                tk_messageBox -title "self_helpxx" -message $msg } }
                console eval {.menubar.help add command -label Self_Help -command self_helpx }
                # Disclaimers: 10/01/2020
                # end of file

        # written on Windows 10 in  ActiveTCL
        # working under TCL version 8.6
        # gold on TCL Club , 25sep2021
        package require math::numtheory
        package require math::constants
        package require math
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory math::constants }
        # Tcllib:math paths to compare timings inside Tcllib and namespace liner
        # logic tests for even,  odd, positive, negative,  conditions of positive  numbers
        # uses logic inside expr , if positive return 1, if not positive return 0
        proc isPositive { n } {return [ expr {$n > 0}]}
        # Richard Suchenwirth RS idea  in Math Sugar
        # uses logic inside expr, if negative return 1, if not negative return 0
        proc isNegative  { n }  { return [ expr {$n < 0}]}
        # Richard Suchenwirth RS idea from wiki: Math Sugar
        # No error traps or safety nets here for negative and real numbers.
        # conditional proc  IsOdd,  if N odd, return 1, if N not odd, return 0.
        proc IsOdd { n }  { return [ expr {$n % 2} ] }
        # Usage
        IsOdd 5  ;# returns 1
        # conditional proc IsEven,  if N even,  return 1. If N not even return 0.
        proc IsEven { n }  { return [ expr { ( $n + 1 ) % 2} ] }
        # IsEven 4 ;# returns 1
        # following functions used in namespace liner
        func isPositive {n] { $n>0? 1: 0 }
        func isNegative {n} { $n<0? 1: 0 }
        func isOdd {n} { ( $n % 2 ) ? 1: 0 }
        func isEven {n} { ( $n % 2 ) ? 0: 1 }
        # liner::isNegative 5 ;# returns 0
        # liner::isNegative -5 ;# returns 1
        # liner::isOdd 5 ;#  returns 1
        # liner::isOdd 4  ;#  returns 0
        # liner::isEven 4  ;# returns 1
        # liner::isEven 5  ;# returns 0

;# pretty print from autoindent and ased editor
;# step_function_table V2
;# testbed for One Liners Program
;# written on Windows 10 on Tcl 8.6
;# working under Tcl version 8.6
;# gold on Tcl Club , 2020-10-18
;# Ref. WIKI BOOKS, Tcl_Programming_Introduction
;# Book Section  contrasts one liners program
;# 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
set tcl_precision 3
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}
;# model if procedure from RS derived
;# for conditional if_elseif_else statement
;# reasonably fast too for Tcl script
;# merely string text assignments, 
;# no extra math calculation after then
;# from Modeling COND with expr on Tcl Wiki
;# alternates after then is either return $sgn ,
;#  return 1 , or return 0
;# vis set statement
proc model_proc_sgn nn {
# standard multi-test if from RS derived
if {$nn>0} {
  set sgn  1
} elseif {$nn<0} {
set sgn -1
} else {
set sgn  0
}
;# one liner program  step_function on extended line
proc step_function nn { if {$nn<-1} { return  0 } elseif {$nn<0 } /
{ return 1 } elseif {$nn==0} { return 1 } elseif { $nn<1} / 
{ return 1 } elseif {$nn>1 } { return 0 } else { return  0 }}
set limit 20
puts "%|table| | printed in|Tcl format |% "
puts "&| session| proc &  mean value|  comment, if any|& "
for { set i -10 } { $i <= $limit }  { incr i } {
    ;# set lister { 1 2 4 5 6 7 8 9 10 }
    ;# lappend lister  [* $i [pie]]
    puts "&| [* $i .2 ]   |step_function [ step_function [* $i .2 ] ]  |   |&"
     }
    ;# end of file     

           # gold on TCL Club , 05ct2020
            # console has large black type on green
            # used as testbed for integer arithmetic
            # Test namespace player for Recursion V2 ???
            # lines reduced for test of namespace
            # Playing with Recursion is TCL wiki page by RS
            # < positive integers > function procs written by RS
            # gold added cosmetics in console deck
            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 }
            namespace path {::tcl::mathop ::tcl::mathfunc}
            set tclprecision 17
            proc func {name argl body} {proc $name $argl [list expr $body]}
            # func tri  { n } {[< $n 2]? 1: [/  [* $n [+ $n 1] ] 2 ]}
            # proc func {name argl body} {proc $name $argl [list expr $body]}
            func tri  { n } {[< $n 2]? 1: [/  [* $n [+ $n 1] ] 2 ]}
            puts "  ****** begin namespace player 1 ******** "
            # begin namespace player
            namespace eval player {
            namespace export math
            package require Tk
            # Note: Namespace  has to have mathop and mathfunc
            # installed for some functions and procs to work.
            namespace path {::tcl::mathop ::tcl::mathfunc}
            puts "  ****** begin namespace player 2 ******** "
            proc func {name argl body} {proc $name $argl [list expr $body]}
            func tri  { n } {[< $n 2]? 1: [/  [* $n [+ $n 1] ] 2 ]}
            # end bracket for namespace player
            }
            # end bracket for namespace player
            console show
            set rrr [ tri 5 ]
            puts  " check player [ tri 5 ] "
            puts  " check player [  player::tri 5 ] "