(All prime numbers up to 10,000,000,000 ) Write a program...

(All prime numbers up to $10,000,000,000$ ) Write a program that finds all prime numbers up to $10,000,000,000$. There are approximately $455,052,511$ such prime numbers. Your program should meet the following requirements: - Your program should store the prime numbers in a binary data file, named PrimeNumbers.dat. When a new prime number is found, the number is appended to the file. - To find whether a new number is prime, your program should load the prime numbers from the file to an array of the long type of size 10000. If no number in the array is a divisor for the new number, continue to read the next 10000 prime numbers from the data file, until a divisor is found or all numbers in the file are read. If no divisor is found, the new number is prime. - Since this program takes a long time to finish, you should run it as a batch job from a UNIX machine. If the machine is shut down and rebooted, your program should resume by using the prime numbers stored in the binary data file rather than start over from scratch. (Geometry: gift-wrapping algorithm for finding a convex hull) Section 22.10.1 introduced the gift-wrapping algorithm for finding a convex hull for a set of points. Assume that the Java's coordinate system is used for the points. Implement the algorithm using the following method: /** Return the points that form a convex hull "/ public static ArrayList<Point2D> getConvexHul1(double[] [] s) Point2D is defined in Section 9.6. Write a test program that prompts the user to enter the set size and the points and displays the points that form a convex hull. Here is a sample run:

(All prime numbers up to $10,000,000,000$ ) Write a program that finds all prime numbers up to $10,000,000,000$. There are approximately $455,052,511$ such prime numbers. Your program should meet the following requirements:
- Your program should store the prime numbers in a binary data file, named PrimeNumbers.dat. When a new prime number is found, the number is appended to the file.
- To find whether a new number is prime, your program should load the prime numbers from the file to an array of the long type of size 10000. If no number in the array is a divisor for the new number, continue to read the next 10000 prime numbers from the data file, until a divisor is found or all numbers in the file are read. If no divisor is found, the new number is prime.
- Since this program takes a long time to finish, you should run it as a batch job from a UNIX machine. If the machine is shut down and rebooted, your program should resume by using the prime numbers stored in the binary data file rather than start over from scratch.
(Geometry: gift-wrapping algorithm for finding a convex hull) Section 22.10.1 introduced the gift-wrapping algorithm for finding a convex hull for a set of points. Assume that the Java's coordinate system is used for the points. Implement the algorithm using the following method:
/** Return the points that form a convex hull "/ public static ArrayList<Point2D> getConvexHul1(double[] [] s)

Point2D is defined in Section 9.6.
Write a test program that prompts the user to enter the set size and the points and displays the points that form a convex hull. Here is a sample run:

Key Concepts

Gift-Wrapping Algorithm

Also known as Jarvis March, this algorithm is a method for computing the convex hull of a set of points. It operates by 'wrapping' around the set of points, starting from an extreme point and incrementally choosing the next point that forms the most counterclockwise turn. It is an illustrative example of an algorithm that is conceptually simple but can be efficient for certain datasets, capturing the essence of iterative and angle-based selection methods in computational geometry.

Computational Geometry and Convex Hull

This concept relates to identifying the smallest convex polygon that encloses a set of points in a plane. In computational geometry, the convex hull is a fundamental structure with applications in areas such as pattern recognition, image processing, and collision detection. Understanding the properties and algorithms for constructing the convex hull is critical in many geometric processing tasks.

Batch Processing and Resumable Computation

This is the practice of running long-running or resource-intensive computations as background jobs, often scheduled to run independently of interactive user sessions. It also includes mechanisms to checkpoint progress (such as writing intermediate results to disk) so that the computation can be resumed in case of interruptions like system reboots.

Persistent Storage and File I/O

This concept encompasses saving and retrieving data from a non-volatile binary file, ensuring that progress in a long-running computation can be maintained across program executions or system reboots. By storing computed prime numbers in a binary data file and reloading them as needed, the system can resume processing without recalculating previously determined results.

Divisibility Testing Using Known Primes

A key concept here is the method of verifying whether a number is prime by checking divisibility against a precomputed list of prime numbers. This technique leverages the fact that if a number has no small prime factors, then it is more likely to be prime. This approach avoids the need to check all possible divisors, providing a more efficient alternative to brute-force division tests.

Prime Number Generation

This concept involves creating a method to determine and list all prime numbers up to a given limit. It includes the idea of testing each candidate number for primality by checking whether any known smaller prime number divides it—an iterative and computationally intensive task when performed over a large range. It also touches on algorithmic optimizations to reduce unnecessary calculations when working with extensive ranges of numbers.

Transcript

00:01 We're a bunch of things about prime numbers.

00:05 And we can, basically, this prime pie, which i will call it prime pi, basically it says that how many prime numbers are there below a certain number here? so a certain integer.

00:24 And so they ask us, calculate the number is pi to the pie of 25 and pi of 100.

00:32 Well, we can, pi of 29, again, they tell us to use the sieve of aristotasins.

00:43 Yeah, i can't remember how, i don't know how to pronounce that exactly.

00:50 But it basically says just divide by two, get rid of all the even numbers, then divide by three, get rid of anything that's a multiple of three.

00:59 And then we divide by the next, that's five, we get rid of all the multiples of five, then get rid of all the multiples.

01:04 Multiples of seven then get rid of all the multiples of 11 i keep doing that until we get up to at least you know halfway through and that would be that there'd be possibly no more if we get up to 50 you can't there will be no more prime numbers after that we divide it as once you nothing divides by 50 so for 9 we get 1 for 25 we get 2 3 5 7 11 13 17 and 19 and 23 so you get 9 there's 9 prime numbers less than, is it less than or equal to? primes that are less than or equal to, yeah, 25.

01:43 So 100, we need to do a little more work, and we can find that, in fact, we get then 29, 31, 37, 41, 43, 47, and so on.

01:54 And counting all these up, we get 25.

01:56 So there's 25 primes that are less than are equal to 100.

02:00 And there's 25 primes that are less than 100, too, because the highest, the largest one is 97.

02:07 Now, they say, okay, they tell us that gauss, when he was a teenager, said that the, postulated, at least, that the limit as n goes to infinity of pi to the n divided by n over the natural log of n is one.

02:27 And then 100 years later, that was actually proven.

02:32 I'm not sure how you actually prove that.

02:34 That's, that's what would be quite an interesting.

02:38 Interesting proof to try to work through.

02:40 But anyway, we'll just actually even just see how it was done.

02:44 So they say, well, let's do this for a few values.

02:47 So we get for 100.

02:50 We have, so this is 25.

02:54 And then we have, you know, 100 times the natural log of minus 100.

03:01 So n over a natural log of, n over natural log of n.

03:08 So we just brought that up under the numeral.

03:10 And that gives us 1 .15.