Oscillator.hs

{-# OPTIONS -fno-implicit-prelude -fglasgow-exts #-}
{- |
Copyright   :  (c) Henning Thielemann 2006, 2008
License     :  GPL

Maintainer  :  synthesizer@henning-thielemann.de
Stability   :  provisional
Portability :  requires multi-parameter type classes

-}
module Synthesizer.Inference.Reader.Oscillator (
   {- * Oscillators with constant waveforms -}
   static,
   freqMod,
   phaseMod,
   phaseFreqMod,
) where

import qualified Synthesizer.SampleRateContext.Oscillator as OsciC

-- import qualified Synthesizer.Plain.Oscillator as Osci
import qualified Synthesizer.Basic.Wave       as Wave

import qualified Synthesizer.Inference.Reader.Signal as SigR
import qualified Synthesizer.Inference.Reader.Process as Proc

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

-- import NumericPrelude
-- import PreludeBase as P


{- * Oscillators with constant waveforms -}

{- | oscillator with a functional waveform with constant frequency -}
static :: (RealField.C t, Field.C t', OccScalar.C t t') =>
      Wave.T t yv  {- ^ waveform -}
   -> y'           {- ^ amplitude -}
   -> t            {- ^ start phase from the range [0,1] -}
   -> t'           {- ^ frequency -}
   -> Proc.T t t' (SigR.T y y' yv)
static wave amplitude phase freq =
   SigR.lift (OsciC.static wave amplitude phase freq)

{- | oscillator with a functional waveform with modulated frequency -}
freqMod :: (RealField.C t, Field.C t', OccScalar.C t t') =>
      Wave.T t yv  {- ^ waveform -}
   -> y'           {- ^ amplitude -}
   -> t            {- ^ start phase from the range [0,1] -}
   -> Proc.T t t' (
          SigR.T t t' t  {-   frequency control -}
       -> SigR.T y y' yv)
freqMod wave amplitude phase =
   SigR.lift (OsciC.freqMod wave amplitude phase)

{- | oscillator with modulated phase -}
phaseMod :: (RealField.C t, Field.C t', OccScalar.C t t') =>
      Wave.T t yv  {- ^ waveform -}
   -> y'           {- ^ amplitude -}
   -> t'           {- ^ frequency control -}
   -> Proc.T t t' (
          SigR.T t t  t  {-   phase modulation, phases must have no unit and
                              are from range [0,1] -}
       -> SigR.T y y' yv)
phaseMod wave amplitude freq =
   SigR.lift (OsciC.phaseMod wave amplitude freq)

{- | oscillator with a functional waveform with modulated phase and frequency -}
phaseFreqMod :: (RealField.C t, Field.C t', OccScalar.C t t') =>
      Wave.T t yv  {- ^ waveform -}
   -> y'           {- ^ amplitude -}
   -> Proc.T t t' (
          SigR.T t t  t  {-   phase control -}
       -> SigR.T t t' t  {-   frequency control -}
       -> SigR.T y y' yv)
phaseFreqMod wave amplitude =
   SigR.lift (OsciC.phaseFreqMod wave amplitude)