CODEWITHSUNDEEP
haskell
user1480139
user1480139

Reputation: 383

Haskell program that gives pretty prime numbers

I've made a haskell program that computes pretty prime numbers. Pretty primes are primes that are very close to a power of 2. You give 2 numbers for example: 10 and 20 then it returns 17 because 17 is the closest to a power of 2. 17 - 16 = 1 so it is the closest.

I've made this:

EDIT: I've rewrote the primefunction like this and e verw function but still getting -1.

  -- Geeft priemgetallen terug tussen de 2 grenzen
-- English: Gives primenumbers between 2 numbers
priemgetallen :: Int->[Int]
priemgetallen b = take b (zeef [2..])
    where zeef (p:xs) = p : zeef [x | x<-xs, (mod x p) /= 0]

-- Geeft machten terug tussen de 2 grenzen
-- English: Gives powers of 2 between 2 numbers
machten :: Int->Int->[Int]
machten a b 
        | a <= 2 = 2:[2^x| x<-[2..b], (2^x) `mod` 2 == 0, 2^x < b, 2^x > a]
        | otherwise = [2^x| x<-[2..b], (2^x) `mod` 2 == 0, 2^x < b, 2^x > a]

-- English: the start of the function
prettyprime :: Int->Int->Int
prettyprime a b = vergelijk ( verw a (priemgetallen b)) (machten a b)

-- Filter the list
verw :: Int->[Int]->[Int]
verw _ [] = []
verw k (x:xs)
    | x > k = [x] ++ verw k xs
    | otherwise = verw k xs

-- Vergelijkt alle priemgetallen en geeft welke korste bij het ander ligt
-- English this function must see what primenumber is the closest to a power of 2 but I can't fix it
vergelijk :: [Int]->[Int]->Int
vergelijk [] _ = -1
vergelijk _ [] = -1
vergelijk (x:xs) (y:ys)
            | x - y < vergelijk (x:xs) ys = x
            | x - y > vergelijk (x:xs) ys = vergelijk xs (y:ys)
            | x - y == vergelijk (x:xs) ys = x




main = do
       print $ prettyprime 14 20

Can someone help me?

Kind regards,

Upvotes: 0

Views: 277

Answers (1)

Daniel Wagner
Daniel Wagner

Reputation: 152682

The incomplete pattern is because you've omitted the case when x - y == vergelijk (x:xs) ys. The compiler is capable of warning you about this if you add -fwarn-incomplete-patterns and convert your guards into a real case:

vergelijk (x:xs) (y:ys) = case compare (x - y) (vergelijk (x:xs) ys) of
    LT -> x
    -- you will get a warning about having no case for EQ
    GT -> vergelijk xs (y:ys)

As a bonus, this version is much less likely to recompute the recursive call, especially on low optimization levels.

Upvotes: 3

Related Questions