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] 3/8/2024
----
<<TOC>>
----
***Twin Primes Follow up with Pseudocode Study ***
----
***Preface***
----
[gold] Update 3/7/2024. The Twin Primes procedure is loaded on the [Tcllib] math::primes module. Reference Routines are listPrimePairs and listPrimeProgressions on [Tcllib]. Study of Twin Primes features using pseudocode. Console program outputs data as table in TCL table format and comma delimited spreadsheet. These auxiliary decks are used to proof features or subroutines. The [Monopoly] page from [GWM] seems closest in theme to what I was trying to learn. Using dice and running with random throws along a track or path like Snakes and Ladders.
----
----
[gold] Update 3/7/2024. The author is retired engineer on Windows 10 and no longer has proofing access to Unix machines. Unix is respected after use of so many decades in engineering, but my wings are lost. I did find a useful online IDE, jdoodle. I can paste from a text file, edit, and run an output using this online IDE.
----
----
[gold] Note: Some tickets for prime numbers are closed and functions available in [Tcllib]. Many thanks to Arjen Markus [arjen] [AM] & [Andreas Kupries] for the heavy lifting.
----
closer: arjenmarkus [AM]
----
Emailed comment from [AM]: I used the sample code to create two new procedures:
======
listPrimePairs
listPrimeProgressions
======
The first proc '''listPrimePairs''' returns a list of pairs of primes that differ by a given number and the second proc '''listPrimeProgressions ''' returns a list of arithmetic progressions of primes that differ by the given number.
----
----
***Introduction***
----
----
*** Not a Replacement for TCL Core ***
----
This page on developing pseudocode examples and one line procedures is not a replacement for the current Tcl [core] and [Tcllib], which is much improved since Tcl version 4, and other <faster> language constructs. [tcl::mathop%|%math ops], [Tcllib] routines, and other compiled routines can reduce the cost of big-data tasks by about 1/3. The time savings of the [core] are not always obvious on small quantities of data, like 4 or 5 numbers. Performance of one-line programs may suffer degradation due to lengthy recursion calls, and may be limited by constraints on recursion. 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.
----
[gold] 3/8/2024 Draft & Check.
----
----
----
----
***Body***
----
----
*** Draft Outline for Applications of Primes including Twin Primes ***
----
1. Cryptography: Primes play a crucial role in encryption algorithms such as RSA (Rivest-Shamir-Adleman), which relies on the difficulty of factoring large numbers into their prime components to secure communication online.
----
2. Number theory: Primes are fundamental in number theory, the branch of mathematics that studies the properties and relationships of numbers. Studying prime numbers helps to understand the distribution of primes, prime factorization, and other important concepts in mathematics.
----
3. Primality testing: Algorithms have been developed to efficiently determine whether a given number is prime. These algorithms are essential in various applications, such as programming languages, cryptography, and computer science.
----
4. Random number generation: Primes are often used in generating random numbers, especially in cryptographic applications where randomness is crucial for security. The use of prime numbers in random number generation ensures a higher level of unpredictability and security.
----
5. Error detection and correction: Primes are used in error detection and correction algorithms, such as the Reed-Solomon codes, which are commonly used in data storage and transmission systems. By leveraging the properties of prime numbers, these algorithms can detect and correct errors in transmitted data.
----
Twin primes, which are prime numbers that have a difference of 2 (e.g., 3 and 5, 11 and 13), have applications in number theory, cryptography, and computer science.
----
1. In number theory, the study of twin primes helps researchers understand the distribution of prime numbers.
----
2. In cryptography, twin primes are used in certain encryption algorithms.
----
3. In computer science, twin primes can be used in algorithms for generating random numbers.
----
***Pseudocode on listPrimePairs ***
----
======
# Pseudocode
# Procedure: listPrimePairs
# Note dependency here on Tcllib proc isprime
# Parameters:
# lower - lower limit for the interval
# upper - upper limit for the interval
# step - difference between successive primes (default: 2)
# Return:
# list of pairs of primes differing the given step
# Procedure is_prime to check if a number is prime
proc is_prime(n):
if n < 2:
return False
for i from 2 to sqrt(n):
if n % i == 0:
return False
return True
# Procedure listPrimePairs
procedure listPrimePairs(lower, upper, step=2):
# Validation card
if upper <= lower:
return error: "The upper limit must be larger than the lower limit"
if step <= 0:
return error: "The step must be at least 1"
# Initialize output variable here, list in TCL
output = []
# for next loop in TCL
for i in range(lower, upper+1):
next = i + step
if isPrime(i) and isPrime(next):
output.append([i, next])
return output
End
======
----
Pseudocode generates a list of prime number pairs that differ by the given step within the specified interval. The pseudocode uses a similar logic to the original [Tcllib] script, with some minor modifications to match the pseudocode syntax.
----
======
# list from copy of [Tcllib] deck on jdoodle.
bruin constant over selected range =
series 1/5 + 1/7 + 1/11 + 1/13 + 1/17 + 1/19 + 1/29 + 1/31 + 1/41 + 1/43 + 1/59 + 1/61 = 0.7698738952
puts " list of twin primes = [ listPrimePairs 3 100 2 ] "
list of twin primes = {3 5} {5 7} {11 13} {17 19} {29 31} {41 43} {59 61} {71 73}
bruin constant over selected range 0.5333333333333333
bruin constant over selected range 0.5333333333333333
bruin constant over selected range 1.330990365719087
bruin constant over selected range 1.330990365719087
puts " list of twin primes = [ listPrimePairs 3 500 2 ] "
bruin constant over selected range 1.486060792020912
bruin very slow closer and not much core allowance on jdoodle
monograph = B2(p = 10**16) = 1.902160583104
series converges extremely slowly.
======
----
Reference Testcases
======
Test Cases
P -> Partial Sum of series for Bruin Constant
2 -> 0
6 -> 0.5333333333333333
10 -> 0.8761904761904762
13 -> 0.8761904761904762
100 -> 1.3309903657190867
620 -> 1.4999706034568274
100000 -> 1.67279958482774
p B2(p)
10E2 1.330990365719
10E4 1.616893557432
10E6 1.710776930804
10E8 1.758815621067
10E10 1.787478502719
10E12 1.806592419175
10E14 1.820244968130
10E15 1.825706013240
10E16 1.830484424658
different more converging formula?
Ref = Introduction to twin primes and Brun’s constant
computation
Pascal Sebah and Xavier Gourdon
10^5: 1.90216329186 ( 6.1 s)
10^6: 1.90191335333 ( 63.1 s)
10^7: 1.90218826322 ( 759.6 s)
2*10^7: 1.90217962170 (1692.3 s)
B2(p = 10**16) => 1.902160583104
======
----
*** Math Template Subroutine for study here***
----
*** Gaps between Twin Primes, What expected?***
----
The first 60 prime gaps are:
1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2, 4, 14, 4, 6, 2, 10, 2, 6, 6, 4, 6, 6, 2, 10, 2, 4, 2, 12, 12, 4, 2, 4, 6, 2, 10, 6, 6, 6, 2, 6, 4, 2, ... (sequence A001223 in the OEIS).
----
The average gap between primes increases as the natural logarithm of these primes, and therefore the ratio of the prime gap to the primes involved decreases (and is asymptotically zero). This is a consequence of the prime number theorem. --- Wikipedia
----
Taking averages between prime pairs, the positions of 2. what expected?
----
======
mean 2, 4, 6, 6, 2,
mean 2, 4, 14, 4, 6, 2,
mean 2, 10, 6, 6, 6, 2
puts " math_mean = [math_mean 2 4 6 6 2 ]" # 4
puts " math_mean = [math_mean 2 4 14 4 6, 2 ]" # 5
puts " math_mean = [math_mean 2 10 6 6 6, 2 ]" # 5
======
----
----
***References:***
----
Omitting outside links here, too transitory on internet.
----
* [TCLLIB] math::primes module
* [Gauss Approximate Number of Primes and eTCL demo example calculator]
* [TCLLIB] Current Release 1.21 (May 7, 2022)
* math::primes::isprime
* math::primes::firstNprimes
* math::primes::primesLowerThan
* math::primes::primeFactors
* math::primes::numberPrimesGauss
* math::primes::numberPrimesLegendre
* math::primes::numberPrimesLegendreModified
* math::primes::differenceNumberPrimesLegendreModified
* math::primes::numberPrimesLegendre N
* math::primes::numberPrimesLegendreModified N
* math::primes::differenceNumberPrimesLegendreModified lower upper
* math::primes::listPrimePairs lower upper step
* math::primes::listPrimeProgressions lower upper step
* Bruin's Constant at p=10**16 , B2(p = 10**16) = 1.902160583104..
* Ref = Introduction to twin primes and Brun’s constant computation
* Pascal Sebah and Xavier Gourdon
* On-Line Encyclopedia of Integer Sequences , OEIS
* Andrew Granville, Primes in intervals of bounded length, Joint Math Meeting, Jan 17 2014.
* J. C. Evard, Twin primes and their applications, archived Pdf
* James Maynard, Small gaps between primes, arXiv:1311.4600 , 2013, Annals of Mathematics,
* Godfrey Harold Hardy (1877-1947) and John Edensor Littlewood (1885-1977)
* to estimate the density of twin primes. historic approximate formula.
* many assumptions, p2(n) ~~ n / (log(n) * log(n)) , ref Gauss formula for prime number density.
* substantial interest online codegolf_
* stackexchange /questions/107634/approximate-bruns-constant
* sagemath twin_prime constant
*The Twin Primes constant is defined as
* ∏︀ 1 − 1/(%F0%9D%91%9D − 1)**2
* for primes %F0%9D%91%9D > 2.
*
* sage: float(twinprime)
* 0.6601618158468696
* sage: twinprime.n(digits=60)
* sage: 0.660161815846869573927812110014555778432623360284733413319448
----
* Wikipedia: Gambler's Ruin
* Khan Academy: Gambler's Ruin
* MathWorld: Gambler's Ruin
* Wolfram Alpha: Gambler's Ruin Problem
* Quora: What are some practical applications of the Gambler's Ruin Problem?
* The Gambler's Ruin Problem" - Discrete Mathematics with Applications, by Kenneth Rosen:
* A chapter from the textbook explaining the Gambler's Ruin Problem
* and its applications in discrete mathematics
* "The Gambler's Ruin Problem: A Case Study in Probability" - MIT OpenCourseWare:
* A lecture on the Gambler's Ruin Problem
* "The Gambler's Ruin Problem" - Khan Academy: A video lesson explaining
* the Gambler's Ruin Problem and its applications in probability and statistics.
----
* [Category Algorithm]
* [Gauss Approximate Number of Primes and eTCL demo example calculator]
* Taking a Weighted Average, Dr Math, mathforum.org/dr.math, dated 03/20/2003
* google <Weighted Average, Dr Math>, mathforum.org/dr.math
* Using Weighted Criteria to Make Decisions, Dr Math>, mathforum.org/dr.math, dated 07/18/2008
* google <Weighted sum product model Decision >
* harmonic mean discussed in [Additional math functions]
* harmonic mean discussed in [Tcl Normalized Extended Benchmarks]
* see arithmetic mean on tcl-wiki [Stats] 2011-05-22, [RLE]
* see similar 1/(1/nth) terms method used in
* [Babylonian Combined Market Rates and eTCL demo example calculator, numerical analysis ]
----
* GoDuck search engine < Functional Programming >
* GoDuck search engine < Imperative Programming >
* GoDuck search engine < Programming Examples >
* Google search engine < vaporware >
* [Tcllib] math::special Special mathematical functions
* [Tcllib] math::figurate Evaluate figurate numbers
* [Tcllib] simulation::random Pseudo-random number generators
* [Tcllib] simulation::montecarlo Monte Carlo simulations
* Wikipedia search engine < Lehmer random number generator >
* Professor Frisby's Mostly Adequate Guide to Functional Programming on internet archive
* Writing code using the Pseudocode Programming Process, article by David Zych
* Mathematical Methods in Large-scale Computing Units
* by Derrick H. Lehmer
* L’Ecuyer, Pierre (January 1999). "Tables of linear congruential generators of different sizes and good lattice structure"
* Mathematics of Computation. 68
* A Comprehensive Review of Quantum Random Number PDF
* Good Pedagogical Random Number Generators
* from J. Stanley Warford
* Coding the Lehmer Pseudo random Number Generator
* from W. H. PAYNE
* The most commonly used version of the Mersenne Twister algorithm
* is based on the Mersenne prime expr { 2**19937-1 }
* TWISTER = 431542479738816264805523551633791983905393504322.....
* GoDuck search engine < TCL version >
* [One Liners Programs Pie in the Sky]
* [One Liners]
* One Liners Programs Compendium [https://wiki.tcl-lang.org/page/One+Liners+Programs+Compendium++and+TCL+demo+examples+calculations%2C+numerical+analysis]
* WIKI BOOKS, Programming_Examples pdf
* WIKI BOOKS, Tcl_Programming_Introduction pdf
* Note. I did find a useful online IDE, jdoodle
* Note. I can paste, edit, and run an output using this online IDE.
* How Do I Write Pseudocode? video by Mr. Brown CS
* Refers to [rand], [RandMT], [Mersenne Twister], & [random]
* [Suchenworth] [RS] on [Horseracing in Tcl].
* Random Number Generators: Good Ones Are Hard to Find, Keith Willam Miller, pdf online
* [Throwing Two Dice] [GWM] and [Dice] by [Keith Vetter].
* [int] from [RLE] has dice expression expr {1 + int(rand()*6)} [RLE].
* Several Dr. Math emails may reduce some dice issues to simple paths, internet archive.
* [Counting Elements in a List] from [RWT].
----
----
*** Extra Credit on One Line Procedures***
----
* [Little] L Programming Language
* [Let's assign with let]
* [let]
* [let2]
* Easy Eye Calculator [https://wiki.tcl-lang.org/page/Easy+Eye+Calculator+and+eTCL+Slot+Calculator+Demo+Example%2C+Numerical+Analysis]
* [Tcl the Misunderstood]
* Maximum nummeric value from [max]
* L-Language pdf [http://www.tcl.tk/community/tcl2006/papers/Larry_McVoy/l.pdf%|%L], by [Larry McVoy]:
* [One liners Programs Pie in the Sky]
* [Counting characters in a string]
* [Playing with recursion]
* [recursive functions]
* [If we had no expr]
* [expr]
* [little language]
* [string is]
----
----
* Wikipedia search engine < random >
* Wikipedia search engine < dice >
* Wikipedia search engine < Programming Examples >
* Google search engine < vaporware >
* [One Liners Programs Pie in the Sky]
* [One Liners]
* One Liners Programs Compendium [https://wiki.tcl-lang.org/page/One+Liners+Programs+Compendium++and+TCL+demo+examples+calculations%2C+numerical+analysis]
* WIKI BOOKS, Programming_Examples pdf
* WIKI BOOKS, Tcl_Programming_Introduction pdf
* google search engine < HgA1c to Average Blood Glucose>
----
----
***Screenshots Section***----
****figure 1.****----
[Twin Primes Follow up with Pseudocode Slow Series Convergence for Bruin Constant]----
****figure 1a.****
----
Credit to Wikipedia-(Kiwi128)
Bruins constant in lower primes field.
The convergence to B2. Each dot represents the effect of an additional pair of twin primes. While the exact value of B2 is unknown, it is thought to be around 1.9 (red line). Calculations have shown it to be greater than 1.83 (blue line)
----
****figure 2.****
[Gauss Approximate Number of Primes and eTCL demo example calculator graph approx no primes]
****figure 3.****
[Gauss Approximate Number of Primes and eTCL demo example graphr]
****figure 4.****
[Gauss Approximate Number of Primes and eTCL demo example grapSSS]
****figure 5.****
[Gauss Approximate Number of Primes and eTCL LEGENDRE APPROXIMATION]
****figure 6.****
[Gauss Approximate Number of Primes and eTCL demo example absolute error]
****figure 7.****
[Gauss Approximate Number of Primes and eTCL large scale absolute error]
****figure 8.****
[Gauss Approximate Number of Primes and eTCL demo example relative error]
****figure 9.****
[Gauss Approximate Number of Primes devil's notch]
****figure 10.****
[Gauss Approximate Number of Primes regular legendre error]
****figure 11.****
[Gauss Approximate Number of Primes modified legrendre error]
****figure 12.****
[Gauss Approximate Number of Primes riemann traces]
----
----
[Twin Primes Follow up with Pseudocode Slow Series Convergence for Bruin Constant]
----
***Auxiliary Code Under Test***
----
----
**Hidden Comments Section**
<<discussion>>
Please include your wiki MONIKER and date in your comment with the same courtesy that I will give you. Thanks, [gold] 12Aug2020
----
test edit
----
----
----
Functional and Imperative Programming Functional programming computes an expression, while imperative programming is a sequence of instructions modifying memory. The former relies on an automatic garbage collector, while the latter requires explicit memory allocation and deallocation.
Memory and Execution Control Imperative programming provides greater control over execution and memory representation, but can be less efficient. Functional programming offers higher abstraction and execution safety, with stricter typing and automatic storage reclamation.
Historical Perspectives Historically, functional programming was associated with symbolic applications, and imperative programming with numerical applications. However, advances in compiling and garbage collection have improved efficiency and execution safety for both paradigms.
The Appeal of Tool Control Language TCL TCL emphasizes that efficiency need not preempt assurance, as long as efficiency remains reasonably good. This approach is gaining popularity among software producers.
----
[gold] prompt? Improve, elaborate, explain steps, and explain definitions in numbered steps with numbered steps with details, dates, and elaboration in regard to computer applications, and Tool Control Language TCL ; use titles on each paragraph consisting of 1,2,3 or 4 words? Restrict each paragraph to 30 words or less?
----
[gold] prompt? improve, condense, elaborate, explain steps, and explain definitions in numbered steps with numbered steps with details, dates, and elaboration in regard to computer applications, and Tool Control Language TCL ; use titles on each paragraph consisting of 1,2,3 or 4 words? Restrict each paragraph to 30 words or less? Restrict text to third person and impersonal discussion text, substitute one for you, substitute ones for your, use one for he, use ones for his?
----
..
----
[gold] Prompt: improve, condense, elaborate, explain steps, and explain definitions in numbered steps with numbered steps with details, dates, and elaboration in regard to computer applications, and Tool Control Language TCL ; use titles on each paragraph consisting of 1,2,3 or 4 words? Omit blank lines? Restrict each paragraph to 30 words or less? Restrict text to third person and impersonal discussion text, substitute one for you, substitute ones for your, use one for he, use ones for his?
----
Note. What about all negative values or mixed positive/negative values. Under definitions of arithmetic mean?
Under math check. The procedure calculates the mean by summing all values and then dividing the sum by the number of values, regardless of the signs of the values. The arithmetic mean, also known as the average, is calculated by adding up all the values and then dividing the sum by the number of values. This definition applies to all types of values, including negative or mixed positive/negative values. The pseudocode accurately follows this definition by summing all values, regardless of their signs, and then dividing the sum by the number of values.
----
When calculating the arithmetic mean of a set of values, whether they are all negative, all positive, or a mix of positive and negative values, the process remains the same. The arithmetic mean is calculated by summing all the values and then dividing by the total number of values.
For example, if you have a set of negative values such as (-1, -2, -3), the arithmetic mean would be calculated by adding -1, -2, and -3 together to get -6, and then dividing by 3 (the total number of values) to get an arithmetic mean of -2.
Similarly, if you have a mix of positive and negative values (e.g., 1, -2, 3), you would sum the values (1 + (-2) + 3 = 2) and then divide by 3 to get an arithmetic mean of approximately 0.67.
The arithmetic mean calculation is not affected by the sign of the values, as it is a measure of central tendency that considers the magnitude of the values rather than their sign.
---
======
# pseudocode
# example to illustrate this process:
# Function to check if a number is prime
function is_prime(n):
if n < 2:
return False
for i from 2 to sqrt(n):
if n % i == 0:
return False
return True
# Function to find twin prime pairs and calculate the gap
function find_twin_primes():
twin_primes = []
for i from 2 to MAX_NUMBER:
if is_prime(i) and is_prime(i + 2):
twin_primes.append((i, i + 2))
prime_gaps = []
for pair in twin_primes:
gap = pair[1] - pair[0]
prime_gaps.append(gap)
return prime_gaps
# Function to calculate the average of prime gaps
function calculate_average(gaps):
total = 0
for gap in gaps:
total += gap
average = total / len(gaps)
return average
# Main program
twin_prime_gaps = find_twin_primes()
average_gap = calculate_average(twin_prime_gaps)
print("Average gap between twin primes: ", average_gap)
======
##
----
<<categories>> Numerical Analysis | Toys | Calculator | Mathematics| Example| Toys and Games | Games | Application | GUI
----
<<categories>> Development | Concept| Algorithm | Biology