Enclosing Circle Problem implementation in Haskell
As per request by Mihai , here is the accepted code of spoj problem . The only error in previous code was " The minimal enclosing circle is determined by the diametric circle of S ".  Instead of finding a circle passing through two points , i was calculating circle from three points. 

import Data.List
import qualified Data.Sequence as DS 
import Text.Printf
import Data.Function ( on ) 


data Point a = P a a deriving ( Show , Ord , Eq ) 
data Turn = S | L | R deriving ( Show , Eq , Ord , Enum  ) -- straight left right  


--start of convex hull  http://en.wikipedia.org/wiki/Graham_scan
{--
compPoint :: ( Num  a , Ord a ) =&gt; Point a -&gt; Point a -&gt; Ordering
compPoint ( P x1 y1 ) ( P x2 y2 )
  | compare x1 x2 == EQ = compare y1 y2
  | otherwise = compare x1 x2 

findMinx :: ( Num a , Ord a ) =&gt; [ Point a ] -&gt; [ Point a ]
findMinx xs = sortBy ( \x  y  -&gt; compPoint  x y  ) xs

compAngle ::(Num a , Ord a ) =&gt; Point a -&gt; Point a -&gt; Point a -&gt; Ordering
compAngle ( P x1 y1 ) ( P x2 y2 ) ( P x0 y0 ) = compare ( (  y1 - y0 ) * ( x2 - x0 )  ) ( ( y2 - y0) * ( x1 - x0 ) )

sortByangle :: ( Num a , Ord a ) =&gt; [ Point a ] -&gt; [ Point a ]
sortByangle (z:xs) = z : sortBy ( \x y -&gt; compAngle x y z ) xs 

convexHull ::( Num a , Ord a )  =&gt; [ Point a ] -&gt; [ Point a ]
convexHull xs = reverse . findHull [y,x]  $ ys where
    (x:y:ys) = sortByangle.findMinx $ xs 

findTurn :: ( Num a , Ord a , Eq a ) =&gt; Point a -&gt; Point a -&gt; Point a -&gt; Turn
findTurn ( P x0 y0 ) ( P x1 y1 ) ( P x2 y2 )
  | ( y1 - y0 ) * ( x2- x0 ) &lt; ( y2 - y0 ) * ( x1 - x0 ) = L
  | ( y1 - y0 ) * ( x2- x0 ) == ( y2 - y0 ) * ( x1 - x0 ) = S
  | otherwise = R 

findHull :: ( Num a , Ord a  )  =&gt; [ Point a ] -&gt;   [ Point a ] -&gt; [ Point a ]
findHull [x]  ( z : ys )  = findHull [ z , x ]  ys  --incase of second point  on line from x to z
findHull xs  [] = xs
findHull ( y : x : xs )  ( z:ys )
   | findTurn x y z == R = findHull (  x : xs )   ( z:ys )
   | findTurn x y z == S = findHull (  x : xs )   ( z:ys )
   | otherwise = findHull ( z : y : x : xs  )   ys
--}

--start of monotone hull give .04 sec lead over graham scan 

compPoint :: ( Num  a , Ord a ) =&gt; Point a -&gt; Point a -&gt; Ordering
compPoint ( P x1 y1 ) ( P x2 y2 )
  | compare x1 x2 == EQ = compare y1 y2
  | otherwise = compare x1 x2 

sortPoint :: ( Num a , Ord a ) =&gt; [ Point a ] -&gt; [ Point a ]
sortPoint xs = sortBy ( \ x y -&gt; compPoint x y ) xs


findTurn :: ( Num a , Ord a , Eq a ) =&gt; Point a -&gt; Point a -&gt; Point a -&gt; Turn
findTurn ( P x0 y0 ) ( P x1 y1 ) ( P x2 y2 )
 | ( y1 - y0 ) * ( x2- x0 ) &lt; ( y2 - y0 ) * ( x1 - x0 ) = L
 | ( y1 - y0 ) * ( x2- x0 ) == ( y2 - y0 ) * ( x1 - x0 ) = S
 | otherwise = R 


hullComputation :: ( Num a , Ord a ) =&gt; [ Point a ] -&gt; [ Point a ] -&gt; [ Point a ]
hullComputation [x] ( z:ys ) = hullComputation [z,x] ys
hullComputation xs [] = xs
hullComputation  ( y : x : xs ) ( z : ys )
  |  findTurn x y z == R = hullComputation ( x:xs ) ( z : ys )
  |  findTurn x y z == S = hullComputation ( x:xs ) ( z : ys )
  |  otherwise = hullComputation ( z : y : x : xs ) ys 


convexHull :: ( Num a , Ord a ) =&gt; [ Point a ] -&gt; [ Point a ]
convexHull xs = final where
    txs = sortPoint xs
    ( x : y : ys  ) = txs
        lhull = hullComputation [y,x] ys
    ( x': y' : xs' ) = reverse txs
    uhull = hullComputation [ y' , x' ] xs'
    final = ( init lhull ) ++ ( init uhull )  

--end of convex hull 
--start of finding point algorithm http://www.personal.kent.edu/~rmuhamma/Compgeometry/MyCG/CG-Applets/Center/centercli.htm  Applet’s Algorithm 


findAngle :: ( Num a , Ord a , Floating a ) =&gt; Point a -&gt; Point a -&gt; Point  a  -&gt; ( Point a , Point a , Point  a , a ) 
findAngle u@(P x0 y0 ) v@(P x1 y1 ) t@(P x2 y2)  
    | u == t || v == t = ( u , v , t , 10 * pi )  -- two points are same so set the angle more than pi  
    | otherwise =  ( u , v, t , ang ) where
        ang = acos $  ( b + c - a ) / ( 2.0 * ( sqrt $ b * c ) )  where
        sqrDist ( P x y ) ( P x' y' ) = ( x - x' ) ^ 2 + ( y - y' ) ^ 2 
        [ b , c , a ] = map ( uncurry sqrDist ) [ ( u , t ) , ( v , t ) , ( u , v ) ]



 findPoints :: ( Num a , Ord a , Floating a ) =&gt; Point a -&gt; Point a -&gt; [ Point  a ] -&gt; ( Point a  , a ) 
 findPoints u v xs 
  | 2 * theta &gt;= pi   =  circle2Points a b  --( a , b , t , theta ) 
  | and [ 2 * alpha &lt;= pi , 2 * beta &lt;= pi ]   = circle3Points a b t --( a , b , t , theta )  
  | otherwise = if 2 * alpha &gt; pi then findPoints v t xs else findPoints u t xs 
     where   
    ( a , b , t , theta ) = minimumBy ( on compare fn  ) . map ( findAngle u v )  $ xs 
    fn ( _ , _ , _ , t ) = t 
        ( _ , _ , _ , alpha ) = findAngle v t u  --angle between v u t angle subtended at u by v t
    ( _ , _ , _ , beta ) = findAngle u t v   -- angle between u v t angle subtended at v by  u t



--end of finding three points algorithm
--find the circle through three points http://paulbourke.net/geometry/circlefrom3/ 


circle2Points :: ( Num a , Ord a , Floating a ) =&gt; Point a -&gt; Point a -&gt; ( Point a , a ) 
circle2Points ( P x0 y0 ) ( P x1 y1 ) = ( P x y , r ) where 
    x = ( x0 + x1 ) / 2.0
    y = ( y0 + y1 ) / 2.0
    r = sqrt $ ( x0 - x1 ) ^ 2 + ( y0 - y1 ) ^ 2 


circle3Points :: ( Num a , Ord a , Floating a ) =&gt; Point a -&gt; Point a -&gt; Point a -&gt; (  Point a , a ) --( center , radius )
circle3Points u@(P x1 y1 ) v@(P x2 y2 ) t@(P x3 y3 ) 
    | x2 == x1 = circle3Points u t v 
    | x3 == x2 = circle3Points v u t 
    | otherwise =  ( P x y , 2 *  r )   
      where 
        m1 = ( y2 - y1 ) / ( x2 - x1 ) 
        m2 = ( y3 - y2 ) / ( x3 - x2 ) 
        x = (  m1 * m2 * ( y1 - y3 )  +   m2 * ( x1 + x2 )  -  m1 * ( x2 + x3 )  ) / ( 2 * ( m2 - m1 ) ) 
        y = if y2 /= y1 
                     then ( ( x1 + x2 -  2 * x  ) / ( 2 * m1 ) ) + ( ( y1 + y2 ) / 2.0 ) 
              else  ( ( x2 + x3 -  2 * x  ) / ( 2 * m2 ) ) + ( ( y2 + y3 ) / 2.0 ) 
        r = sqrt $ ( x - x1 ) ^2 + ( y - y1 ) ^ 2 


--start of SPOJ code 


format::(Num a , Ord a ) =&gt; [[a]] -&gt; [Point a]
format xs = map (\[x0 , y0] -&gt; P x0 y0 ) xs 


readInt  ::( Num a , Read a ) =&gt;   String -&gt; a 
readInt  = read


solve :: ( Num a , Ord a , Floating a ) =&gt; [ Point a ] -&gt; (  Point a , a )
solve [ P x0 y0 ] = ( P x0 y0 , 0 ) --in case of one point
solve [ P x0 y0 , P x1 y1 ] = circle2Points ( P x0 y0 ) ( P x1 y1 )   -- in case of two points 
solve  xs = findPoints x y  t where 
    t@( x : y : ys )  = convexHull xs  


final :: ( Num a , Ord a , Floating a ) =&gt; ( Point a , a ) -&gt; a 
final ( t , w ) 
    | w == 0 = 0
    | otherwise =  w


main = interact $   ( printf "%.2f\n" :: Double -&gt; String ) . final . solve . convexHull . format . map  ( map readInt . words ) . tail . lines