synthesizer-inference-0.2: src/Synthesizer/Inference/Monad/SignalSeq/Oscillator.hs

{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{- |

Copyright   :  (c) Henning Thielemann 2006
License     :  GPL

Maintainer  :  synthesizer@henning-thielemann.de
Stability   :  provisional
Portability :  requires multi-parameter type classes
-}
module Synthesizer.Inference.Monad.SignalSeq.Oscillator(
   {- * Oscillators with constant waveforms -}
   static,
   freqMod,
   phaseMod,
   phaseFreqMod,
) where

import qualified Synthesizer.Inference.Monad.Signal     as SigI

import qualified Synthesizer.Inference.Monad.Signal.Oscillator as OsciI

import Synthesizer.Inference.Monad.Signal.Oscillator (static)

import qualified Synthesizer.Basic.Wave       as Wave

import qualified Algebra.OccasionallyScalar as OccScalar
import qualified Algebra.RealField          as RealField
import qualified Algebra.Field              as Field

import UniqueLogicNP.Monad (liftP, liftP2)
-- import NumericPrelude
import PreludeBase


{- * Oscillators with constant waveforms -}

{- | oscillator with a functional waveform with modulated frequency -}
freqMod :: (RealField.C a, Field.C q, OccScalar.C a q) =>
      Wave.T a v
   -> q
   -> a
   -> SigI.Process a q a
   -> SigI.Process a q v
freqMod wave amplitude phase =
   liftP (OsciI.freqMod wave amplitude phase)

{- | oscillator with modulated phase -}
phaseMod :: (RealField.C a, Field.C q, OccScalar.C a q) =>
      Wave.T a v
   -> q
   -> q
   -> SigI.Process a q a
   -> SigI.Process a q v
phaseMod wave amplitude freq =
   liftP (OsciI.phaseMod wave amplitude freq)

{- | oscillator with modulated phase and frequency -}
phaseFreqMod :: (RealField.C a, Field.C q, Eq q, OccScalar.C a q) =>
      Wave.T a v
   -> q
   -> SigI.Process a q a
   -> SigI.Process a q a
   -> SigI.Process a q v
phaseFreqMod wave amplitude =
   liftP2 (OsciI.phaseFreqMod wave amplitude)