accelerate-fftw 1.0.3 → 1.1

raw patch · 5 files changed

+184/−122 lines, 5 filesdep +comfort-arraydep +comfort-fftwdep +netlib-ffidep −carraydep −fftPVP ok

version bump matches the API change (PVP)

Dependencies added: comfort-array, comfort-fftw, netlib-ffi

Dependencies removed: carray, fft

API changes (from Hackage documentation)

Files

• accelerate-fftw.cabal +7/−5
• src/Data/Array/Accelerate/CArray/Conversion.hs +53/−44
• src/Data/Array/Accelerate/FFTW/Manifest.hs +29/−45
• src/Data/Array/Accelerate/FFTW/Private.hs +63/−0
• test/Test/Data/Array/Accelerate/FFTW/Manifest.hs +32/−28

@@ -1,6 +1,6 @@ Cabal-Version:    2.2 Name:             accelerate-fftw-Version:          1.0.3+Version:          1.1 License:          BSD-3-Clause License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>@@ -11,13 +11,13 @@ Description:   An interface to the Fastest Fourier Transform in the West (FFTW)   for the @accelerate@ framework.-Tested-With:      GHC==9.2.8+Tested-With:      GHC==9.2.8, GHC==9.12.4 Build-Type:       Simple Extra-Source-Files:   Justfile  Source-Repository this-  Tag:         1.0.3+  Tag:         1.1   Type:        darcs   Location:    https://hub.darcs.net/thielema/accelerate-fftw/ @@ -27,8 +27,9 @@  Library   Build-Depends:-    fft >=0.1.7 && <0.2,-    carray >=0.1.5 && <0.2,+    comfort-fftw >=0.0 && <0.1,+    comfort-array >=0.5.5 && <0.6,+    netlib-ffi >=0.1 && <0.2,     storable-complex >=0.2.1 && <0.3,     accelerate-io >=1.3 && <1.5,     accelerate >=1.3 && <1.5,@@ -40,6 +41,7 @@   Exposed-Modules:     Data.Array.Accelerate.FFTW.Manifest   Other-Modules:+    Data.Array.Accelerate.FFTW.Private     Data.Array.Accelerate.CArray.Conversion  Test-Suite accelerate-fftw-test

@@ -1,25 +1,28 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE ConstraintKinds #-}+-- ToDo: extract to a separate package module Data.Array.Accelerate.CArray.Conversion where  import qualified Data.Array.Accelerate.IO.Foreign.ForeignPtr as AIO+import qualified Data.Array.Accelerate.Sugar.Shape as Shape import qualified Data.Array.Accelerate as A import Data.Array.Accelerate.Sugar.Elt (EltR) import Data.Array.Accelerate (Array, DIM1, DIM2, Z(Z), (:.)((:.))) -import qualified Data.Array.CArray as CArray-import Data.Array.CArray (CArray, unsafeForeignPtrToCArray, rangeSize)-import Data.Ix (Ix)+import qualified Data.Array.Comfort.Storable.Private as CArray+import qualified Data.Array.Comfort.Shape as CShape import Foreign.Storable.Complex ()  import Data.Array.Accelerate.Data.Complex (Complex) -import System.IO.Unsafe (unsafePerformIO) import Foreign.ForeignPtr (ForeignPtr, castForeignPtr) import Foreign.Storable (Storable)  +type CArray = CArray.Array+type ShapeInt = CShape.ZeroBased Int+ type RealElement a =       (A.Elt a, Storable a, AIO.ForeignPtrs (EltR a) ~ ForeignPtr a) @@ -27,101 +30,100 @@       (Storable a, RealFloat a, Complex a ~ ac, A.Elt ac,        AIO.ForeignPtrs (EltR ac) ~ ForeignPtr a) + accFromCArrayReal1D ::    (RealElement a) =>-   CArray Int a -> Array DIM1 a+   CArray ShapeInt a -> Array DIM1 a accFromCArrayReal1D arr =-   let (len, fptr) = CArray.toForeignPtr arr-   in  AIO.fromForeignPtrs (Z :. len) fptr+   AIO.fromForeignPtrs+      (accDimsFromArrayBounds1D $ CArray.shape arr)+      (CArray.buffer arr)  accFromCArrayReal2D ::    (RealElement a) =>-   CArray (Int, Int) a -> Array DIM2 a+   CArray (ShapeInt, ShapeInt) a -> Array DIM2 a accFromCArrayReal2D arr =    AIO.fromForeignPtrs-      (accDimsFromArrayBounds2D $ CArray.bounds arr)-      (snd $ CArray.toForeignPtr arr)+      (accDimsFromArrayBounds2D $ CArray.shape arr)+      (CArray.buffer arr)   accFromCArrayComplex1D ::    (ComplexElement a ac) =>-   CArray Int (Complex a) -> Array DIM1 (Complex a)+   CArray ShapeInt (Complex a) -> Array DIM1 (Complex a) accFromCArrayComplex1D arr =-   accFromCArrayComplex (accDimsFromArrayBounds1D $ CArray.bounds arr) arr+   accFromCArrayComplex (accDimsFromArrayBounds1D $ CArray.shape arr) arr  accFromCArrayComplex2D ::    (ComplexElement a ac) =>-   CArray (Int, Int) (Complex a) -> Array DIM2 (Complex a)+   CArray (ShapeInt, ShapeInt) (Complex a) -> Array DIM2 (Complex a) accFromCArrayComplex2D arr =-   accFromCArrayComplex (accDimsFromArrayBounds2D $ CArray.bounds arr) arr+   accFromCArrayComplex (accDimsFromArrayBounds2D $ CArray.shape arr) arr  accFromCArrayComplex ::-   (Ix i, A.Shape sh, ComplexElement a ac) =>-   sh -> CArray i ac -> Array sh ac+   (A.Shape sh, ComplexElement a ac) =>+   sh -> CArray csh ac -> Array sh ac accFromCArrayComplex sh arr =-   AIO.fromForeignPtrs sh $-   castForeignPtrFromComplex $ snd $ CArray.toForeignPtr arr+   AIO.fromForeignPtrs sh $ castForeignPtrFromComplex $ CArray.buffer arr  castForeignPtrFromComplex :: ForeignPtr (Complex a) -> ForeignPtr a castForeignPtrFromComplex = castForeignPtr   -accDimsFromArrayBounds1D :: (CArray.Ix i) => (i, i) -> DIM1-accDimsFromArrayBounds1D bnds = Z :. rangeSize bnds+accDimsFromArrayBounds1D :: (CShape.C sh) => sh -> DIM1+accDimsFromArrayBounds1D sh = Z :. CShape.size sh  accDimsFromArrayBounds2D ::-   (CArray.Ix i, CArray.Ix j) => ((i, j), (i, j)) -> DIM2-accDimsFromArrayBounds2D ((li,lj), (ri,rj)) =-   Z :. rangeSize (li,ri) :. rangeSize (lj,rj)+   (CShape.C sh0, CShape.C sh1) => (sh0, sh1) -> DIM2+accDimsFromArrayBounds2D (sh0, sh1) =+   Z :. CShape.size sh0 :. CShape.size sh1   cArrayFromAccReal1D ::    (RealElement a) =>-   Array DIM1 a -> CArray Int a+   Array DIM1 a -> CArray ShapeInt a cArrayFromAccReal1D arr =-   let (Z:.len) = A.arrayShape arr-   in  unsafePerformIO $-       unsafeForeignPtrToCArray (AIO.toForeignPtrs arr) (0,len-1)+   CArray.Array+      (arrayBounds1DFromAccDims $ A.arrayShape arr)+      (AIO.toForeignPtrs arr)  cArrayFromAccReal2D ::    (RealElement a) =>-   Array DIM2 a -> CArray (Int, Int) a+   Array DIM2 a -> CArray (ShapeInt, ShapeInt) a cArrayFromAccReal2D arr =-   unsafePerformIO $-   unsafeForeignPtrToCArray (AIO.toForeignPtrs arr)+   CArray.Array       (arrayBounds2DFromAccDims $ A.arrayShape arr)+      (AIO.toForeignPtrs arr)  cArrayFromAccComplex1D ::    (ComplexElement a ac) =>-   Array DIM1 ac -> CArray Int ac+   Array DIM1 ac -> CArray ShapeInt ac cArrayFromAccComplex1D arr =    cArrayFromAccComplex       (arrayBounds1DFromAccDims $ A.arrayShape arr) arr  cArrayFromAccComplex2D ::    (ComplexElement a ac) =>-   Array DIM2 ac -> CArray (Int,Int) ac+   Array DIM2 ac -> CArray (ShapeInt,ShapeInt) ac cArrayFromAccComplex2D arr =    cArrayFromAccComplex       (arrayBounds2DFromAccDims $ A.arrayShape arr) arr  cArrayFromAccComplex ::-   (Ix i, A.Shape sh, ComplexElement a ac) =>-   (i,i) -> Array sh ac -> CArray i ac+   (CShape.C csh, A.Shape sh, ComplexElement a ac) =>+   csh -> Array sh ac -> CArray csh ac cArrayFromAccComplex bnds arr =-   unsafePerformIO $-   unsafeForeignPtrToCArray-      (castForeignPtrToComplex $ AIO.toForeignPtrs arr) bnds+   CArray.Array bnds (castForeignPtrToComplex $ AIO.toForeignPtrs arr)  castForeignPtrToComplex :: ForeignPtr a -> ForeignPtr (Complex a) castForeignPtrToComplex = castForeignPtr   withCArrayComplex ::-   (Ix i, A.Shape sh, ComplexElement a ac) =>-   (sh -> (i,i)) ->-   (CArray i ac -> CArray i ac) ->+   (CShape.C csh, A.Shape sh, ComplexElement a ac) =>+   (sh -> csh) ->+   (CArray csh ac -> CArray csh ac) ->    Array sh ac -> Array sh ac withCArrayComplex bndsFromSh f arr =    let sh = A.arrayShape arr@@ -129,8 +131,15 @@        cArrayFromAccComplex (bndsFromSh sh) arr  -arrayBounds1DFromAccDims :: DIM1 -> (Int, Int)-arrayBounds1DFromAccDims (Z :. i) = (0, i-1)+arrayBounds1DFromAccDims :: DIM1 -> ShapeInt+arrayBounds1DFromAccDims (Z :. i) = CShape.ZeroBased i -arrayBounds2DFromAccDims :: DIM2 -> ((Int, Int), (Int, Int))-arrayBounds2DFromAccDims (Z :. i :. j) = ((0,0), (i-1,j-1))+arrayBounds2DFromAccDims :: DIM2 -> (ShapeInt, ShapeInt)+arrayBounds2DFromAccDims (Z :. i :. j) =+   (CShape.ZeroBased i, CShape.ZeroBased j)+++newtype Cube sh = Cube sh++instance (A.Shape sh) => CShape.C (Cube sh) where+   size (Cube sh) = Shape.size sh

@@ -1,28 +1,22 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE ConstraintKinds #-} module Data.Array.Accelerate.FFTW.Manifest (    Transform,-   Element,    dft,    idft,    dft2d,    idft2d,    ) where -import qualified Math.FFT as FFT-import Math.FFT.Base (FFTWReal)--import qualified Data.Array.Accelerate.CArray.Conversion as Conv--import qualified Data.Array.Accelerate.Sugar.Shape as Shape+import qualified Data.Array.Accelerate.FFTW.Private as Batch import qualified Data.Array.Accelerate as A-import Data.Array.Accelerate (Array, (:.)((:.)))+import Data.Array.Accelerate.FFTW.Private (Transform)+import Data.Array.Accelerate ((:.)) +import Data.Array.Accelerate.Data.Complex (Complex) import Foreign.Storable.Complex () -import Data.Array.Accelerate.Data.Complex (Complex)+import qualified Numeric.Netlib.Class as Class   {- $setup@@ -36,80 +30,70 @@ >>> roundComplex :: A.Exp (Complex Float) -> A.Exp (Complex Int) >>> roundComplex = >>>    Exp.modify (expr:+expr) $ \(r:+i) -> A.round r :+ (A.round i :: A.Exp Int)+>>>+>>> roundComplexArray ::+>>>    (A.Shape sh) => A.Array sh (Complex Float) -> A.Array sh (Complex Int)+>>> roundComplexArray = AI.run1 (A.map roundComplex) -}  -type Bounds i = (i,i)--type Transform sh a = Array sh a -> Array sh a--type Element a = (FFTWReal a, Conv.ComplexElement a (Complex a))- {- |->>> AI.run1 (A.map roundComplex) $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+>>> roundComplexArray $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000]) Matrix (Z :. 3 :. 3)   [ 1000 :+ 0,        1000 :+ 0,        1000 :+ 0,     1000 :+ 0, (-500) :+ (-866),    (-500) :+ 866,     1000 :+ 0,    (-500) :+ 866, (-500) :+ (-866)] -} dft ::-   (A.Shape sh, Element a) =>+   (A.Shape sh, Class.Real a) =>    Transform (sh:.Int) (Complex a)-dft = Conv.withCArrayComplex bnds1 $ FFT.dftN [1]+dft = Batch.runComplexTransform $ Class.switchReal Batch.dft Batch.dft  {- |->>> AI.run1 (A.map roundComplex) $ idft $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+>>> roundComplexArray $ idft $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000]) Matrix (Z :. 3 :. 3)-  [ 1000 :+ 0,    0 :+ 0,    0 :+ 0,-       0 :+ 0, 1000 :+ 0,    0 :+ 0,-       0 :+ 0,    0 :+ 0, 1000 :+ 0]+  [ 3000 :+ 0,    0 :+ 0,    0 :+ 0,+       0 :+ 0, 3000 :+ 0,    0 :+ 0,+       0 :+ 0,    0 :+ 0, 3000 :+ 0] -} idft ::-   (A.Shape sh, Element a) =>+   (A.Shape sh, Class.Real a) =>    Transform (sh:.Int) (Complex a)-idft = Conv.withCArrayComplex bnds1 $ FFT.idftN [1]--bnds1 :: (A.Shape sh) => sh:.Int -> Bounds (Int,Int)-bnds1 (sh:.n) = ((0,0), (Shape.size sh-1, n-1))+idft = Batch.runComplexTransform $ Class.switchReal Batch.idft Batch.idft   {- |->>> AI.run1 (A.map roundComplex) $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,0,0, 0,0,0])+>>> roundComplexArray $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,0,0, 0,0,0]) Matrix (Z :. 3 :. 3)   [ 1000 :+ 0, 1000 :+ 0, 1000 :+ 0,     1000 :+ 0, 1000 :+ 0, 1000 :+ 0,     1000 :+ 0, 1000 :+ 0, 1000 :+ 0] ->>> AI.run1 (A.map roundComplex) $ dft2d (A.fromList (A.Z:.3:.3) [0,1000,0, 0,0,0, 0,0,0])+>>> roundComplexArray $ dft2d (A.fromList (A.Z:.3:.3) [0,1000,0, 0,0,0, 0,0,0]) Matrix (Z :. 3 :. 3)   [ 1000 :+ 0, (-500) :+ (-866), (-500) :+ 866,     1000 :+ 0, (-500) :+ (-866), (-500) :+ 866,     1000 :+ 0, (-500) :+ (-866), (-500) :+ 866] ->>> AI.run1 (A.map roundComplex) $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+>>> roundComplexArray $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000]) Matrix (Z :. 3 :. 3)   [ 3000 :+ 0,    0 :+ 0,    0 :+ 0,        0 :+ 0,    0 :+ 0, 3000 :+ 0,        0 :+ 0, 3000 :+ 0,    0 :+ 0] -} dft2d ::-   (A.Shape sh, Element a) =>+   (A.Shape sh, Class.Real a) =>    Transform (sh:.Int:.Int) (Complex a)-dft2d =-   Conv.withCArrayComplex bnds2 $ FFT.dftN [1,2]+dft2d = Batch.runComplexTransform $ Class.switchReal Batch.dft2d Batch.dft2d  {- |->>> AI.run1 (A.map roundComplex) $ idft2d $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+>>> roundComplexArray $ idft2d $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000]) Matrix (Z :. 3 :. 3)-  [ 1000 :+ 0,    0 :+ 0,    0 :+ 0,-       0 :+ 0, 1000 :+ 0,    0 :+ 0,-       0 :+ 0,    0 :+ 0, 1000 :+ 0]+  [ 9000 :+ 0,    0 :+ 0,    0 :+ 0,+       0 :+ 0, 9000 :+ 0,    0 :+ 0,+       0 :+ 0,    0 :+ 0, 9000 :+ 0] -} idft2d ::-   (A.Shape sh, Element a) =>+   (A.Shape sh, Class.Real a) =>    Transform (sh:.Int:.Int) (Complex a)-idft2d =-   Conv.withCArrayComplex bnds2 $ FFT.idftN [1,2]--bnds2 :: (A.Shape sh) => sh:.Int:.Int -> Bounds (Int,Int,Int)-bnds2 (sh:.n:.m) = ((0,0,0), (Shape.size sh-1, n-1, m-1))+idft2d = Batch.runComplexTransform $ Class.switchReal Batch.idft2d Batch.idft2d

@@ -0,0 +1,63 @@+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE ConstraintKinds #-}+module Data.Array.Accelerate.FFTW.Private where++import qualified Numeric.FFTW.Batch as Batch+import qualified Numeric.FFTW.Shape as Spectrum+import qualified Numeric.Netlib.Class as Class++import qualified Data.Array.Accelerate.CArray.Conversion as Conv+import qualified Data.Array.Accelerate as A+import Data.Array.Accelerate (Array, (:.)((:.)))++import qualified Data.Array.Comfort.Shape as CShape++import Foreign.Storable.Complex ()++import Data.Array.Accelerate.Data.Complex (Complex)+++type ShapeCyclic = CShape.Cyclic Int++type Transform sh a = Array sh a -> Array sh a++newtype ComplexTransform sh a =+   ComplexTransform {runComplexTransform :: Transform sh (Complex a)}++type Element a ac = (Class.Real a, Conv.ComplexElement a ac)++complexTransform ::+   (A.Shape sh, CShape.C loop, Spectrum.MultiCyclic csh, Element a ac) =>+   (sh -> (loop, csh)) -> Batch.Sign -> ComplexTransform sh a+complexTransform bnds sign =+   ComplexTransform $ Conv.withCArrayComplex bnds $ Batch.fourier sign+++dft ::+   (A.Shape sh, Element a ac) =>+   ComplexTransform (sh:.Int) a+dft = complexTransform bnds1 Batch.Forward++idft ::+   (A.Shape sh, Element a ac) =>+   ComplexTransform (sh:.Int) a+idft = complexTransform bnds1 Batch.Backward++bnds1 :: (A.Shape sh) => sh:.Int -> (Conv.Cube sh, ShapeCyclic)+bnds1 (sh:.n) = (Conv.Cube sh, CShape.Cyclic n)+++dft2d ::+   (A.Shape sh, Element a ac) =>+   ComplexTransform (sh:.Int:.Int) a+dft2d = complexTransform bnds2 Batch.Forward++idft2d ::+   (A.Shape sh, Element a ac) =>+   ComplexTransform (sh:.Int:.Int) a+idft2d = complexTransform bnds2 Batch.Backward++bnds2 ::+   (A.Shape sh) => sh:.Int:.Int -> (Conv.Cube sh, (ShapeCyclic,ShapeCyclic))+bnds2 (sh:.n:.m) = (Conv.Cube sh, (CShape.Cyclic n, CShape.Cyclic m))

@@ -1,5 +1,5 @@ -- Do not edit! Automatically created with doctest-extract from src/Data/Array/Accelerate/FFTW/Manifest.hs-{-# LINE 28 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+{-# LINE 22 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}  module Test.Data.Array.Accelerate.FFTW.Manifest where @@ -7,7 +7,7 @@ import Test.DocTest.Base import qualified Test.DocTest.Driver as DocTest -{-# LINE 29 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+{-# LINE 23 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-} import     qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp import     qualified Data.Array.Accelerate.Interpreter as AI import     qualified Data.Array.Accelerate as A@@ -19,47 +19,51 @@ roundComplex     =        Exp.modify (expr:+expr) $ \(r:+i) -> A.round r :+ (A.round i :: A.Exp Int) +roundComplexArray     ::+       (A.Shape sh) => A.Array sh (Complex Float) -> A.Array sh (Complex Int)+roundComplexArray     = AI.run1 (A.map roundComplex)+ test :: DocTest.T () test = do- DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:49: "-{-# LINE 49 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+ DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:41: "+{-# LINE 41 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}  DocTest.example(-{-# LINE 49 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}-    AI.run1 (A.map roundComplex) $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+{-# LINE 41 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+    roundComplexArray $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])   )   [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 1000 :+ 0,        1000 :+ 0,        1000 :+ 0,"],ExpectedLine [LineChunk "    1000 :+ 0, (-500) :+ (-866),    (-500) :+ 866,"],ExpectedLine [LineChunk "    1000 :+ 0,    (-500) :+ 866, (-500) :+ (-866)]"]]- DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:61: "-{-# LINE 61 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+ DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:53: "+{-# LINE 53 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}  DocTest.example(-{-# LINE 61 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}-    AI.run1 (A.map roundComplex) $ idft $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+{-# LINE 53 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+    roundComplexArray $ idft $ dft (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])   )-  [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 1000 :+ 0,    0 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0, 1000 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0,    0 :+ 0, 1000 :+ 0]"]]- DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:77: "-{-# LINE 77 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+  [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 3000 :+ 0,    0 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0, 3000 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0,    0 :+ 0, 3000 :+ 0]"]]+ DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:66: "+{-# LINE 66 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}  DocTest.example(-{-# LINE 77 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}-    AI.run1 (A.map roundComplex) $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,0,0, 0,0,0])+{-# LINE 66 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+    roundComplexArray $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,0,0, 0,0,0])   )   [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 1000 :+ 0, 1000 :+ 0, 1000 :+ 0,"],ExpectedLine [LineChunk "    1000 :+ 0, 1000 :+ 0, 1000 :+ 0,"],ExpectedLine [LineChunk "    1000 :+ 0, 1000 :+ 0, 1000 :+ 0]"]]- DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:83: "-{-# LINE 83 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+ DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:72: "+{-# LINE 72 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}  DocTest.example(-{-# LINE 83 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}-    AI.run1 (A.map roundComplex) $ dft2d (A.fromList (A.Z:.3:.3) [0,1000,0, 0,0,0, 0,0,0])+{-# LINE 72 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+    roundComplexArray $ dft2d (A.fromList (A.Z:.3:.3) [0,1000,0, 0,0,0, 0,0,0])   )   [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 1000 :+ 0, (-500) :+ (-866), (-500) :+ 866,"],ExpectedLine [LineChunk "    1000 :+ 0, (-500) :+ (-866), (-500) :+ 866,"],ExpectedLine [LineChunk "    1000 :+ 0, (-500) :+ (-866), (-500) :+ 866]"]]- DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:89: "-{-# LINE 89 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+ DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:78: "+{-# LINE 78 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}  DocTest.example(-{-# LINE 89 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}-    AI.run1 (A.map roundComplex) $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+{-# LINE 78 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+    roundComplexArray $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])   )   [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 3000 :+ 0,    0 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0,    0 :+ 0, 3000 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0, 3000 :+ 0,    0 :+ 0]"]]- DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:102: "-{-# LINE 102 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+ DocTest.printPrefix "Data.Array.Accelerate.FFTW.Manifest:90: "+{-# LINE 90 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}  DocTest.example(-{-# LINE 102 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}-    AI.run1 (A.map roundComplex) $ idft2d $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])+{-# LINE 90 "src/Data/Array/Accelerate/FFTW/Manifest.hs" #-}+    roundComplexArray $ idft2d $ dft2d (A.fromList (A.Z:.3:.3) [1000,0,0, 0,1000,0, 0,0,1000])   )-  [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 1000 :+ 0,    0 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0, 1000 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0,    0 :+ 0, 1000 :+ 0]"]]+  [ExpectedLine [LineChunk "Matrix (Z :. 3 :. 3)"],ExpectedLine [LineChunk "  [ 9000 :+ 0,    0 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0, 9000 :+ 0,    0 :+ 0,"],ExpectedLine [LineChunk "       0 :+ 0,    0 :+ 0, 9000 :+ 0]"]]