From e7a1820e6e868276bb38795899a80fd341226b25 Mon Sep 17 00:00:00 2001 From: Ewoudbouman Date: Sun, 14 Oct 2018 20:13:30 +0200 Subject: [PATCH 1/2] finished assignments + comments --- Lab6/ewoud/Lab6.hs | 302 +++++++++++++++++++++++++++++++-------------- 1 file changed, 209 insertions(+), 93 deletions(-) diff --git a/Lab6/ewoud/Lab6.hs b/Lab6/ewoud/Lab6.hs index d95ac4b..afcc582 100644 --- a/Lab6/ewoud/Lab6.hs +++ b/Lab6/ewoud/Lab6.hs @@ -4,11 +4,11 @@ import Data.List import System.Random import Numeric import Data.Bits --- -import Lecture6 (prime, primeTestsF, primeMR, primes) --- Bonus assignment imports -import Lecture6 (rsaPublic, rsaPrivate, rsaEncode, rsaDecode) -import Data.Hashable +import Lecture6 (prime, primeTestsF, primeMR, primes, + -- Assignment 6_2 + mers, + -- Assignment 7 + rsaPublic, rsaPrivate, rsaEncode, rsaDecode) {------------------------------------------------------------------------------ @@ -17,17 +17,16 @@ Assignment 1 Hours spent: 1h -Idea: Right-to-left binary method aka modular exponentiation with repeated squaring -(https://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method) -(https://nptel.ac.in/courses/106103015/10) +Idea: Left-to-right binary method +Source: https://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method ------------------------------------------------------------------------------} --- Exm:: base(b) -> exponent(e) -> modulus(m) -> result +-- f :: base(b) -> exponent(e) -> modulus(m) -> return result exM :: Integer -> Integer -> Integer -> Integer exM b 0 m = 1 exM b e m = mult * exM ((b * b) `mod` m) (shiftR e 1) m `mod` m where - -- if bit value [,,x,,] is 0, do not modify result - -- otherwise set result + -- if bit value [,,xi,,] is 0, skip to next step. + -- otherwise compute result mult | testBit e 0 = b `mod` m | otherwise = 1 @@ -38,6 +37,38 @@ Assignment 2 Hours spent: 1h +See bench2.html for more results. + +Increasing the exponent +original expm: +10^10 mod 123 : mean 245.8 ns (243.7 ns .. 250.3 ns) +10^100 mod 123 : mean 522.4 ns (521.3 ns .. 523.3 ns) +10^1000 mod 123 : mean 1.608 μs (1.599 μs .. 1.630 μs) +10^10000 mod 123 : mean 29.79 μs (29.73 μs .. 29.96 μs) + +custom exM +10^10 mod 123 : mean 382.4 ns (382.0 ns .. 383.2 ns) +10^100 mod 123 : mean 639.6 ns (631.9 ns .. 668.2 ns +10^1000 mod 123 : mean 1.074 μs (1.048 μs .. 1.114 μs) +10^10000 mod 123 : mean 1.253 μs (1.242 μs .. 1.275 μs) + +The exM implementation scales much better with an increasing exponent compared +to the original implementation. + +Increasing the base +original expm +10^10 mod 123 : mean 246.7 ns (245.8 ns .. 248.7 ns) +100^10 mod 123 : mean 255.3 ns (251.3 ns .. 265.2 ns) +1000^10 mod 123 : mean 271.6 ns (270.2 ns .. 274.8 ns) +10000^10 mod 123 : mean 296.8 ns (295.3 ns .. 300.3 ns) + +custom expm +10^10 mod 123 : mean 404.5 ns (392.7 ns .. 423.5 ns) +100^10 mod 123 : mean 378.3 ns (377.6 ns .. 379.0 ns) +1000^10 mod 123 : mean 383.1 ns (380.9 ns .. 387.9 ns) +10000^10 mod 123 : mean 392.6 ns (386.3 ns .. 405.7 ns) + +Both implementations show similar performance with an increased base ------------------------------------------------------------------------------} -- See: bench2.hs + bench2.html @@ -48,12 +79,12 @@ Assignment 3 Hours spent: 0.25h +We generate the compositis based on two conditions for n: +- n is a positive integer with n>1. +- n is not a prime number. ------------------------------------------------------------------------------} --- A composite number n is a positive integer n>1 which is not prime (i.e., which has factors other than 1 and itself). --- The first few composite numbers (sometimes called "composites" for short) are 4, 6, 8, 9, 10, 12, 14, 15, 16, ... --- source: http://mathworld.wolfram.com/CompositeNumber.html - +-- f :: returns [composites] composites :: [Integer] composites = filter (\x -> not (prime x)) [2..] @@ -63,12 +94,24 @@ Assignment 4 Hours spent: 1h -------------------------------------------------------------------------------} +Result: +k = 1, 100 tests, least composite number : 9 +k = 2, 100 tests, least composite number : 9 +k = 3, 100 tests, least composite number : 35 +k = 5, 100 tests, least composite number : 91 +k = 10, 100 tests, least composite number : 1105 --- Kleine uitleg: https://www.khanacademy.org/computing/computer-science/cryptography/random-algorithms-probability/v/fermat-primality-test-prime-adventure-part-10 +By choosing a random value as the base there is a >50% chance that the number +is not a pseudoprime to the base. +By choosing k random values there is a 0.5^k possibility of not being fooled +by composite numbers. --- Checks if the value k is a Fermat liar --- The supplied array as contains composites only +------------------------------------------------------------------------------} + +-- Checks if the value k is a Fermat liar. +-- The supplied array contains composites only. +-- +-- f :: k -> [composites] -> return primality check fermatLiar :: Int -> [Integer] -> IO Integer fermatLiar k (a:as) = do liar <- primeTestsF k a @@ -76,34 +119,30 @@ fermatLiar k (a:as) = do then return a else fermatLiar k as --- Finds the smallest fermat liar for the supplied k value. --- Returns the smallest value after n random tests. +-- Returns the smallest fermat liar for the supplied k value +-- after n tests. -- --- leastCompositeNum k -> composites -> current attempt -> max attempts -> fermatLiar results -> smallest fermat liar +-- f :: k -> [composites] -> cur attempt -> max attempts -> [fermatLiars] -> return smallest fermat liar leastCompositeNum :: Int -> [Integer] -> Int -> Int -> [Integer] -> IO Integer leastCompositeNum k as n s xs = if (n == s) then return $ minimum xs else do liar <- fermatLiar k as - --leastCompositeNum k as (n+1) xs leastCompositeNum k as (n+1) s $ xs ++ [liar] ass4 = do - let max = 50 - let start = 0 - --ki <- leastCompositeNum i composites start max [] - --print ("k = i, " ++ show max ++ " tests, smallest least composite number : " ++ show ki) - k1 <- leastCompositeNum 1 composites start max [] - print ("k = 1, " ++ show max ++ " tests, smallest least composite number : " ++ show k1) - k2 <- leastCompositeNum 2 composites start max [] - print ("k = 2, " ++ show max ++ " tests, smallest least composite number : " ++ show k2) - k3 <- leastCompositeNum 3 composites start max [] - print ("k = 3, " ++ show max ++ " tests, smallest least composite number : " ++ show k3) - k5 <- leastCompositeNum 4 composites start max [] - print ("k = 5, " ++ show max ++ " tests, smallest least composite number : " ++ show k5) - k10 <- leastCompositeNum 10 composites start max [] - print ("k = 10, " ++ show max ++ " tests, smallest least composite number : " ++ show k10) + let max = 100 + k1 <- leastCompositeNum 1 composites 0 max [] + print ("k = 1, " ++ show max ++ " tests, least composite number : " ++ show k1) + k2 <- leastCompositeNum 2 composites 0 max [] + print ("k = 2, " ++ show max ++ " tests, least composite number : " ++ show k2) + k3 <- leastCompositeNum 3 composites 0 max [] + print ("k = 3, " ++ show max ++ " tests, least composite number : " ++ show k3) + k5 <- leastCompositeNum 4 composites 0 max [] + print ("k = 5, " ++ show max ++ " tests, least composite number : " ++ show k5) + k10 <- leastCompositeNum 10 composites 0 max [] + print ("k = 10, " ++ show max ++ " tests, least composite number : " ++ show k10) {------------------------------------------------------------------------------ @@ -111,8 +150,20 @@ Assignment 5 Hours spent: 1h +A carmichael number is an odd positive composite number that satisfies fermats +little theorem. + +Result: + +"k = 1, first 15 Carmichael numbers, avg of 500 tests. Percentage of false positives : 99.43995" +"k = 2, first 15 Carmichael numbers, avg of 500 tests. Percentage of false positives : 98.639885" +"k = 3, first 15 Carmichael numbers, avg of 500 tests. Percentage of false positives : 98.27986" +"k = 5, first 15 Carmichael numbers, avg of 500 tests. Percentage of false positives : 96.94645" +"k = 10, first 15 Carmichael numbers, avg of 500 tests. Percentage of false positives : 94.413086" +"k = 100, first 15 Carmichael numbers, avg of 500 tests. Percentage of false positives : 69.08004" ------------------------------------------------------------------------------} +-- f :: returns [carmichael numbers] carmichael :: [Integer] carmichael = [ (6*k+1)*(12*k+1)*(18*k+1) | @@ -124,7 +175,7 @@ carmichael = -- Check if the carmichael number -- passes the primeTest test -- --- fermatCarMichael k, carmichael number +-- f :: k -> carmichael number -> return primality check fermatCarMichael :: Int -> Integer -> IO Integer fermatCarMichael k a = do liar <- primeTestsF k a @@ -133,9 +184,10 @@ fermatCarMichael k a = do else return 0 -- Check for the first n carmichael numbers if they --- can pass the primeTest. +-- can pass the primeTest. +-- Function returns the false positive percentage. -- --- fermatCarMichaelN k, numbers, start, end, result +-- f :: k -> [carmichael] -> cur attempt -> max attempts -> running [result] -> returns false positive % fermatCarMichaelN :: Int -> [Integer] -> Int -> Int -> [Integer] -> IO Float fermatCarMichaelN k (a:as) n s xs = if (n == s) @@ -144,10 +196,10 @@ fermatCarMichaelN k (a:as) n s xs = fooled <- fermatCarMichael k a fermatCarMichaelN k as (n+1) s $ xs ++ [fooled] --- Check to see the amount of times we can generate --- absolute Fermat pseudoprimes. +-- Returns the average false positive percentage of a +-- fermatCarMichaelN k check. -- --- avgCarMichael :: k -> current Iter -> stop Iter -> running value -> first X numbers +-- f :: k -> current Iter -> stop Iter -> running value -> first X numbers -> returns avg false positive % avgCarMichael :: Int -> Int -> Int -> Float -> Int -> IO Float avgCarMichael k n s x upTo = if (n == s) @@ -156,21 +208,28 @@ avgCarMichael k n s x upTo = res <- fermatCarMichaelN k carmichael 0 upTo [] avgCarMichael k (n + 1) s (x + res) upTo --- ass5 = do - -- iterates the first x carMichael numbers - let upTo = 500 - let tries = 10 -- 500 + -- iterates the first x carMichael numbers + let upTo = 15 + let tries = 500 -- 500 k1 <- avgCarMichael 1 0 tries 0.0 upTo - print ("k = 1, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k1) + print ("k = 1, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k1) k2 <- avgCarMichael 2 0 tries 0.0 upTo - print ("k = 2, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k2) + print ("k = 2, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k2) k3 <- avgCarMichael 3 0 tries 0.0 upTo - print ("k = 3, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k3) + print ("k = 3, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k3) k5 <- avgCarMichael 5 0 tries 0.0 upTo - print ("k = 5, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k5) + print ("k = 5, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k5) k10 <- avgCarMichael 10 0 tries 0.0 upTo - print ("k = 10, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k10) + print ("k = 10, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k10) + k100 <- avgCarMichael 100 0 tries 0.0 upTo + print ("k = 100, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k100) {------------------------------------------------------------------------------ @@ -178,12 +237,27 @@ Assignment 6_1 Hours spent: 0.5h -Answer: results much more better because blablaba (compare ass5 versus ass6a) +Using the miller rabin check instead of Fermat's primality rerunning exercise 5 gives +the following results: + +"k = 1, first 500 Carmichael numbers, avg of 10 tests. Percentage of false positives : 10.4" +"k = 2, first 500 Carmichael numbers, avg of 10 tests. Percentage of false positives : 1.0" +"k = 3, first 500 Carmichael numbers, avg of 10 tests. Percentage of false positives : 0.18" +"k = 5, first 500 Carmichael numbers, avg of 10 tests. Percentage of false positives : 0.0" +"k = 10, first 500 Carmichael numbers, avg of 10 tests. Percentage of false positives : 0.0" +"k = 100, first 500 Carmichael numbers, avg of 10 tests. Percentage of false positives : 0.0" + +The results show that the miller rabin check is much more accurate for a low k and with k > 4 +the check performs reliable with no false positives. + +This is because Rabin-miller extends Fermat's primality check by checking if the number +has exactly two trivial square roots of unity modules n. ------------------------------------------------------------------------------} + -- Check if the carmichael number -- passes the Miller-Rabin test -- --- mrCarMichael k, carmichael number +-- f :: k -> carmichael number -> return primality check mrCarMichael :: Int -> Integer -> IO Integer mrCarMichael k a = do liar <- primeMR k a @@ -193,8 +267,9 @@ mrCarMichael k a = do -- Check for the first n carmichael numbers if they -- can pass the Miller-Rabin test. +-- Function returns the false positive percentage. -- --- mrCarMichaelN k, numbers, start, end, result +-- f :: k -> [carmichael] -> cur attempt -> max attempts -> running [result] -> returns false positive % mrCarMichaelN :: Int -> [Integer] -> Int -> Int -> [Integer] -> IO Float mrCarMichaelN k (a:as) n s xs = if (n == s) @@ -203,10 +278,10 @@ mrCarMichaelN k (a:as) n s xs = fooled <- mrCarMichael k a mrCarMichaelN k as (n+1) s $ xs ++ [fooled] --- Check to see the amount of times we can generate --- absolute Fermat pseudoprimes. +-- Returns the average false positive percentage of a +-- Miller-Rabin check. -- --- avgMillerRabin :: k -> current Iter -> stop Iter -> running value -> first X numbers +-- f :: k -> current Iter -> stop Iter -> running value -> first X numbers -> returns avg false positive % avgMillerRabin :: Int -> Int -> Int -> Float -> Int -> IO Float avgMillerRabin k n s x upTo = if (n == s) @@ -218,17 +293,25 @@ avgMillerRabin k n s x upTo = ass6a = do -- iterates the first x carMichael numbers let upTo = 500 - let tries = 10 -- 500 + let tries = 500 -- 500 k1 <- avgMillerRabin 1 0 tries 0.0 upTo - print ("k = 1, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k1) + print ("k = 1, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k1) k2 <- avgMillerRabin 2 0 tries 0.0 upTo - print ("k = 2, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k2) + print ("k = 2, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k2) k3 <- avgMillerRabin 3 0 tries 0.0 upTo - print ("k = 3, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k3) + print ("k = 3, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k3) k5 <- avgMillerRabin 5 0 tries 0.0 upTo - print ("k = 5, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k5) + print ("k = 5, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k5) k10 <- avgMillerRabin 10 0 tries 0.0 upTo - print ("k = 10, first " ++ show upTo ++ " carMichael numbers, average of " ++ show tries ++ " tests. Percentage of Fermat pseudoprimes : " ++ show k10) + print ("k = 10, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k10) + k100 <- avgMillerRabin 100 0 tries 0.0 upTo + print ("k = 100, first " ++ show upTo ++ " Carmichael numbers, avg of " ++ show tries ++ + " tests. Percentage of false positives : " ++ show k10) {------------------------------------------------------------------------------ @@ -236,8 +319,15 @@ Assignment 6_2 Hours spent: 1h +"k = 1, first 15 Mersenne primes, avg of 5 tests. Sorted by small to large : 80.0%, results contained only Mersenne primes 80.0%" +"k = 2, first 15 Mersenne primes, avg of 5 tests. Sorted by small to large : 100.0%, results contained only Mersenne primes 100.0%" +"k = 5, first 15 Mersenne primes, avg of 5 tests. Sorted by small to large : 100.0%, results contained only Mersenne primes 100.0%" + +A k = 2 is sufficient to discover the first 15 Mersenne primes reliably using +the Miller-Rabin primality check ------------------------------------------------------------------------------} +-- List containing the first 47 Mersenne exponents -- Source: https://oeis.org/A000043 mersenneExp :: [Integer] mersenneExp = [2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 2203, 2281, 3217, @@ -245,42 +335,71 @@ mersenneExp = [2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 220 216091, 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, 20996011, 24036583, 25964951, 30402457, 32582657, 37156667, 42643801, 43112609] --- discoverMersenneN startingPrime -> # of primeMR tests -> primes list -> max # of mersenne primes -> running mersenne primes -discoverMersenneN :: Int -> Int -> [Integer] -> Int -> [Integer] -> IO [Integer] -discoverMersenneN iPrime t (p:ps) n xs = +-- Returns the first n mersenne numbers +-- in a list. +-- Goes upto mersenne number 25 (2^21701-1) +-- Warning, very slow for n > 10 +-- +-- f :: n -> returns [n mersenne primes] +mers2List :: Integer -> [Integer] +mers2List 0 = [] +mers2List n = mers2List (n - 1) ++ [mers n] + +-- Function that discovers mersenne numbers using +-- the Miller-Rabin primality check. +-- If a prime p passes the Miller check with 2 ^ p - 1 +-- p is a mersenne nummber +-- +-- f :: k -> n results -> [primes i] -> running results -> returning [n results] +discoverMersenneN :: Int -> Int -> Int -> [Integer] -> IO [Integer] +discoverMersenneN k n i xs = if (n == (length xs)) then return xs else do - let mp = 2 ^ (primes !! iPrime) - 1 - isPrime <- primeMR t mp + let p = (primes !! i) + let mp = 2 ^ p - 1 + isPrime <- primeMR k mp if isPrime - then discoverMersenneN (iPrime+1) t ps n $ xs ++ [p] - else discoverMersenneN (iPrime+1) t ps n xs - --- startingPrime -> current Iter -> stop Iter -> # of primeMR tests -> primes list -> max # of mersenne primes -> Orderd mersennes -> Only mersennes -avgDiscoverMersenneN :: Int -> Int -> Int -> Int -> [Integer] -> Int -> Int -> Int -> IO (Float, Float) -avgDiscoverMersenneN sPrime b stop t ps upTo os cs = - if (b == stop) - then return ((fromIntegral cs) / (fromIntegral stop) * 100, (fromIntegral os) / (fromIntegral stop)* 100) + then discoverMersenneN k n (i + 1) $ xs ++ [mp] + else discoverMersenneN k n (i + 1) xs + +-- Returns the average accuracy for the the Miller-Rabin +-- primality check to discover mersenne numbers. +-- +-- Checks two things: +-- If Miller-Rabin can generate the first n Mersenne primes in the correct order with given k. +-- If Miller-Rabin only generates Mersenne primes with given k. +-- +-- f :: k -> current Iter -> stop Iter -> [Mersennes] -> n results -> running result -> running result -> avg (order, correct) +avgDiscoverMersenneN :: Int -> Int -> Int -> [Integer] -> Int -> Int -> Int -> IO (Float, Float) +avgDiscoverMersenneN k n s ms upTo os cs = + if (n == s) + then return (((fromIntegral cs / fromIntegral s) * 100), (fromIntegral os / fromIntegral s) * 100) else do - m <- discoverMersenneN sPrime t ps upTo [] - -- check if order of mersenne list is correct from small to big - let osi = fromEnum (m == take upTo mersenneExp) + m <- discoverMersenneN k upTo 0 [] + -- check if the mersenne list is ordered by small to big + let osi = fromEnum (m == ms) -- check if all mersenne primes are correct - let csi = fromEnum (m == (intersect m mersenneExp)) - avgDiscoverMersenneN sPrime (b+1) stop t ps upTo (os + osi) (cs + csi) + let csi = fromEnum (m == (intersect m ms)) + avgDiscoverMersenneN k (n + 1) s ms upTo (os + osi) (cs + csi) -- Find the first 15 mersenne exponents ass6b = do let upTo = 15 - let bench = 10 - -- primeMR 1 mp - m1 <- avgDiscoverMersenneN 0 0 bench 1 primes upTo 0 0 - print ("Avg of " ++ show bench ++ " runs with: primeMR 1 x and " ++ show upTo ++ " mersenne primes: " ++ (show (fst m1)) ++ "% of the lists contained only correct values and " ++ (show (snd m1)) ++ "% orderd by small to large") - -- primeMR 10 mp - m10 <- avgDiscoverMersenneN 0 0 bench 10 primes upTo 0 0 - print ("Avg of " ++ show bench ++ " runs with: primeMR 10 x and " ++ show upTo ++ " mersenne primes: " ++ (show (fst m10)) ++ "% of the lists contained only correct values and " ++ (show (snd m10)) ++ "% orderd by small to large") - + let mersList = mers2List $ toInteger upTo + let tries = 5 + m1 <- avgDiscoverMersenneN 1 0 tries mersList upTo 0 0 + print ("k = 1, first " ++ show upTo ++ " Mersenne primes, avg of " ++ show tries ++ + " tests. Sorted by small to large : " ++ (show (fst m1)) ++ + "%, results contained only Mersenne primes " ++ (show (snd m1)) ++ "%") + m2 <- avgDiscoverMersenneN 2 0 tries mersList upTo 0 0 + print ("k = 2, first " ++ show upTo ++ " Mersenne primes, avg of " ++ show tries ++ + " tests. Sorted by small to large : " ++ (show (fst m2)) ++ + "%, results contained only Mersenne primes " ++ (show (snd m2)) ++ "%") + m5 <- avgDiscoverMersenneN 5 0 tries mersList upTo 0 0 + print ("k = 5, first " ++ show upTo ++ " Mersenne primes, avg of " ++ show tries ++ + " tests. Sorted by small to large : " ++ (show (fst m5)) ++ + "%, results contained only Mersenne primes " ++ (show (snd m5)) ++ "%") {------------------------------------------------------------------------------ @@ -303,8 +422,6 @@ rsaPrimePair :: Int -> IO (Integer, Integer) rsaPrimePair n = do p <- genNBitPrime n q <- genNBitPrime n - -- bit length check? - -- -- check iff unique if (p /= q) then return (p, q) @@ -317,7 +434,6 @@ ass7 = do let publicKey = rsaPublic (fst pq) (snd pq) let privateKey = rsaPrivate (fst pq) (snd pq) -- message - -- -- perhaps add hash/seriliaztion to bypass Integer limitation let msg = 123456789 print ("Original message: " ++ show msg) From c89a89b9dc0c892b7e969d3f483ac6008c824ff7 Mon Sep 17 00:00:00 2001 From: Ewoudbouman Date: Sun, 14 Oct 2018 20:15:13 +0200 Subject: [PATCH 2/2] ouwe meuk moest nog weg --- Lab6/ewoud/Lab6.hs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/Lab6/ewoud/Lab6.hs b/Lab6/ewoud/Lab6.hs index afcc582..5f0e659 100644 --- a/Lab6/ewoud/Lab6.hs +++ b/Lab6/ewoud/Lab6.hs @@ -327,14 +327,6 @@ A k = 2 is sufficient to discover the first 15 Mersenne primes reliably using the Miller-Rabin primality check ------------------------------------------------------------------------------} --- List containing the first 47 Mersenne exponents --- Source: https://oeis.org/A000043 -mersenneExp :: [Integer] -mersenneExp = [2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 2203, 2281, 3217, - 4253, 4423, 9689, 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503, 132049, - 216091, 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, - 20996011, 24036583, 25964951, 30402457, 32582657, 37156667, 42643801, 43112609] - -- Returns the first n mersenne numbers -- in a list. -- Goes upto mersenne number 25 (2^21701-1)