Synthesizer.Plain.ToneModulation

Avoid importing this module. Better use functions from Synthesizer.Plain.Oscillator and Synthesizer.Basic.Wave

Input data is interpreted as samples of data on a cylinder in the following form:

 |*          |
 |   *       |
 |      *    |
 |         * |
 | *         |
 |    *      |
 |       *   |
 |          *|
 |  *        |
 |     *     |
 |        *  |

 -----------
 *
     *
         *
  *
      *
          *
   *
       *
           *
    *
        *
 -----------

We have to interpolate in the parallelograms.

general helpers

type Cell y = T (T y)

interpolateCell :: T a y -> T b y -> (a, b) -> Cell y -> y

array based shape variable wave

data Prototype t y

Constructors

Prototype

Fields

protoMarginLeap :: Margin

protoMarginStep :: Margin

protoIpOffset :: Int

protoPeriod :: t

protoPeriodInt :: Int

protoShapeLimits :: (t, t)

protoArray :: Array Int y

makePrototype :: C t => Margin -> Margin -> Int -> t -> T y -> Prototype t y

sampledToneCell :: C t => Prototype t y -> t -> T t -> ((t, t), Cell y)

lazy oscillator

oscillatorCells :: C t => Margin -> Margin -> Int -> t -> T y -> (t, T t) -> (T t, T t) -> T ((t, t), Cell y)

seekCell :: C t => Int -> t -> ((t, T t), Cell y) -> ((t, t), Cell y)

oscillatorSuffixes :: C t => Margin -> Margin -> Int -> t -> T y -> (t, T t) -> (T t, T t) -> T ((t, T t), Cell y)

dropFrac :: C i => i -> T a -> (Int, i, T a)

dropFrac' :: C i => i -> T a -> (Int, i, T a)

propDropFrac :: (C i, Eq a) => i -> T a -> Bool

dropRem :: Int -> T a -> (Int, T a)

dropRem' :: Int -> T a -> (Int, T a)

propDropRem :: Eq a => Int -> T a -> Bool

oscillatorCoords :: C t => Int -> t -> (t, T t) -> (T t, T t) -> T (Coords t)

integrateFractional :: C t => t -> (t, T t) -> (T t, T t) -> T (Skip t)

freqsToPhases :: C a => T a -> T a -> T (T a)

Convert a list of phase steps into a list of momentum phases phase is a number in the interval [0,1) freq contains the phase steps

limitRelativeShapes :: (C t, Ord t) => Margin -> Margin -> Int -> T y -> (t, T t) -> (t, T t)

limitMinRelativeValues :: (C a, Ord a) => a -> a -> T a -> (a, T a)

limitMaxRelativeValues :: (C a, Ord a) => a -> a -> T a -> (a, T a)

limitMaxRelativeValuesNonNeg :: (C a, Ord a) => a -> a -> T a -> (a, T a)

Avoids negative numbers and thus can be used with Chunky numbers.

safeSub :: (C a, Ord a) => a -> a -> (Bool, a)