fork(1) download
copy 
  1. {-# LANGUAGE ScopedTypeVariables #-}
  2. import Control.Monad.ST
  3. import Data.Array.ST
  4. import Data.Array.Unboxed
  5. import Data.Array.IO
  6. import Data.Foldable
  7. import Data.Binary
  8. import Data.Int
  9. import qualified Data.ByteString.Lazy as B
  10. import Control.Monad
  11. import System.IO
  12. import System.Random
  13. import System.Directory
  14. import System.Environment
  15.  
  16. partition :: (Enum b, Num b, Ord e, Ix b, MArray a e m) => a b e -> b -> b -> b -> m b
  17. partition arr left right pivotIndex = do
  18.   pivotValue <- readArray arr pivotIndex
  19.   swap arr pivotIndex right
  20.   storeIndex <- foreachWith [left..right-1] left (\i storeIndex -> do
  21. 	val <- readArray arr i
  22. 	if (val <= pivotValue)
  23. 	  then do
  24. 	    swap arr i storeIndex
  25. 	    return (storeIndex + 1)
  26. 	  else do
  27. 	    return storeIndex )
  28.   swap arr storeIndex right
  29.   return storeIndex
  30.  
  31. qsort :: (Integral t, Ord e, Ix t, MArray a e m) => a t e -> t -> t -> m ()
  32. qsort arr left right = when (right > left) $ do
  33.   let pivotIndex = left + ((right-left) `div` 2)
  34.   newPivot <- partition arr left right pivotIndex
  35.   qsort arr left (newPivot - 1)
  36.   qsort arr (newPivot + 1) right
  37.  
  38. swap :: (Ix i, MArray a e m) => a i e -> i -> i -> m ()
  39. swap arr left right = do
  40.     leftVal <- readArray arr left
  41.     rightVal <- readArray arr right
  42.     writeArray arr left rightVal
  43.     writeArray arr right leftVal
  44.  
  45. foreachWith xs v f = foldlM (flip f) v xs
  46.  
  47. size :: N
  48. size = 1000000
  49.  
  50. path :: String
  51. path = "dataH.dat"
  52.  
  53. type N = Int32
  54.  
  55. generate :: N -> N -> UArray N N
  56. generate size seed = listArray (fromIntegral 0, size) $ take ((fromIntegral size) + 1) . randomRs (-224, 228) . mkStdGen $ fromIntegral seed
  57.  
  58. main :: IO ()
  59. main = do
  60.   fileExist <- doesFileExist path
  61.   if fileExist
  62. 	then do
  63. 	  (arrRead :: UArray N N) <- return . decode =<< B.readFile path
  64. 	  (arrMutable :: IOUArray N N) <- thaw arrRead
  65. 	  qsort arrMutable 0 size
  66. 	  (arrSorted :: UArray N N) <- freeze arrMutable
  67. 	  print $ arrSorted ! 1
  68. 	  print $ arrSorted ! size
  69. 	else do 
  70.       (B.writeFile path . encode) $ generate size (42 :: N)
  71.       print "Run me again!"
  72.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.hs:12:8:
    Could not find module `System.Random'
    Use -v to see a list of the files searched for.
stdout
copy 
Standard output is empty
https://ideone.com/0uWU4X
language:
Haskell (ghc 8.4.4)
created:
12 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!