diff --git a/accelerate-fftw.cabal b/accelerate-fftw.cabal --- a/accelerate-fftw.cabal +++ b/accelerate-fftw.cabal @@ -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 @@ -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 diff --git a/src/Data/Array/Accelerate/CArray/Conversion.hs b/src/Data/Array/Accelerate/CArray/Conversion.hs --- a/src/Data/Array/Accelerate/CArray/Conversion.hs +++ b/src/Data/Array/Accelerate/CArray/Conversion.hs @@ -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 diff --git a/src/Data/Array/Accelerate/FFTW/Manifest.hs b/src/Data/Array/Accelerate/FFTW/Manifest.hs --- a/src/Data/Array/Accelerate/FFTW/Manifest.hs +++ b/src/Data/Array/Accelerate/FFTW/Manifest.hs @@ -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 diff --git a/src/Data/Array/Accelerate/FFTW/Private.hs b/src/Data/Array/Accelerate/FFTW/Private.hs new file mode 100644 --- /dev/null +++ b/src/Data/Array/Accelerate/FFTW/Private.hs @@ -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)) diff --git a/test/Test/Data/Array/Accelerate/FFTW/Manifest.hs b/test/Test/Data/Array/Accelerate/FFTW/Manifest.hs --- a/test/Test/Data/Array/Accelerate/FFTW/Manifest.hs +++ b/test/Test/Data/Array/Accelerate/FFTW/Manifest.hs @@ -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]"]]