Release calc version 2.10.2t30

help/prevcand

@@ -0,0 +1,85 @@
+NAME
+    prevcand - previous candidate for primeness
+
+SYNOPSIS
+    prevcand(n [,count [, skip [, residue [, modulus]]]])
+
+TYPES
+    n		integer
+    count	integer with absolute value less than 2^24, defaults to 1
+    skip	integer, defaults to 1
+    residue	integer, defaults to 0
+    modulus	integer, defaults to 1
+
+    return	integer
+
+DESCRIPTION
+    The sign of n is ignored; in the following it is assumed that n >= 0.
+
+    prevcand(n, count, skip, residue, modulus) returns the greatest
+    positive integer i less than abs(n) expressible as
+    residue + k * modulus, where k is an integer, for which
+    ptest(i,count,skip) == 1, or if there is no such integer i, zero.
+
+    If n < 2^32, count >= 0, and the returned value i is not zero, i is
+    definitely prime.  If n > 2^32, count != 0, and i is not zero,
+    i is probably prime, particularly if abs(count) is greater than 1.
+
+    With the default argument values, if n > 2, prevcand(n) returns the a
+    probably prime integer i less than n such that every integer
+    between i and n is composite.
+
+    If skip == 0, the bases used in the probabilistic test are random
+    and then the probability that the returned value is composite is
+    less than 1/4^abs(count).
+
+    If skip == 1 (the default value) the bases used in the probabilistic
+    test are the first abs(count) primes 2, 3, 5, ...
+
+    For other values of skip, the bases used are the abs(count) consecutive
+    integer skip, skip + 1, ...
+
+    If modulus = 0, the only values that may be returned are zero and the
+    value of residue.  The latter is returned if it is positive, less
+    than n, and is such that ptest(residue, count, skip) = 1.
+
+RUNTIME
+    The runtime for v = prevcand(n, ...) will depend strongly on the
+    number and nature of the integers between n and v.  If this number
+    is reasonably large the size of count is largely irrelevant as the
+    compositeness of the numbers betweeen n and v will usually be
+    determined by the test for small prime factors or one pseudoprime
+    test with some base b.  If N > 1, count should be positive so that
+    candidates divisible by small primes will be passed over quickly.
+
+    On the average for random n with large word-count N, the runtime
+    seems to be between roughly K/N^3 some constant K.
+
+EXAMPLE
+    > print prevcand(50), prevcand(2), prevcand(125,-1), prevcand(125,-2)
+    47 1 113 113
+
+    > print prevcand(100,1,1,1,6), prevcand(100,1,1,-1,6)
+    97 89
+
+    > print prevcand(100,1,1,2,6), prevcand(100,1,1,4,6),
+    2 0
+
+    > print prevcand(100,1,1,53,0), prevcand(100,1,1,53,106)
+    53 53
+
+    > print prevcand(125,1,3), prevcand(125,-1,3), prevcand(125,-2,3)
+    113 121 113
+
+    > print prevcand(2e60, 1, 1, 31, 1e30)
+    1999999999999999999999999999914000000000000000000000000000031
+
+LIMITS
+    none
+
+LIBRARY
+    int zprevcand(ZVALUE n, long count, long skip, ZVALUE res, ZVALUE mod,
+	ZVALUE *cand)
+
+SEE ALSO
+    nextcand, ptest