module Numeric.FFTW.FFI.Generic (
FFT.PlanDFT1d, planDFT1d,
FFT.PlanDFT2d, planDFT2d,
FFT.PlanDFT3d, planDFT3d,
FFT.PlanDFT, planDFT,
FFT.PlanDFTr2c1d, planDFTr2c1d,
FFT.PlanDFTr2c2d, planDFTr2c2d,
FFT.PlanDFTr2c3d, planDFTr2c3d,
FFT.PlanDFTr2c, planDFTr2c,
FFT.PlanDFTc2r1d, planDFTc2r1d,
FFT.PlanDFTc2r2d, planDFTc2r2d,
FFT.PlanDFTc2r3d, planDFTc2r3d,
FFT.PlanDFTc2r, planDFTc2r,
FFT.PlanR2r1d, planR2r1d,
FFT.PlanR2r2d, planR2r2d,
FFT.PlanR2r3d, planR2r3d,
FFT.PlanR2r, planR2r,
FFT.PlanManyDFT, planManyDFT,
FFT.PlanManyDFTr2c, planManyDFTr2c,
FFT.PlanManyDFTc2r, planManyDFTc2r,
FFT.PlanManyR2r, planManyR2r,
FFT.PlanGuruDFT, planGuruDFT,
FFT.PlanGuruDFTr2c, planGuruDFTr2c,
FFT.PlanGuruDFTc2r, planGuruDFTc2r,
FFT.PlanGuruR2r, planGuruR2r,
FFT.PlanGuruSplitDFT, planGuruSplitDFT,
FFT.PlanGuruSplitDFTr2c, planGuruSplitDFTr2c,
FFT.PlanGuruSplitDFTc2r, planGuruSplitDFTc2r,
FFT.DestroyPlan, destroyPlan,
FFT.Execute, execute,
FFT.ExecuteDFT, executeDFT,
FFT.ExecuteDFTr2c, executeDFTr2c,
FFT.ExecuteDFTc2r, executeDFTc2r,
FFT.ExecuteR2r, executeR2r,
FFT.ExecuteSplitDFT, executeSplitDFT,
FFT.ExecuteSplitDFTr2c, executeSplitDFTr2c,
FFT.ExecuteSplitDFTc2r, executeSplitDFTc2r,
FFT.Malloc, malloc,
FFT.Free, free,
FFT.AllocReal, allocReal,
FFT.AllocComplex, allocComplex,
FFT.FreeComplex, freeComplex,
) where
import qualified Numeric.FFTW.FFI.Double as FFTD
import qualified Numeric.FFTW.FFI.Float as FFTF
import qualified Numeric.FFTW.FFI.Function as FFT
import qualified Numeric.Netlib.Class as Class
newtype PlanDFT1d a =
PlanDFT1d {runPlanDFT1d :: FFT.PlanDFT1d a}
planDFT1d :: (Class.Real a) => FFT.PlanDFT1d a
planDFT1d =
runPlanDFT1d $
Class.switchReal
(PlanDFT1d FFTF.planDFT1d)
(PlanDFT1d FFTD.planDFT1d)
newtype PlanDFT2d a =
PlanDFT2d {runPlanDFT2d :: FFT.PlanDFT2d a}
planDFT2d :: (Class.Real a) => FFT.PlanDFT2d a
planDFT2d =
runPlanDFT2d $
Class.switchReal
(PlanDFT2d FFTF.planDFT2d)
(PlanDFT2d FFTD.planDFT2d)
newtype PlanDFT3d a =
PlanDFT3d {runPlanDFT3d :: FFT.PlanDFT3d a}
planDFT3d :: (Class.Real a) => FFT.PlanDFT3d a
planDFT3d =
runPlanDFT3d $
Class.switchReal
(PlanDFT3d FFTF.planDFT3d)
(PlanDFT3d FFTD.planDFT3d)
newtype PlanDFT a =
PlanDFT {runPlanDFT :: FFT.PlanDFT a}
planDFT :: (Class.Real a) => FFT.PlanDFT a
planDFT =
runPlanDFT $
Class.switchReal
(PlanDFT FFTF.planDFT)
(PlanDFT FFTD.planDFT)
newtype PlanDFTr2c1d a =
PlanDFTr2c1d {runPlanDFTr2c1d :: FFT.PlanDFTr2c1d a}
planDFTr2c1d :: (Class.Real a) => FFT.PlanDFTr2c1d a
planDFTr2c1d =
runPlanDFTr2c1d $
Class.switchReal
(PlanDFTr2c1d FFTF.planDFTr2c1d)
(PlanDFTr2c1d FFTD.planDFTr2c1d)
newtype PlanDFTr2c2d a =
PlanDFTr2c2d {runPlanDFTr2c2d :: FFT.PlanDFTr2c2d a}
planDFTr2c2d :: (Class.Real a) => FFT.PlanDFTr2c2d a
planDFTr2c2d =
runPlanDFTr2c2d $
Class.switchReal
(PlanDFTr2c2d FFTF.planDFTr2c2d)
(PlanDFTr2c2d FFTD.planDFTr2c2d)
newtype PlanDFTr2c3d a =
PlanDFTr2c3d {runPlanDFTr2c3d :: FFT.PlanDFTr2c3d a}
planDFTr2c3d :: (Class.Real a) => FFT.PlanDFTr2c3d a
planDFTr2c3d =
runPlanDFTr2c3d $
Class.switchReal
(PlanDFTr2c3d FFTF.planDFTr2c3d)
(PlanDFTr2c3d FFTD.planDFTr2c3d)
newtype PlanDFTr2c a =
PlanDFTr2c {runPlanDFTr2c :: FFT.PlanDFTr2c a}
planDFTr2c :: (Class.Real a) => FFT.PlanDFTr2c a
planDFTr2c =
runPlanDFTr2c $
Class.switchReal
(PlanDFTr2c FFTF.planDFTr2c)
(PlanDFTr2c FFTD.planDFTr2c)
newtype PlanDFTc2r1d a =
PlanDFTc2r1d {runPlanDFTc2r1d :: FFT.PlanDFTc2r1d a}
planDFTc2r1d :: (Class.Real a) => FFT.PlanDFTc2r1d a
planDFTc2r1d =
runPlanDFTc2r1d $
Class.switchReal
(PlanDFTc2r1d FFTF.planDFTc2r1d)
(PlanDFTc2r1d FFTD.planDFTc2r1d)
newtype PlanDFTc2r2d a =
PlanDFTc2r2d {runPlanDFTc2r2d :: FFT.PlanDFTc2r2d a}
planDFTc2r2d :: (Class.Real a) => FFT.PlanDFTc2r2d a
planDFTc2r2d =
runPlanDFTc2r2d $
Class.switchReal
(PlanDFTc2r2d FFTF.planDFTc2r2d)
(PlanDFTc2r2d FFTD.planDFTc2r2d)
newtype PlanDFTc2r3d a =
PlanDFTc2r3d {runPlanDFTc2r3d :: FFT.PlanDFTc2r3d a}
planDFTc2r3d :: (Class.Real a) => FFT.PlanDFTc2r3d a
planDFTc2r3d =
runPlanDFTc2r3d $
Class.switchReal
(PlanDFTc2r3d FFTF.planDFTc2r3d)
(PlanDFTc2r3d FFTD.planDFTc2r3d)
newtype PlanDFTc2r a =
PlanDFTc2r {runPlanDFTc2r :: FFT.PlanDFTc2r a}
planDFTc2r :: (Class.Real a) => FFT.PlanDFTc2r a
planDFTc2r =
runPlanDFTc2r $
Class.switchReal
(PlanDFTc2r FFTF.planDFTc2r)
(PlanDFTc2r FFTD.planDFTc2r)
newtype PlanR2r1d a =
PlanR2r1d {runPlanR2r1d :: FFT.PlanR2r1d a}
planR2r1d :: (Class.Real a) => FFT.PlanR2r1d a
planR2r1d =
runPlanR2r1d $
Class.switchReal
(PlanR2r1d FFTF.planR2r1d)
(PlanR2r1d FFTD.planR2r1d)
newtype PlanR2r2d a =
PlanR2r2d {runPlanR2r2d :: FFT.PlanR2r2d a}
planR2r2d :: (Class.Real a) => FFT.PlanR2r2d a
planR2r2d =
runPlanR2r2d $
Class.switchReal
(PlanR2r2d FFTF.planR2r2d)
(PlanR2r2d FFTD.planR2r2d)
newtype PlanR2r3d a =
PlanR2r3d {runPlanR2r3d :: FFT.PlanR2r3d a}
planR2r3d :: (Class.Real a) => FFT.PlanR2r3d a
planR2r3d =
runPlanR2r3d $
Class.switchReal
(PlanR2r3d FFTF.planR2r3d)
(PlanR2r3d FFTD.planR2r3d)
newtype PlanR2r a =
PlanR2r {runPlanR2r :: FFT.PlanR2r a}
planR2r :: (Class.Real a) => FFT.PlanR2r a
planR2r =
runPlanR2r $
Class.switchReal
(PlanR2r FFTF.planR2r)
(PlanR2r FFTD.planR2r)
newtype PlanManyDFT a =
PlanManyDFT {runPlanManyDFT :: FFT.PlanManyDFT a}
planManyDFT :: (Class.Real a) => FFT.PlanManyDFT a
planManyDFT =
runPlanManyDFT $
Class.switchReal
(PlanManyDFT FFTF.planManyDFT)
(PlanManyDFT FFTD.planManyDFT)
newtype PlanManyDFTr2c a =
PlanManyDFTr2c {runPlanManyDFTr2c :: FFT.PlanManyDFTr2c a}
planManyDFTr2c :: (Class.Real a) => FFT.PlanManyDFTr2c a
planManyDFTr2c =
runPlanManyDFTr2c $
Class.switchReal
(PlanManyDFTr2c FFTF.planManyDFTr2c)
(PlanManyDFTr2c FFTD.planManyDFTr2c)
newtype PlanManyDFTc2r a =
PlanManyDFTc2r {runPlanManyDFTc2r :: FFT.PlanManyDFTc2r a}
planManyDFTc2r :: (Class.Real a) => FFT.PlanManyDFTc2r a
planManyDFTc2r =
runPlanManyDFTc2r $
Class.switchReal
(PlanManyDFTc2r FFTF.planManyDFTc2r)
(PlanManyDFTc2r FFTD.planManyDFTc2r)
newtype PlanManyR2r a =
PlanManyR2r {runPlanManyR2r :: FFT.PlanManyR2r a}
planManyR2r :: (Class.Real a) => FFT.PlanManyR2r a
planManyR2r =
runPlanManyR2r $
Class.switchReal
(PlanManyR2r FFTF.planManyR2r)
(PlanManyR2r FFTD.planManyR2r)
newtype PlanGuruDFT a =
PlanGuruDFT {runPlanGuruDFT :: FFT.PlanGuruDFT a}
planGuruDFT :: (Class.Real a) => FFT.PlanGuruDFT a
planGuruDFT =
runPlanGuruDFT $
Class.switchReal
(PlanGuruDFT FFTF.planGuruDFT)
(PlanGuruDFT FFTD.planGuruDFT)
newtype PlanGuruDFTr2c a =
PlanGuruDFTr2c {runPlanGuruDFTr2c :: FFT.PlanGuruDFTr2c a}
planGuruDFTr2c :: (Class.Real a) => FFT.PlanGuruDFTr2c a
planGuruDFTr2c =
runPlanGuruDFTr2c $
Class.switchReal
(PlanGuruDFTr2c FFTF.planGuruDFTr2c)
(PlanGuruDFTr2c FFTD.planGuruDFTr2c)
newtype PlanGuruDFTc2r a =
PlanGuruDFTc2r {runPlanGuruDFTc2r :: FFT.PlanGuruDFTc2r a}
planGuruDFTc2r :: (Class.Real a) => FFT.PlanGuruDFTc2r a
planGuruDFTc2r =
runPlanGuruDFTc2r $
Class.switchReal
(PlanGuruDFTc2r FFTF.planGuruDFTc2r)
(PlanGuruDFTc2r FFTD.planGuruDFTc2r)
newtype PlanGuruR2r a =
PlanGuruR2r {runPlanGuruR2r :: FFT.PlanGuruR2r a}
planGuruR2r :: (Class.Real a) => FFT.PlanGuruR2r a
planGuruR2r =
runPlanGuruR2r $
Class.switchReal
(PlanGuruR2r FFTF.planGuruR2r)
(PlanGuruR2r FFTD.planGuruR2r)
newtype PlanGuruSplitDFT a =
PlanGuruSplitDFT {runPlanGuruSplitDFT :: FFT.PlanGuruSplitDFT a}
planGuruSplitDFT :: (Class.Real a) => FFT.PlanGuruSplitDFT a
planGuruSplitDFT =
runPlanGuruSplitDFT $
Class.switchReal
(PlanGuruSplitDFT FFTF.planGuruSplitDFT)
(PlanGuruSplitDFT FFTD.planGuruSplitDFT)
newtype PlanGuruSplitDFTr2c a =
PlanGuruSplitDFTr2c {runPlanGuruSplitDFTr2c :: FFT.PlanGuruSplitDFTr2c a}
planGuruSplitDFTr2c :: (Class.Real a) => FFT.PlanGuruSplitDFTr2c a
planGuruSplitDFTr2c =
runPlanGuruSplitDFTr2c $
Class.switchReal
(PlanGuruSplitDFTr2c FFTF.planGuruSplitDFTr2c)
(PlanGuruSplitDFTr2c FFTD.planGuruSplitDFTr2c)
newtype PlanGuruSplitDFTc2r a =
PlanGuruSplitDFTc2r {runPlanGuruSplitDFTc2r :: FFT.PlanGuruSplitDFTc2r a}
planGuruSplitDFTc2r :: (Class.Real a) => FFT.PlanGuruSplitDFTc2r a
planGuruSplitDFTc2r =
runPlanGuruSplitDFTc2r $
Class.switchReal
(PlanGuruSplitDFTc2r FFTF.planGuruSplitDFTc2r)
(PlanGuruSplitDFTc2r FFTD.planGuruSplitDFTc2r)
newtype DestroyPlan a =
DestroyPlan {runDestroyPlan :: FFT.DestroyPlan a}
destroyPlan :: (Class.Real a) => FFT.DestroyPlan a
destroyPlan =
runDestroyPlan $
Class.switchReal
(DestroyPlan FFTF.destroyPlan)
(DestroyPlan FFTD.destroyPlan)
newtype Execute a =
Execute {runExecute :: FFT.Execute a}
execute :: (Class.Real a) => FFT.Execute a
execute =
runExecute $
Class.switchReal
(Execute FFTF.execute)
(Execute FFTD.execute)
newtype ExecuteDFT a =
ExecuteDFT {runExecuteDFT :: FFT.ExecuteDFT a}
executeDFT :: (Class.Real a) => FFT.ExecuteDFT a
executeDFT =
runExecuteDFT $
Class.switchReal
(ExecuteDFT FFTF.executeDFT)
(ExecuteDFT FFTD.executeDFT)
newtype ExecuteDFTr2c a =
ExecuteDFTr2c {runExecuteDFTr2c :: FFT.ExecuteDFTr2c a}
executeDFTr2c :: (Class.Real a) => FFT.ExecuteDFTr2c a
executeDFTr2c =
runExecuteDFTr2c $
Class.switchReal
(ExecuteDFTr2c FFTF.executeDFTr2c)
(ExecuteDFTr2c FFTD.executeDFTr2c)
newtype ExecuteDFTc2r a =
ExecuteDFTc2r {runExecuteDFTc2r :: FFT.ExecuteDFTc2r a}
executeDFTc2r :: (Class.Real a) => FFT.ExecuteDFTc2r a
executeDFTc2r =
runExecuteDFTc2r $
Class.switchReal
(ExecuteDFTc2r FFTF.executeDFTc2r)
(ExecuteDFTc2r FFTD.executeDFTc2r)
newtype ExecuteR2r a =
ExecuteR2r {runExecuteR2r :: FFT.ExecuteR2r a}
executeR2r :: (Class.Real a) => FFT.ExecuteR2r a
executeR2r =
runExecuteR2r $
Class.switchReal
(ExecuteR2r FFTF.executeR2r)
(ExecuteR2r FFTD.executeR2r)
newtype ExecuteSplitDFT a =
ExecuteSplitDFT {runExecuteSplitDFT :: FFT.ExecuteSplitDFT a}
executeSplitDFT :: (Class.Real a) => FFT.ExecuteSplitDFT a
executeSplitDFT =
runExecuteSplitDFT $
Class.switchReal
(ExecuteSplitDFT FFTF.executeSplitDFT)
(ExecuteSplitDFT FFTD.executeSplitDFT)
newtype ExecuteSplitDFTr2c a =
ExecuteSplitDFTr2c {runExecuteSplitDFTr2c :: FFT.ExecuteSplitDFTr2c a}
executeSplitDFTr2c :: (Class.Real a) => FFT.ExecuteSplitDFTr2c a
executeSplitDFTr2c =
runExecuteSplitDFTr2c $
Class.switchReal
(ExecuteSplitDFTr2c FFTF.executeSplitDFTr2c)
(ExecuteSplitDFTr2c FFTD.executeSplitDFTr2c)
newtype ExecuteSplitDFTc2r a =
ExecuteSplitDFTc2r {runExecuteSplitDFTc2r :: FFT.ExecuteSplitDFTc2r a}
executeSplitDFTc2r :: (Class.Real a) => FFT.ExecuteSplitDFTc2r a
executeSplitDFTc2r =
runExecuteSplitDFTc2r $
Class.switchReal
(ExecuteSplitDFTc2r FFTF.executeSplitDFTc2r)
(ExecuteSplitDFTc2r FFTD.executeSplitDFTc2r)
newtype Malloc a =
Malloc {runMalloc :: FFT.Malloc a}
malloc :: (Class.Real a) => FFT.Malloc a
malloc =
runMalloc $
Class.switchReal
(Malloc FFTF.malloc)
(Malloc FFTD.malloc)
newtype Free a =
Free {runFree :: FFT.Free a}
free :: (Class.Real a) => FFT.Free a
free =
runFree $
Class.switchReal
(Free FFTF.free)
(Free FFTD.free)
newtype AllocReal a =
AllocReal {runAllocReal :: FFT.AllocReal a}
allocReal :: (Class.Real a) => FFT.AllocReal a
allocReal =
runAllocReal $
Class.switchReal
(AllocReal FFTF.allocReal)
(AllocReal FFTD.allocReal)
newtype AllocComplex a =
AllocComplex {runAllocComplex :: FFT.AllocComplex a}
allocComplex :: (Class.Real a) => FFT.AllocComplex a
allocComplex =
runAllocComplex $
Class.switchReal
(AllocComplex FFTF.allocComplex)
(AllocComplex FFTD.allocComplex)
newtype FreeComplex a =
FreeComplex {runFreeComplex :: FFT.FreeComplex a}
freeComplex :: (Class.Real a) => FFT.FreeComplex a
freeComplex =
runFreeComplex $
Class.switchReal
(FreeComplex FFTF.freeComplex)
(FreeComplex FFTD.freeComplex)