Rosetta Prime

[Leonides Suttle]

Aprime number is defined as a positive integer which has exactly two factors: one and itself. A factor of a number is an integer which divides evenly into it--that is, divides with a remainder of zero. By this definition one and zero are not prime. One only has one factor (which is itself), and zero divided by any number always has a remainder of zero, so it effectively has an infinite number of factors.

Primality is frequently used for instructional purposes in computer science. Naive algorithms for calculating it are usually complex enough to be a test for a new programmer (barring algorithms built into languages), but simple enough that they can be used as parts of problems to follow.

The function Decompose first estimates the maximal result length as log2 of the argument. Then it allocates the result and starts to enumerate divisors. It does not care to check if the divisors are prime, because non-prime divisors will be automatically excluded.

It's not easily possible to have arbitrary precision integers in PET basic, so here is at least a version using built-in data types (reals). On return from the subroutine starting at 9000 the global array pf contains the number of factors followed by the factors themselves:

An efficient Factor function using trial division and Pollard's rho algorithm is given in bqn-libs primes.bqn. The following standalone version is based on the trial division there, and builds in the sieve from Extensible prime generator.

Relatively sophiscated sieve method based on size 30 prime wheel. The code does not pretend to handle prime factors larger than 64 bits. All 32-bit primes are cached with 137MB data. Cache data takes about a minute to compute the first time the program is run, which is also saved to the current directory, and will be loaded in a second if needed again.

Note: The following code sample is experimental as it implements python style iterators for (potentially) infinite sequences. C is not normally written this way, and in the case of this sample it requires the GCC "nested procedure" extension to the C language.

To understand what was going on with the above code, pass it through cpp and read the outcome. Translated into normal C code sans the function call overhead, it's really this (the following uses a adjustable cache, although setting it beyond a few thousands doesn't gain further benefit):

This version a translation from Java of the sample presented by Robert C. Martin during a TDD talk at NDC 2011.Although this three-line algorithm does not mention anything about primes, the fact that factors are taken out of the number n in ascending order garantees the list will only contain primes.

This example assumes a function isPrime and was tested with this one. It could use a self-referential implementation such as the Python task, but the original author of this example did not like the ordering dependency involved.

Frink has a built-in factoring function which uses wheel factoring, trial division, Pollard p-1 factoring, and Pollard rho factoring. It also recognizes some special forms (e.g. Mersenne numbers) and handles them efficiently.

See Sieve of Eratosthenes or Primality by trial division for a source of primes to use with this function. Actually as some other entries notice, with any ascending order list containing all primes (e.g. 2:[3,5..]) used in place of primesList, the factors found by this function are guaranteed to be prime, so no separate testing for primality is strictly needed; however using just primes is more efficient, if we already have them.

Simple but very inefficient method, because it will test divisibility of all numbers from 2 to max prime factor. When decomposing a large prime number this will take O(n) trial divisions instead of more common O(log n).

`factors` as defined below emits a stream of all the prime factors of the input integer.The implementation is compact, fast and space-efficient:no space is required to store the primes or factors already computed, there is no reliance on an "is_prime" function, and square roots are only computed if needed.

The economy comes about through the use of the builtin filter recurse/1,and the use of the state vector: [p, n, valid, sqrt],where p is the candidate factor, n is the number still to be factored,valid is a flag, and sqrt is either null or the square root of n.

gojq supports unlimited-precision integer arithmetic, but the C implementation of jqcurrently uses IEEE 754 64-bit numbers, so using the latter, the following program will only bereliable for integers up to and including 9,007,199,254,740,992 (2^53). However, "factors"could be easily modified to work with a "BigInt" library for jq, such as BigInt.jq.

Maple has two commands for integer factorization: ifactor, which returns results in a form resembling textbook presentation and ifactors, which returns a list of two-element lists of prime factors and their multiplicities:

GP normally returns factored integers as a matrix with the first column representing the primes and the second their exponents. Thus factor(12)==[2,2;3,1] is true. But it's simple enough to convert this to a vector with repetition:

If you really need a speed boost, load the highly optimized Perl 5 ntheory module. It needs a little extra plumbing to deal with the lack of built-in big integer support, but for large number factoring the interface overhead is worth it.

REXX does not have an 'include' facility nor 'arbitrary precision' mathematical functions out of thebox. In previous REXX entries it was custom the have all needed routines or procedures copied intothe program. Newer entries redirect to

Libraries and

Pre processor and Include clause.

At the end of each entry you'll find several 'Include' clauses, showing the libraries that the programneeds (cf '#include', 'import', 'uses' or '::requires').

The factorization routine in below version is almost the same as the one in Version 3, but is also finds (number of) factors and stores all results in global variables. Thus it has some overhead for this specific task.

Rust's largest built-in integer type is u128 (128-bit unsigned integer) which is pretty large, but not unlimited.The solution therefore uses external crates for big integers.Add the dependencies in Cargo.toml:

It is unnecessary to write this function because Frink has an efficient isPrime[x] function to test primality of arbitrarily-large integers. Here is a version that works for arbitrarily-large integers. Beware some of these solutions that calculate up to sqrt[x] but because of floating-point error the square root is slightly smaller than the true square root!

Any increasing unbounded sequence of numbers that includes all primes (above the first few, perhaps) could be used with the testing function noDivsBy to define the isPrime function -- but using just primes is better, produced e.g. by Sieve of Eratosthenes, or noDivsBy itself can be used to define primeNums as shown above, because it stops when the square root is reached (so there's no infinite recursion, no "vicious circle").

Julia already has an isprime function, so this function has the verbose name isprime_trialdivision to avoid overriding the built-in function. Note this function relies on the fact that Julia skips for-loops having invalid ranges. Otherwise the function would have to include additional logic to check the odd numbers less than 9.

The following predicate showcases Prolog's support for writing predicates suitable for both testing and generating. In this case, assuming the Prolog implemenation supports indefinitely large integers, prime(N) can be used to generate primes until memory is exhausted.

(formerly Perl 6)Here we use a "none" junction which will autothread through the %% "is divisible by" operator to assert that $i is not divisible by 2 or any of the numbers up to its square root. Read it just as you would English: "Integer $i is prime if it is greater than one and is divisible by none of 2, 3, up to the square root of $i."

This can easily be improved in two ways. First, we generate the primes so we only divide by those, instead of all odd numbers. Second, we memoize the result using the //= idiom of Perl, which does the right-hand calculation and assigns it only if the left side is undefined. We avoid recalculating the square root each time. Note the mutual recursion that depends on the implicit laziness of list evaluation:

The Rosetta spacecraft was built by an industrial team led by prime contractor Astrium GmbH, Friedrichshafen, Germany, and involving more than 50 contractors from 14 European countries and the USA. Major subcontractors were Astrium Ltd. who built the spacecraft platform, Astrium France who supplied the spacecraft avionics and Alenia Spazio, Turin, Italy, for assembly, integration and verification. Canada participated in the construction of ESA's first 35 m-diameter Deep Space Antenna in Australia, which was built for Rosetta. Scientific consortia from institutes across Europe and the United States provided the 11 experiments for the orbiter.

The lander, Philae, was provided by a European consortium headed by the German Aerospace Research Institute (DLR). Other members of the consortium are ESA, CNES, ASI, and institutes from Austria, Finland, France, Hungary, Ireland, Italy, and the United Kingdom.

In 1940, from a jailhouse in Rouen, France, Andr Weil wrote one of the most consequential letters of 20th-century mathematics. He was serving time for refusing to join the French army, and he filled his days in part by writing letters to his sister, Simone, an accomplished philosopher living in London.

Other mathematicians had proposed ideas in this direction, but Weil was the first to spell out an exact vision. His letter presaged the Langlands program, a major initiative in contemporary mathematical research.

Because these shapes are the geometric embodiment of solutions to polynomial equations, they have a structure that can be exploited using techniques from complex analysis, a form of calculus. This structure allows for a richer set of theorem-proving tools, beyond those immediately available to number theorists.

3a8082e126