{-# LANGUAGE NoImplicitPrelude #-}
{- |
Copyright   :  (c) Henning Thielemann 2009
License     :  GPL

Maintainer  :  synthesizer@henning-thielemann.de
Stability   :  provisional
Portability :  requires multi-parameter type classes
-}
module Synthesizer.Dimensional.Map.Filter (
   -- * Amplification
   amplify,
   amplifyDimension,
   amplifyScalarDimension,
   negate,
   envelope,
   envelopeScalarDimension,
   envelopeVector,
   envelopeVectorDimension,
 ) where

import qualified Synthesizer.Dimensional.Map as MapD
import qualified Synthesizer.Dimensional.Amplitude as Amp

import qualified Number.DimensionTerm        as DN
import qualified Algebra.DimensionTerm       as Dim

import Number.DimensionTerm ((&*&), )

-- import qualified Number.NonNegative     as NonNeg

-- import qualified Algebra.Transcendental as Trans
-- import qualified Algebra.RealField      as RealField
-- import qualified Algebra.Field          as Field
-- import qualified Algebra.Real           as Real
import qualified Algebra.Ring           as Ring
import qualified Algebra.Additive       as Additive
-- import qualified Algebra.VectorSpace    as VectorSpace
import qualified Algebra.Module         as Module

-- import Control.Monad(liftM2)

import NumericPrelude hiding (negate)
import PreludeBase as P
import Prelude ()


{- | The amplification factor must be positive. -}
{-# INLINE amplify #-}
amplify :: (Module.C y amp) =>
   y ->
   MapD.T (Amp.Numeric amp) (Amp.Numeric amp) yv yv
amplify volume =
   MapD.independent (fmap (volume *>)) id

{-# INLINE amplifyDimension #-}
amplifyDimension :: (Ring.C y, Dim.C v0, Dim.C v1) =>
   DN.T v0 y ->
   MapD.T
       (Amp.Dimensional v1 y) (Amp.Dimensional (Dim.Mul v0 v1) y)
       yv yv
amplifyDimension volume =
   MapD.independent (fmap (volume &*&)) id

{-# INLINE amplifyScalarDimension #-}
amplifyScalarDimension :: (Ring.C y, Dim.C v) =>
   DN.T v y ->
   MapD.T
      (Amp.Dimensional Dim.Scalar y) (Amp.Dimensional v y)
      yv yv
amplifyScalarDimension volume =
   MapD.independent 
      (fmap $ flip DN.scale volume . DN.toNumber)
      id


{-# INLINE negate #-}
negate :: (Additive.C yv) =>
   MapD.T amp amp yv yv
negate =
   MapD.independent id Additive.negate


{-# INLINE envelope #-}
envelope :: (Ring.C y) =>
   MapD.T (Amp.Flat y, amp) amp (y,y) y
envelope =
   MapD.independent snd (uncurry (*))

{-# INLINE envelopeScalarDimension #-}
envelopeScalarDimension ::
   (Ring.C y, Dim.C v) =>
   MapD.T
      (Amp.Dimensional Dim.Scalar y, Amp.Dimensional v y)
      (Amp.Dimensional v y)
      (y,y) y
envelopeScalarDimension =
   MapD.independent
      (\(Amp.Numeric ampEnv, Amp.Numeric ampSig) ->
         Amp.Numeric $ DN.scale (DN.toNumber ampEnv) ampSig)
      (uncurry (*))

{-# INLINE envelopeVector #-}
envelopeVector :: (Module.C y yv) =>
   MapD.T (Amp.Flat y, amp) amp (y,yv) yv
envelopeVector =
   MapD.independent snd (uncurry (*>))

{-# INLINE envelopeVectorDimension #-}
envelopeVectorDimension ::
   (Module.C y0 yv, Ring.C y, Dim.C v0, Dim.C v1) =>
   MapD.T
      (Amp.Dimensional v0 y, Amp.Dimensional v1 y)
      (Amp.Dimensional (Dim.Mul v0 v1) y)
      (y0,yv) yv
envelopeVectorDimension =
   MapD.independent
      (\(Amp.Numeric ampEnv, Amp.Numeric ampSig) ->
         Amp.Numeric $ ampEnv &*& ampSig)
      (uncurry (*>))