Sparse.hs

{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE TypeOperators #-}
module Test.Data.Array.Accelerate.Arithmetic.Sparse where

import Test.Data.Array.Accelerate.Arithmetic.Utility (arbitraryArray, (=!=), )

import qualified Data.Array.Accelerate.Arithmetic.Sparse as Sparse
import qualified Data.Array.Accelerate.Arithmetic.LinearAlgebra as LinAlg

import qualified Data.Array.Accelerate as A
import Data.Array.Accelerate (Z(Z), (:.)((:.)))

import qualified Test.QuickCheck as QC

import Control.Monad (liftM2, )

import Data.Word (Word32, )


data
   CRVTriple a =
      CRVTriple
         (Sparse.ColumnMatrix Z a)
         (Sparse.RowMatrix Z a)
         (LinAlg.Vector Z a)

instance (QC.Arbitrary a, A.Elt a) => QC.Arbitrary (CRVTriple a) where
   arbitrary = do
      k <- QC.choose (1,200)
      nc <- QC.choose (1,100)
      nr <- QC.choose (1,100)
      cc <- QC.choose (1,10)
      cr <- QC.choose (1,10)
      mc <-
         arbitraryArray (Z :. cc :. k) $
         liftM2 (,) (QC.choose (0,nc-1)) QC.arbitrary
      mr <-
         arbitraryArray (Z :. k :. cr) $
         liftM2 (,) (QC.choose (0,nr-1)) QC.arbitrary
      v <- arbitraryArray (Z :. nr) QC.arbitrary
      return $
         CRVTriple
            (Sparse.ColumnMatrix (A.lift nc) (A.use mc))
            (Sparse.RowMatrix (A.lift nr) (A.use mr))
            (A.use v)


multiplication :: CRVTriple Word32 -> Bool
multiplication (CRVTriple mc mr v) =
   LinAlg.multiplyMatrixVector (Sparse.multiplyMatrixMatrix mc mr) v
   =!=
   Sparse.multiplyColumnMatrixVector mc (Sparse.multiplyRowMatrixVector mr v)