Gauss Approximate Number of Primes and eTCL demo example calculator, numerical analysis  edit

Page contents

 Gauss Approximate Number of Primes and eTCL demo example calculator, numerical analysis  

 Introduction

 Gauss approximation 

  Legendre and  Modified_Legendre approximations 

 devil's notch in Pcf(x)

 Ribeiro approximation and extensions 

  Riemann fluctuatons in prime counting function 

 Table: Rarity of Primes as percent reported from Modified_Legendre_primes function

 Testcases Section

  Testcase 1 

  Testcase 2 

  Testcase 3 

  Testcase 4 

  Testcase 5 

  Testcase 6 

  Testcase 7 ,  devil's notch  

 Screenshots Section

 figure 1.

 figure 2.

 figure 3.

 figure 4.

 figure 5.

 figure 6.

 figure 7.

 figure 8.

 figure 9.

 figure 10.

 figure 11.

 figure 12.

 References:

 Appendix Code

 appendix TCL programs and scripts 

  Pushbutton Operation

  Console program used to build csv spreadsheet charts.

  Console program for devil's notch 

  Alternate Console programs for prime_counting_function 

  Console program for sum of reciprocal squares of prime numbers.

 Table for  prime_zeta_function 

 References:

 Comments Section

Introduction edit

Gauss approximation  edit

Legendre and Modified_Legendre approximations  edit

        # following statements can be pasted into TCL console
        set project 1.0
        proc gaussian_primes {n} { return [/ $n [log $n] ]    }
        puts "gaussian_primes [ gaussian_primes 100   ] " #  answer 21.71472409516259 
        proc legendre_primes2 {n} { return [/ $n [- [log $n] 1.] ]   }
        puts "legendre_primes2 [ legendre_primes2 100   ] " #  answer 27.73794157864211 
        proc modified_legendre_primes3 {n} { return [/ $n [- [log $n] 1.08366] ]   }
        puts "modified_legendre_primes3 [ modified_legendre_primes3 100   ] "  #  answer 28.39690778061494 
        #  answer 25 prime_counting_functionx for 100   is    25         #  answer 25
        # nth prime f(x) =~~ 1.13*log(x)
        proc mod_percent {n} { set aa [/ $n [- [log $n] 1.08366] ] ;return [* [/ $aa $n ] 100. ]  }
        # percentage of primes at given number n from modified_legendre_primes3
        # shows increasing rarity of primes as n increases beyond 1E12
        # Riemann Hypothesis Equivalent, For all x => 2.01,abs {prime_pi(x) − Li(x)} =< sqrt(x) * log(x).
        # prime number theorem,  Li(x)=∼~ prime_pi(x) 

devil's notch in Pcf(x) edit

Ribeiro approximation and extensions  edit

Riemann fluctuatons in prime counting function  edit

Table: Rarity of Primes as percent reported from Modified_Legendre_primes function edit

Testcases Section

Testcase 1

Testcase 2

Testcase 3

Testcase 4

Testcase 5

Testcase 6

Testcase 7 , devil's notch

Screenshots Section

figure 1.

figure 2.

figure 3.

figure 4.

figure 5.

figure 6.

figure 7.

figure 8.

figure 9.

figure 10.

figure 11.

figure 12.

References:

• Primes
• Oneliner's Pie in the Sky
• One Liners
• Comparing Tcl and Python
• Primes Sieve - on a resizable canvas from uniquename
• TCLLIB ::math::numtheory
• https://en.wikipedia.org/wiki/Prime-counting_function
• http://sweet.ua.pt/tos/primes.html#i
• http://mathworld.wolfram.com/PrimeCountingFunction.html
• http://www.math.uni-bonn.de/people/jbuethe/topics/AnalyticPiX.html
• http://primes.utm.edu/notes/rh.html
• http://numbers.computation.free.fr/Constants/Primes/pixtable.html
• http://numbers.computation.free.fr/Constants/constants.html
• on line prime number generator, see
• http://www.miniwebtool.com/list-of-prime-numbers/?to=50
• Mathematician pair find prime numbers aren't as random as thought, March 15, 2016 by Bob Yirka,
• ref Robert Lemke Oliver and Kannan Soundararajan, Stanford University
• google < Prime number theorem Wikipedia >
• Probability that a number is prime, John D. Cook, 6 October 2010
• Probability of Next Prime Digit, Kevin's Math Page, Kevin Gong,March 17th, 2016
• Mathematicians Discover Prime Conspiracy, Erica Klarreich , March 13, 2016, Quanta Magazine
• Prime Probability: Catch the Wave, Michael M. Ross , Excel spreadsheet, Jan2008
• Prime Numbers and Their Statistical Properties,Dr. Phillip M. Feldman
• 19TH CENTURY MATHEMATICS - GAUSS, The Story of Mathematics
• A Conjecture about the Density of Prime Numbers,
• Lincoln Almir AMARANTE RIBEIRO, Departamento de Física,
• Universidade Federal de Minas Gerais, good explanation
• Dan Rockmore Stalking the Riemann Hypothesis, The Quest to Find the Hidden Law of Prime Numbers
• J. Pintz. On Legendre's prime number formula. Amer. Math. Monthly 87 (1980)
• Dusart, Pierre. Estimates of some functions over primes without r.h
• Ref. proc sum_primes_to by dkf
• from Comparing Tcl and Python on TCL WIKI
• Ref. Sieve of Eratosthenes « Python recipes « = code.activestate.com/recipes/117119/

Appendix Code edit

appendix TCL programs and scripts

        # pretty print from autoindent and ased editor
        # Gauss approximate number of primes calculator
        # written on Windows XP on eTCL
        # working under TCL version 8.5.6 and eTCL 1.0.1
        # gold on TCL WIKI, 15may2016
        package require Tk
        package require math::numtheory
        #namespace path {math::numtheory}
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        frame .frame -relief flat -bg aquamarine4
        pack .frame -side top -fill y -anchor center
        set names {{} {interval number L1  :} }
        lappend names {end number L2  :}
        lappend names {optional, if one & L2 < 190,  invoke exact solution (? long!!): }
        lappend names {answers: gauss function ~number_primes for N1 :}
        lappend names {legendre function ~number_primes for N1 :}
        lappend names {gauss approx number of primes from zero: }
        lappend names {gauss approx number of primes from zero to interval start: }
        lappend names {gauss number of primes over interval:} 
        foreach i {1 2 3 4 5 6 7 8} {
            label .frame.label$i -text [lindex $names $i] -anchor e
            entry .frame.entry$i -width 35 -textvariable side$i
            grid .frame.label$i .frame.entry$i -sticky ew -pady 2 -padx 1 }
        proc about {} {
            set msg "Calculator for Gauss Approximate Number of Primes 
            from TCL WIKI,
            written on eTCL "
            tk_messageBox -title "About" -message $msg } 
            # ref. TCLLIB::math::numtheory::prime_counting_functionx 
            # ref. alternate TCLLIB::math::numtheory::isprime 
             proc prime_counting_function { start  end } {
             set start [int $start ]
             set end [int $end ]
             set counter 0
             if { $start > 1  } { set counter  $start  } 
             set end  $end 
             set prime_counting_function 0
             while { $counter < $end  } {
             incr counter 
             incr  prime_counting_function  [isprime $counter ] 
             }
             return $prime_counting_function }  
       proc calculate {     } {
            global answer2
            global side1 side2 side3 side4 side5
            global side6 side7 side8 
            global switch_factor big_giant_list legendre_function
            global testcase_number 
            incr testcase_number 
            set side1 [* $side1 1. ]
            set side2 [* $side2 1. ]
            set side3 [* $side3 1. ]
            set side4 [* $side4 1. ]
            set side5 [* $side5 1. ]
            set side6 [* $side6 1. ]
            set side7 [* $side7 1. ]
            set side8 [* $side8 1. ]
            set L1 $side1  
            set L2 $side2  
            set N1 $side2 
            set switch_factor $side3 
            set approx_number_primes [/ $N1   [log $N1 ] ] 
            set legendre_function  [/ $N1   [- [log $N1 ] 1.08366 ] ] 
            # conditions, all numbers real and positive. 
            # conditions L1 =! 1 and L2 > L1, otherwise division by zero and undefined Q's.
            # if { $L1 == 1.0 } { set $L1 0.0 } 
            set approx_number_primes_interval_start [/ $L1   [log $L1 ] ]
            set approx_number_primes_over_interval [- [/ $L2   [log $L2 ] ] [/ $L1   [log $L1 ] ] ]
            set side4 $approx_number_primes
            set side5 $legendre_function
            set side6 $approx_number_primes 
            set side7 $approx_number_primes_interval_start
            set side8 $approx_number_primes_over_interval
            if { $switch_factor > 0 && $L2 < 200 } { exact_solution } 
                    }
            proc listprimes { aa bb} {lappend booboo 2.0; for {set i 1} {$i<=$bb} {incr i 2} { if {[isprime $i] } {lappend booboo [expr 1.*$i]   } };return $booboo}
            #returns list of prime numbers  from aa to bb, usage [listprimes 0 25],
            # answer is 2.0 3.0 5.0 7.0 11.0 13.0 17.0 19.0 23.0, 
            # list returned as real numbers, not counting 1.0 unity
               proc exact_solution {} {
            global side1 side2 side3 side4 side5
            global side6 side7 side8 big_giant_list prime_counting 
            set big_giant_list  [ listprimes $side1 $side2 ]           
            set side8 [ llength $big_giant_list ] 
             }
        proc fillup {aa bb cc dd ee ff gg hh} {
            .frame.entry1 insert 0 "$aa"
            .frame.entry2 insert 0 "$bb"
            .frame.entry3 insert 0 "$cc"
            .frame.entry4 insert 0 "$dd"
            .frame.entry5 insert 0 "$ee"
            .frame.entry6 insert 0 "$ff" 
            .frame.entry7 insert 0 "$gg"
            .frame.entry8 insert 0 "$hh" 
             }
        proc clearx {} {
            foreach i {1 2 3 4 5 6 7 8 } {
                .frame.entry$i delete 0 end } }
        proc reportx {} {
            global side1 side2 side3 side4 side5
            global side6 side7 side8
            global switch_factor big_giant_list legendre_function
            global testcase_number
            console show;
            puts "%|table $testcase_number|printed in| tcl wiki format|% "
            puts "&| quantity| value| comment, if any|& "
            puts "&| testcase number:|$testcase_number | |&"
            puts "&| $side1 :|interval L1   |   |&"
            puts "&| $side2 :|end number L2  | |& "  
            puts "&| $side3 :|optional,if one,  invoke exact solution (? long) | |& "
            puts "&| $side4 :|answers: gauss function ~number_primes| |&"
            puts "&| $side5 :|legendre function ~number_primes| |&"
            puts "&| $side6 :|gauss approx_number_primes  |  |&"
            puts "&| $side7 :|gauss approx_number_primes_interval_start |  |&"
            puts "&| $side8 :|gauss number_primes_over_interval |  |&" 
            puts "&| $legendre_function :|legendre_function number_primes_N1|  |&"
            if {$switch_factor > 0.0} { puts "&| [prime_counting_function $side1 $side2  ] :|prime_counting_function over interval|  |&" }
            if {$switch_factor > 0.0 && $side2 < 190.} {puts "&| $big_giant_list :|list number_primes_over_interval |  |&" }
            }
        frame .buttons -bg aquamarine4
        ::ttk::button .calculator -text "Solve" -command { calculate   }
        ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 0.0 1E1 1.0 4.3  8.20  4.3 0.00 4.30}
        ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 0.0 5.0 1.0 3.1  9.50  3.1 0.00 3.10 }
        ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 1E3 1E6 1.0 7E5  7E5 72382.0 0.0 72382.0 }
        ::ttk::button .clearallx -text clear -command {clearx }
        ::ttk::button .about -text about -command {about}
        ::ttk::button .cons -text report -command { reportx }
        ::ttk::button .exit -text exit -command {exit}
        pack .calculator  -in .buttons -side top -padx 10 -pady 5
        pack  .clearallx .cons .about .exit .test4 .test3 .test2   -side bottom -in .buttons
        grid .frame .buttons -sticky ns -pady {0 10}
               . configure -background aquamarine4 -highlightcolor brown -relief raised -border 30
        wm title . "Gauss Approximate Number of Primes Calculator"

Pushbutton Operation

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

Console program used to build csv spreadsheet charts.

                  # autoindent from ased editor
                  # console program for graph numbers 
                  # written on Windows XP on eTCL
                  # working under TCL version 8.5.6 and eTCL 1.0.1
                  # TCL WIKI , 12dec2016
             console show
             package require math::numtheory
             #namespace path {math::numtheory}
             namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
             set tcl_precision 17
             proc factors {} {
             set counter 0
             set prime_counting_function 0
             while {$counter < 500} {
             puts " [* $counter 1.] ,  [/ [* $counter 1.] [log [* $counter 1.]] ],  [isprime $counter ],  $prime_counting_function   "
             incr counter 
             incr  prime_counting_function  [isprime $counter ] 
             }
             return }
             factors

 2.0 ,  2.8853900817779268,  1,  1   
 3.0 ,  2.7307176798805122,  1,  2   
 4.0 ,  2.8853900817779268,  0,  2   
 5.0 ,  3.1066746727980594,  1,  3   
 6.0 ,  3.3486637593074837,  0,  3   
 7.0 ,  3.5972883965882549,  1,  4   
 8.0 ,  3.8471867757039027,  0,  4   
 9.0 ,  4.0960765198207678,  0,  4   
 10.0 ,  4.3429448190325175,  0,  4   

             # under test, biasing approx. from interval to save computer time
       proc prime_counting_function { start  end } {
             set counter 0
             if { $start > 1  } { set counter [int $start ]  } 
             set end [int $end ] 
             set prime_counting_function 0
             while { $counter < $end  } {
             incr counter 
             incr  prime_counting_function  [isprime $counter ] 
             }
             return $prime_counting_function }  
        proc biased_count { N1    } {
             set N1 [int $N1 ]
             set bias1 [* 1. [ prime_counting_function [int  [* $N1 .99] ] $N1 ]]
             set bias2  [* 1. [ prime_counting_function $N1 [int [* $N1 1.01]]   ]]
             puts " $bias1 "
             puts " $bias2 "
             set bias 1.
             set approx_number_primes 1.
             set bias [expr  $bias2/ double($bias1)  ] 
             puts " $bias $bias2   $bias1 "
             set approx_number_primes [* [/ $N1   [log $N1 ] ] $bias ]
             return $approx_number_primes
             }

Console program for devil's notch

        # pretty print from autoindent and ased editor
        # testing devil's notch
        # prime number function from TCLLIB  
        # written on Windows XP
        # working under TCL version 8.6.6
        # gold on TCL WIKI , 20dec2017
        package require Tk
        package require math::numtheory
        package require math::constants
        #package require math::bigfloat
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory  math::constants }
       console show
       # corrected legendre_function  
       proc leg {N1 N2 } {
       set legendre_function  [/ $N1   [- [ ::tcl::mathfunc::log $N1 ] 1.08366 ] ] 
       set legendre_functionx  [/ $N2   [- [ ::tcl::mathfunc::log $N2 ] 1.08366 ] ] 
       return [- $legendre_functionx $legendre_function  ]
       }
       set numberx [ ::math::numtheory::prime_counting_functionx   450  550  ]
       puts "prime counting function  $numberx  corrected legendre [ leg 450. 550. ] "
       set numberx [ ::math::numtheory::prime_counting_functionx   550  650  ]
       puts "prime counting function  $numberx  corrected legendre [ leg 550. 650. ] "
       set numberx [ ::math::numtheory::prime_counting_functionx   650  750  ]
       puts "prime counting function  $numberx  corrected legendre [ leg 650. 750. ] "
       # padded statements into <local> ::math::numtheory::prime_counting_functionx   
       # for list of primes in interval 
       #if {[::math::numtheory::isprime $counter ] } {  lappend lister $counter }
       #      }
       # puts $lister

Alternate Console programs for prime_counting_function

        # pretty print from autoindent and ased editor
        # console program for prime_counting_function
        # keywords prime counting function
        # written on Windows XP on  TCL
        # working under TCL version 8.6
        # gold on TCL WIKI, 4feb2018
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        console show
        # adapted from sum_primes_to by dkf
        # from  Comparing Tcl and Python on TCL WIKI
        # advantage: no dependency on expr or isprime.
        # large numbers > 10E3 can take a long time.
        proc prime_counting_function {n {i 1}} {
            set total 0
            incr n 0
            for {set q [+ $i $i ]} {$q < $n} {incr q} {
                if {![info exists d($q)]} {
                    incr total
                    lappend d([* $q $q ]) $q
                } else {
                    foreach p $d($q) {
                        lappend d([+ $p $q ]) $p
                    }
                    unset -nocomplain d($q)
                }
            }
            return $total
        }
        puts " prime_counting_function for 100 , answer [prime_counting_function 100]
        puts " time note   [ time {prime_counting_function 100} 100 ] "
        #  prime_counting_function for 100 , answer 25
        #  time note   273.35 microseconds per iteration 

        # pretty print from autoindent and ased editor
        # written on Windows XP on TCL
        # working under TCL version 8.6
        # gold on TCL WIKI , 2feb2018
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory}
        set tclprecision 17
        console show
        # based on all_primes proc in Sample Math Programs on TCL WIKI
        proc prime_counting_functiont {max} {
            # from  rwt? on TCL WIKI
            set counter 1
            set primes [list 2]
            for {set test 3} {$test <= $max} {incr test 2} {
                set maxTest [int [sqrt $test ]]
                foreach prime $primes {
                    if {$prime  > $maxTest} {
                        # puts $test list omitted for time save
                        lappend primes $test
                        incr counter
                        break
                    }
                    if {![% $test $prime ]} {
                        break
                    }
                }
            }
            return $counter
        }
        puts " prime_counting_functiont answer [ prime_counting_functiont 100]"
        puts " prime_counting_functiont time note   [ time { prime_counting_functiont 100 } 300 ]  "
        # prime_counting_functiont answer 25
        # prime_counting_functiont time note   165.896 microseconds per iteration 

Console program for sum of reciprocal squares of prime numbers.

        # following statements can be pasted into TCL console
        set project 1.0
        set P_2 expr { 1./(2*2)+1./(3*3)+1./(5*5)} #0.40111 
        set P_2 expr { 1./(2*2)+1./(3*3)+1./(5*5)+1./(7*7)+1./(11*11)+1./(13*13)} # 0.43570 

Table for prime_zeta_function

        # pretty print from autoindent and ased editor
        # console program for prime_zeta_function
        # keywords sum  squares prime zeta function Sieve Eratosthenes
        # written on Windows XP on  TCL
        # working under TCL version 8.6
        # gold on TCL WIKI, 4feb2018
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        console show
        # adapted from sum_primes_to by dkf
        # from  Comparing Tcl and Python on TCL WIKI
        # advantage: no dependency on expr or isprime.
        # large numbers n  > 10E3 can take a long time.
        # P(order 1) is divergent, P(n),n>1 should be convergent.
        proc prime_zeta_function {bb n} {
            # tally sequence of prime numbers via the Sieve of Eratosthenes.
            # n is highest integer to test
            # i subintegers to test as factors
            # D()  # map composite integers to primes witnessing their compositeness
            # q = integer to test for primality (usually starts at 2 )
            # total here, sum of reciprocals of prime squares or powers
            # bb is square or power for reciprocal denominator
            # prime zeta function P(1) is divergent at inf, higher P() converge
            # if q and p are odd, q+2*p will always be odd. 
            # all even numbers n() are not prime, except 2.
            set total 0
            incr n 0
            set i 1
            for {set q [+ $i $i ]} {$q < $n} {incr q} {
                if {![info exists d($q)]} {
                    # add 1/n**bb to tatal if n prime
                    set total [+ $total [/ 1. [* $q $q ] ]]
                    # add to current map 
                    lappend d([* $q $q ]) $q
                } else {
                    # move each witness to its next multiple
                    foreach p $d($q) {
                        lappend d([+ $p $q ]) $p
                    }
                    unset -nocomplain d($q)
                    # dump map
                }
            }
            return $total
        }
        puts " prime_zeta_function for {2 6} , answer [prime_zeta_function 2 6] "
        puts " time note   [ time {prime_zeta_function 2 5} 100 ] "
        puts " prime_zeta_function for {2 10000} , answer [prime_zeta_function 2 10000 ] "
        puts " time note   [ time {prime_zeta_function 2 10000} 100 ] "       
        # prime_zeta_function for {2 6} , answer 0.40111111111111108 
        # time note   11.390000000000001 microseconds per iteration 
        # prime_zeta_function for {2 10000} , answer 0.45223760433995064 
        # time note   71381.509999999995 microseconds per iteration 

         proc report {n} {
         set count 1
         set lister {}
         set lister {0. 0.452247 0.174763 0.0769931 0.035755 0.0170701 0.00828383 0.00406141 0.00200447 0.000993604 }
         puts "%|table testcases number||||printed in| tcl wiki format|% "
         puts "%|testcase |P(order)|TCL n value |TCL proc prime_zeta_function |P() standard at inf | comment, if any|% "            
         foreach item { 2 3 4 5 6 7 8 } {
         puts "&| testcase $count | $item |1E6  |[ prime_zeta_function $item 1000000 ] | [lindex $lister $count]||&"
         incr count 1
         }}
         report 2

References:

• Primes
• Oneliner's Pie in the Sky
• One Liners
• Comparing Tcl and Python
• TCLLIB ::math::numtheory
• en.wikipedia.org/wiki/Prime-counting_function
• sweet.ua.pt/tos/primes.html
• mathworld.wolfram.com/PrimeCountingFunction.html
• Prime zeta function, Wikipedia
• Prime Zeta Function, from Wolfram MathWorld
• Riemann zeta function, Wikipedia
• Sample Math Programs on TCL WIKI
• On the Number of Prime Numbers less than
• a Given Quantity,Bernhard Riemann,November 1859.

this license

Comments Section edit

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References