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)