Non-recursive Lucas; faster FirstD; time comparisons

lucas.py

 # Finding lucas pseudoprimes
 from math import sqrt, gcd, floor, log
+from time import process_time
 
 def isqrt(n):
     """ Find the integer square root of n via newton's method, code via
     """Return first D in the sequence 5, -7, 9, -11, 13, -15... for which the
     Jacobi symbol (D/n) is -1
     """
-    if hasIntSQRT(n):
-        raise ValueError("n must not be a square")
     if n < 1 or n % 2 == 0:
         raise ValueError("n must be a positive odd number")
+    # Flag to see if it's been checked whether or not n is
+    # square
+    haschecked = False
     for D in Dsequence():
         if Jacobi(D, n) == -1:
             return D
+        # This is supposed to be faster
+        if D > 30 and not haschecked:
+            if hasIntSQRT(n):
+                raise ValueError("n must not be a square")
     # Shouldn't fire
     return 0
 
     """
     if n < 0:
         raise ValueError("n must be a non-negative integer")
-    if n == 0:
-        return 0, 2
-    Unm1, Vnm1 = Lucas(n - 1, p, q)
-    Un = (p * Unm1 + Vnm1) // 2
-    Vn = ((p * p - 4 * q) * Unm1 + p * Vnm1) // 2
-    return Un, Vn
+    Uc = 0
+    Vc = 2
+    for i in range(n):
+        Un = (p * Uc + Vc) // 2
+        Vn = ((p * p - 4 * q) * Uc + p * Vc) // 2
+        Uc = Un
+        Vc = Vn
+    return Uc, Vc
 
 def LucasUn(n, p, q):
     """Return only the U numbers from a lucas sequence Un(P, Q). For example if
     return(uc, vc)
 
 
-for i in range(1, 20000, 2):
+for i in range(1, 20, 2):
     if hasIntSQRT(i):
         continue
     d = FirstD(i)
     su, sv = Lucas(i + 1, 1, q)
     su = su % i
     sv = sv % i
-    print("{}: {}, {}; {}".format(i, fu == su, fv == sv, Lucas(i + 1, 1, q)))
-
-
+    if (fu != su) or (fv != sv):
+        print("{}: {}, {}; {} {}".format(i, fu, fv, su, sv))
+print("Done!")
+
+i = 19999999999999999999999999999999999999999999999999999999999
+t1 = process_time()
+hasIntSQRT(i)
+te = process_time() - t1
+print(te)
+t1 = process_time()
+d = FirstD(i)
+te = process_time() - t1
+print(te)
+q = (1 - d) // 4
+t1 = process_time()
+LucasFast(i + 1, 1, q, i)
+te = process_time() - t1
+print(te)
+t1 = process_time()