--
-- A k-means clustering implementation.
-- Run the generate-samples program first to create some random data.
--

module Main where

import Kmeans
import Config

import Data.Array.Accelerate                            as A
import Data.Array.Accelerate.Examples.Internal          as A

import Control.Applicative
import Control.Monad                                    ( unless )
import Data.Binary                                      ( decodeFile )
import Data.Label                                       ( get )
import System.Directory
import Prelude                                          as P


main :: IO ()
main = do

  beginMonitoring
  (_, opts, rest)       <- parseArgs options defaults header footer

  inputs                <- (P.&&) <$> doesFileExist "points.bin"
                                  <*> doesFileExist "clusters"
  unless inputs $ do
    error "Run the GenSamples program first to generate random data"

  points'               <- decodeFile "points.bin"
  initial'              <- read `fmap` readFile "clusters"

  let nclusters   = P.length initial'
      npoints     = P.length points'

      solve       = run1 backend (kmeans (use points))
      backend     = get optBackend opts

      initial :: Vector (Cluster Float)
      initial = A.fromList (Z:.nclusters) initial'

      points :: Vector (Point Float)
      points = A.fromList (Z:.npoints) points'

  -- Warm up first by printing the expected results
  --
  putStrLn $ "number of points: " P.++ show npoints
  putStrLn $ "final clusters:\n"  P.++
    unlines (P.map show (A.toList (solve initial)))

  -- Now benchmark
  --
  runBenchmarks opts rest
    [ bench "k-means" $ whnf solve initial ]