1:
2:
3:
4:
5:
6:
7:
8:

primalityCheck :: Integer -> Bool
primalityCheck n | n < 2 = False
                 | n == 2 || n == 3 || n== 5 || n== 7 = True
                 | otherwise = head $ (filter (==False) $ map (\x -> n `mod` x  /= 0) ([2,3,5,7] ++ [11,13..m]))++ [True]
			where m = floor $ sqrt( fromIntegral n)

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

bool primality_check(int n) 
{
      // numbers less than 2 are not prime;
      if (n < 2)
            return  false;
      
      
      // check for n==2 or whether n even 
      if(n == 2) 
           return true;
      else if(n % 2 == 0) 
           return false;

      // check all possible odd divisors up to sqrt(n):
      for (int i = 3; i * i <= n; i += 2)
      {
            if (n % i == 0)
                  return false;
      }

      return true;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

-- sqrRoot n ist effektiv floor $ sqrt n. Im Gegensatz zu Letzterem ist das 
-- Ergebnis sogar für beliebig große Zahlen korrekt. 
sqrRoot :: Integer -> Integer
sqrRoot 0 = 0
sqrRoot 1 = 1
sqrRoot n =
   let powers = iterate (^2) 2
       (lowerRt, lowerN) =
          last $ takeWhile ((n>=) . snd) $ zip (1:powers) powers
       newtonStep x = div (x + div n x) 2
       iters = iterate newtonStep (sqrRoot (div n lowerN) * lowerRt)
       isRoot r  =  r^2 <= n && n < (r+1)^2
   in  head $ dropWhile (not . isRoot) iters

primalityCheck :: Integer -> Bool
primalityCheck n | n < 2 = False
                 | otherwise = head $ (filter (==False) $ map (\x -> n `mod` x  /= 0) ([2,3,5,7] ++ [11,13..m]))++ [True]
			where m = sqrRoot n