Fix gemm API, add tests for bitNot and complex number functions.

- Remove dead `beta` parameter from `gemm`: the C binding always
  starts with a null C array, so beta*C_prev was silently a no-op.
  Beta memory is now zero-filled internally.
- Add tests for `bitNot`: complement of 0/-1 for Int32/Word32,
  and round-trip identity.
- Add tests for `cplx`, `cplx2`, `real`, `imag`: scalar/vector
  construction, extraction, and the round-trip property
  `cplx2 (real c) (imag c) == c`.
- Add non-trivial gemm test (A*B with known exact result).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dmjio

src/ArrayFire/BLAS.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE ViewPatterns        #-}
 --------------------------------------------------------------------------------
 -- |
@@ -35,8 +36,9 @@ import Control.Exception (mask_)
 import Data.Complex
 import Foreign.ForeignPtr (newForeignPtr, withForeignPtr)
 import Foreign.Marshal.Alloc (alloca)
-import Foreign.Ptr (castPtr)
-import Foreign.Storable (peek, poke)
+import Foreign.Marshal.Utils (fillBytes)
+import Foreign.Ptr (Ptr, castPtr)
+import Foreign.Storable (peek, poke, sizeOf)
 import System.IO.Unsafe (unsafePerformIO)
 
 import ArrayFire.Exception
@@ -175,18 +177,18 @@ transposeInPlace
 transposeInPlace arr (fromIntegral . fromEnum -> b) =
   arr `inPlace` (`af_transpose_inplace` b)
 
--- | General Matrix Multiply: C = alpha * op(A) * op(B) + beta * C_prev
+-- | General Matrix Multiply: C = alpha * op(A) * op(B)
 --
--- More general than 'matmul': supports scaling and accumulation.
--- When @beta = 0@, equivalent to @alpha * op(A) * op(B)@.
+-- More general than 'matmul': supports per-element scaling and optional
+-- transposition via 'MatProp'.
 --
--- >>> gemm None None 1.0 (matrix @Double (2,2) [[1,0],[0,1]]) (matrix @Double (2,2) [[3,4],[5,6]]) 0.0
+-- >>> gemm None None 1.0 (matrix @Double (2,2) [[1,0],[0,1]]) (matrix @Double (2,2) [[3,4],[5,6]])
 -- ArrayFire Array
 -- [2 2 1 1]
 --     3.0000     5.0000
 --     4.0000     6.0000
 gemm
-  :: AFType a
+  :: forall a . AFType a
   => MatProp
   -- ^ Transformation applied to A ('None', 'Trans', or 'CTrans')
   -> MatProp
@@ -197,20 +199,18 @@ gemm
   -- ^ Matrix A
   -> Array a
   -- ^ Matrix B
-  -> a
-  -- ^ Scalar beta (use 0 for pure multiply)
   -> Array a
-  -- ^ Result C = alpha * op(A) * op(B) + beta * C_prev
-gemm opA opB alpha (Array fptrA) (Array fptrB) beta =
+  -- ^ Result C = alpha * op(A) * op(B)
+gemm opA opB alpha (Array fptrA) (Array fptrB) =
   unsafePerformIO . mask_ $
     withForeignPtr fptrA $ \ptrA ->
     withForeignPtr fptrB $ \ptrB ->
     alloca $ \pOut ->
     alloca $ \pAlpha ->
-    alloca $ \pBeta -> do
+    alloca $ \(pBeta :: Ptr a) -> do
       zeroOutArray pOut
       poke pAlpha alpha
-      poke pBeta beta
+      fillBytes pBeta 0 (sizeOf alpha)
       throwAFError =<< af_gemm pOut (toMatProp opA) (toMatProp opB) (castPtr pAlpha) ptrA ptrB (castPtr pBeta)
       Array <$> (newForeignPtr af_release_array_finalizer =<< peek pOut)
 {-# NOINLINE gemm #-}

test/ArrayFire/ArithSpec.hs

@@ -4,8 +4,9 @@
 
 module ArrayFire.ArithSpec where
 
-import ArrayFire (AFType, Array, cast, clamp, getType, isInf, isZero, matrix, maxOf, minOf, mkArray, scalar, vector)
+import ArrayFire (AFType, Array, cast, clamp, cplx, cplx2, getType, imag, isInf, isZero, matrix, maxOf, minOf, mkArray, real, scalar, vector)
 import qualified ArrayFire
+import Data.Complex (Complex (..))
 import Control.Exception (throwIO)
 import Control.Monad (unless, when)
 import Foreign.C
@@ -226,3 +227,37 @@ spec =
         evalf (signum (scalar @Double (-2.5))) `shouldBeApprox` (-1)
       it "signum vector" $
         signum (vector @Int 3 [-4, 0, 7]) `shouldBe` vector @Int 3 [-1, 0, 1]
+
+    describe "cplx" $ do
+      it "lifts a real scalar to complex with zero imaginary part" $
+        cplx (scalar @Double 5.0) `shouldBe` scalar @(Complex Double) (5.0 :+ 0.0)
+      it "real . cplx == id on a vector" $ do
+        let v = vector @Double 4 [1, 2, 3, 4]
+        (real (cplx v) :: Array Double) `shouldBe` v
+      it "imag . cplx == 0 on a vector" $ do
+        let v = vector @Double 4 [1, 2, 3, 4]
+        ArrayFire.toList (imag (cplx v) :: Array Double) `shouldBe` [0, 0, 0, 0]
+
+    describe "cplx2" $ do
+      it "combines real and imaginary parts into a complex scalar" $
+        cplx2 (scalar @Double 3.0) (scalar @Double 4.0)
+          `shouldBe` scalar @(Complex Double) (3.0 :+ 4.0)
+      it "real . cplx2 r i == r" $ do
+        let r = vector @Double 3 [1, 2, 3]
+            i = vector @Double 3 [4, 5, 6]
+        (real (cplx2 r i) :: Array Double) `shouldBe` r
+      it "imag . cplx2 r i == i" $ do
+        let r = vector @Double 3 [1, 2, 3]
+            i = vector @Double 3 [4, 5, 6]
+        (imag (cplx2 r i) :: Array Double) `shouldBe` i
+
+    describe "real / imag" $ do
+      it "real extracts the real part of a complex scalar" $
+        (real (scalar @(Complex Double) (7.0 :+ 3.0)) :: Array Double)
+          `shouldBe` scalar @Double 7.0
+      it "imag extracts the imaginary part of a complex scalar" $
+        (imag (scalar @(Complex Double) (7.0 :+ 3.0)) :: Array Double)
+          `shouldBe` scalar @Double 3.0
+      it "real and imag round-trip via cplx2" $ do
+        let c = vector @(Complex Double) 3 [1:+2, 3:+4, 5:+6]
+        cplx2 (real c :: Array Double) (imag c :: Array Double) `shouldBe` c

test/ArrayFire/BLASSpec.hs

@@ -28,17 +28,25 @@ spec =
       let m = matrix @Double (2,2) [[1,1],[2,2]]
       transposeInPlace m False
       m `shouldBe` matrix @Double (2,2) [[1,2],[1,2]]
-    it "Should perform gemm: C = 1*A*B + 0*C (identity scaling)" $ do
+    it "Should perform gemm: alpha=1, A*I = A" $ do
       let a = matrix @Double (2,2) [[1,2],[3,4]]
           b = matrix @Double (2,2) [[1,0],[0,1]]
-      gemm None None 1.0 a b 0.0 `shouldBe` a
-    it "Should perform gemm: C = alpha*A*B with alpha=2" $ do
-      -- b is column-major: col0=[3,4], col1=[5,6] → matrix [[3,5],[4,6]]
+      gemm None None 1.0 a b `shouldBe` a
+    it "Should perform gemm: alpha=2 scales the result" $ do
+      -- b col-major: col0=[3,4], col1=[5,6]
       -- 2 * I * b = 2b → col0=[6,8], col1=[10,12]
       let a = matrix @Double (2,2) [[1,0],[0,1]]
           b = matrix @Double (2,2) [[3,4],[5,6]]
-      gemm None None 2.0 a b 0.0 `shouldBe` matrix @Double (2,2) [[6,8],[10,12]]
-    it "Should perform gemm with transposed A: C = A^T * B" $ do
+      gemm None None 2.0 a b `shouldBe` matrix @Double (2,2) [[6,8],[10,12]]
+    it "Should perform gemm with transposed A" $ do
       let a = matrix @Double (2,2) [[1,3],[2,4]]
           b = matrix @Double (2,2) [[1,0],[0,1]]
-      gemm Trans None 1.0 a b 0.0 `shouldBe` matrix @Double (2,2) [[1,2],[3,4]]
+      gemm Trans None 1.0 a b `shouldBe` matrix @Double (2,2) [[1,2],[3,4]]
+    it "Should perform gemm: non-trivial A*B" $ do
+      -- matrix (2,2) [[c0r0,c0r1],[c1r0,c1r1]] is column-major.
+      -- A = [[1,3],[2,4]], B = [[5,7],[6,8]] (rows displayed by ArrayFire)
+      -- A*B col0 = [1*5+3*6, 2*5+4*6] = [23,34]
+      -- A*B col1 = [1*7+3*8, 2*7+4*8] = [31,46]
+      let a = matrix @Double (2,2) [[1,2],[3,4]]
+          b = matrix @Double (2,2) [[5,6],[7,8]]
+      gemm None None 1.0 a b `shouldBe` matrix @Double (2,2) [[23,34],[31,46]]

test/ArrayFire/DataSpec.hs

@@ -148,3 +148,14 @@ spec =
       join 1 (constant @Int [1, 2] 1) (constant @Int [1, 2] 2) `shouldBe` mkArray @Int [1, 4] [1, 1, 2, 2]
       joinMany 0 [constant @Int [1, 3] 1, constant @Int [1, 3] 2] `shouldBe` mkArray @Int [2, 3] [1, 2, 1, 2, 1, 2]
       joinMany 1 [constant @Int [1, 2] 1, constant @Int [1, 1] 2, constant @Int [1, 3] 3] `shouldBe` mkArray @Int [1, 6] [1, 1, 2, 3, 3, 3]
+
+    describe "bitNot" $ do
+      it "complements 0 to all-ones (-1 in two's complement) for Int32" $ do
+        bitNot (scalar @Int32 0) `shouldBe` scalar @Int32 (-1)
+      it "complements -1 to 0 for Int32" $ do
+        bitNot (scalar @Int32 (-1)) `shouldBe` scalar @Int32 0
+      it "complements 0 to maxBound for Word32" $ do
+        bitNot (scalar @Word32 0) `shouldBe` scalar @Word32 maxBound
+      it "bitNot . bitNot == id" $ do
+        let v = vector @Int32 4 [0, 1, -1, 42]
+        bitNot (bitNot v) `shouldBe` v