-- Do not edit! Automatically generated by fftw-generate.
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)