Add more to LAPACK spec, add more docs.

Author: dmjio

shell.nix

@@ -10,7 +10,7 @@ in
       function test-runner () {
          ${pkgs.ag}/bin/ag -l | \
            ${pkgs.entr}/bin/entr sh -c \
-             'cabal build test && dist/build/test/test +RTS -N -RTS'
+             'cabal build test && dist/build/test/test'
       }
     '';
   })

src/ArrayFire/Arith.hs

@@ -135,39 +135,55 @@ ge x y (fromIntegral . fromEnum -> batch) = do
 eq
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of equal
 eq x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_eq arr arr1 arr2 batch
 
 neq
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of not equal
 neq x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_neq arr arr1 arr2 batch
 
 and
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of and
 and x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_and arr arr1 arr2 batch
 
 or
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of or
 or x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_or arr arr1 arr2 batch
@@ -181,57 +197,79 @@ not = flip op1 af_not
 bitAnd
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of bitwise and
 bitAnd x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_bitand arr arr1 arr2 batch
 
 bitOr
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of bit or
 bitOr x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_bitor arr arr1 arr2 batch
 
 bitXor
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of bit xor
 bitXor x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_bitxor arr arr1 arr2 batch
 
 bitShiftL
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of bit shift left
 bitShiftL x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_bitshiftl arr arr1 arr2 batch
 
 bitShiftR
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of bit shift right
 bitShiftR x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_bitshiftr arr arr1 arr2 batch
 
 cast
   :: forall a b . (AFType a, AFType b)
   => Array a
+  -- ^ Input array to cast
   -> Array b
+    -- ^ Result of cast
 cast afArr =
   coerce $ afArr `op1` (\x y -> af_cast x y dtyp)
     where
@@ -240,19 +278,27 @@ cast afArr =
 minOf
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of minimum of
 minOf x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_minof arr arr1 arr2 batch
 
 maxOf
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of maximum of
 maxOf x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_maxof arr arr1 arr2 batch
@@ -270,19 +316,27 @@ clamp a b c (fromIntegral . fromEnum -> batch) =
 rem
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of remainder
 rem x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_rem arr arr1 arr2 batch
 
 mod
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of mod
 mod x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_mod arr arr1 arr2 batch
@@ -368,19 +422,27 @@ atan = flip op1 af_atan
 atan2
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of atan2
 atan2 x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_atan2 arr arr1 arr2 batch
 
 cplx2
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of cplx2
 cplx2 x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_cplx2 arr arr1 arr2 batch
@@ -430,19 +492,27 @@ tanh = flip op1 af_tanh
 root
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of root
 root x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_root arr arr1 arr2 batch
 
 pow
   :: AFType a
   => Array a
+  -- ^ First input
   -> Array a
+  -- ^ Second input
   -> Bool
+  -- ^ Use batch
   -> Array a
+  -- ^ Result of pow
 pow x y (fromIntegral . fromEnum -> batch) = do
   x `op2` y $ \arr arr1 arr2 ->
     af_pow arr arr1 arr2 batch

src/ArrayFire/Array.hs

@@ -56,8 +56,11 @@ mkArray
   :: forall array
    . AFType array
   => [Int]
+  -- ^ Dimensions
   -> [array]
+  -- ^ Array elements
   -> Array array
+  -- ^ Returned array
 {-# NOINLINE mkArray #-}
 mkArray dims xs =
   unsafePerformIO . mask_ $ do

src/ArrayFire/BLAS.hs

@@ -20,10 +20,15 @@ import ArrayFire.Types
 -- | The following applies for Sparse-Dense matrix multiplication.
 --
 -- This function can be used with one sparse input. The sparse input must always be the lhs and the dense matrix must be rhs.
+--
 -- The sparse array can only be of AF_STORAGE_CSR format.
+--
 -- The returned array is always dense.
+--
 -- optLhs an only be one of AF_MAT_NONE, AF_MAT_TRANS, AF_MAT_CTRANS.
+--
 -- optRhs can only be AF_MAT_NONE.
+--
 matmul
   :: Array a
   -- ^ 2D matrix of Array a, left-hand side

src/ArrayFire/LAPACK.hs

@@ -16,10 +16,23 @@ import ArrayFire.FFI
 import ArrayFire.Types
 import ArrayFire.Internal.Defines
 
+-- | This function factorizes a matrix A into two unitary matrices U and Vt, and a diagonal matrix S such that
+-- A=U∗S∗Vt
+--
+-- If A has M rows and N columns, U is of the size M x M , V is of size N x N, and S is of size M x N
+--
+-- The arrayfire function only returns the non zero diagonal elements of S.
+--
 svd
   :: AFType a
   => Array a
+  -- ^ Input matrix
   -> (Array a, Array a, Array a)
+  -- ^ 'u' is the output array containing U
+  --
+  -- 'v' is the output array containing the diagonal values of sigma, (singular values of the input matrix))
+  --
+  -- 'vt' is the output array containing V^H
 svd = (`op3p` af_svd)
 
 svdInPlace
@@ -131,5 +144,5 @@ norm arr a b c =
   arr `infoFromArray` (\w y -> af_norm w y a b c)
 
 isLAPACKAvailable :: Bool
-isLAPACKAvailable = 
+isLAPACKAvailable =
   toEnum . fromIntegral $ afCall1' af_is_lapack_available

test/ArrayFire/LAPACKSpec.hs

@@ -10,3 +10,32 @@ spec =
   describe "LAPACK spec" $ do
     it "Should have LAPACK available" $ do
       A.isLAPACKAvailable `shouldBe` True
+    it "Should perform svd" $ do
+      let (s,v,d) = A.svd $ A.matrix @Double (4,2) (repeat 1)
+      A.getDims s `shouldBe` (4,4,1,1)
+      A.getDims v `shouldBe` (2,1,1,1)
+      A.getDims d `shouldBe` (2,2,1,1)
+    it "Should perform svd in place" $ do
+      let (s,v,d) = A.svdInPlace $ A.matrix @Double (4,2) (repeat 1)
+      A.getDims s `shouldBe` (4,4,1,1)
+      A.getDims v `shouldBe` (2,1,1,1)
+      A.getDims d `shouldBe` (2,2,1,1)
+    it "Should perform lu" $ do
+      let (s,v,d) = A.lu $ A.matrix @Double (2,2) [3,1,4,2]
+      A.getDims s `shouldBe` (2,2,1,1)
+      A.getDims v `shouldBe` (2,2,1,1)
+      A.getDims d `shouldBe` (2,1,1,1)
+    it "Should perform qr" $ do
+      let (s,v,d) = A.lu $ A.matrix @Double (3,3) [12,6,4,-51,167,24,4,-68,-41]
+      A.getDims s `shouldBe` (3,3,1,1)
+      A.getDims v `shouldBe` (3,3,1,1)
+      A.getDims d `shouldBe` (3,1,1,1)
+    it "Should get determinant" $ do
+      let (x,y) = A.det $ A.matrix @Double (2,2) [3,8,4,6]
+      x `shouldBe` (-14)
+    it "Should calculate inverse" $ do
+      let x = flip A.inverse A.None $ A.matrix @Double (2,2) [4,7,2,6]
+      x `shouldBe` A.matrix @Double (2,2) [0.6,-0.2,-0.7,0.4]
+    -- it "Should calculate psuedo inverse" $ do
+    --   let x = A.pinverse (A.matrix @Double (2,2) [4,7,2,6]) 1.0 A.None
+    --   x `shouldBe` A.matrix @Double (2,2) [0.6,-0.2,-0.7,0.4]