Sound.Sc3.Common.Math.Operator

Non-standard mathematical enumerations, classes and base instances.

Enumerations of the unary and binary math unit generators. Names that conflict with existing names have a _ suffix.

The Eq and Ord classes in the Prelude require Bool, hence EqE and OrdE. True is 1.0, False is 0.0

The RealFrac class requires Integral results, hence RealFracE.

Unary

data Sc3_Unary_Op

Enumeration of Sc3 unary operator Ugens. The names here are from the enumeration at "serverpluginsUnaryOpUgens.cpp". The capitalisation is edited since these names become function names in rsc3. Names have a _ suffix if they conflict with Ugen names.

zip (map show [minBound :: Sc3_Unary_Op .. maxBound]) [0..]

Constructors

OpNeg

OpNot

OpIsNil

OpNotNil

OpBitNot

OpAbs

OpAsFloat

OpAsInt

OpCeil

OpFloor

OpFrac

OpSign

OpSquared

OpCubed

OpSqrt

OpExp

OpRecip

OpMidiCps

OpCpsMidi

OpMidiRatio

OpRatioMidi

OpDbAmp

OpAmpDb

OpOctCps

OpCpsOct

OpLog

OpLog2

OpLog10

OpSin

OpCos

OpTan

OpArcSin

OpArcCos

OpArcTan

OpSinh

OpCosh

OpTanh

OpRand_

OpRand2

OpLinRand_

OpBiLinRand

OpSum3Rand

OpDistort

OpSoftClip

OpCoin

OpDigitValue

OpSilence

OpThru

OpRectWindow

OpHanWindow

OpWelchWindow

OpTriWindow

OpRamp_

OpScurve

Instances

Bounded Sc3_Unary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

minBound :: Sc3_Unary_Op

maxBound :: Sc3_Unary_Op

Enum Sc3_Unary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

succ :: Sc3_Unary_Op -> Sc3_Unary_Op

pred :: Sc3_Unary_Op -> Sc3_Unary_Op

toEnum :: Int -> Sc3_Unary_Op

fromEnum :: Sc3_Unary_Op -> Int

enumFrom :: Sc3_Unary_Op -> [Sc3_Unary_Op]

enumFromThen :: Sc3_Unary_Op -> Sc3_Unary_Op -> [Sc3_Unary_Op]

enumFromTo :: Sc3_Unary_Op -> Sc3_Unary_Op -> [Sc3_Unary_Op]

enumFromThenTo :: Sc3_Unary_Op -> Sc3_Unary_Op -> Sc3_Unary_Op -> [Sc3_Unary_Op]

Read Sc3_Unary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

readsPrec :: Int -> ReadS Sc3_Unary_Op

readList :: ReadS [Sc3_Unary_Op]

readPrec :: ReadPrec Sc3_Unary_Op

readListPrec :: ReadPrec [Sc3_Unary_Op]

Show Sc3_Unary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

showsPrec :: Int -> Sc3_Unary_Op -> ShowS

show :: Sc3_Unary_Op -> String

showList :: [Sc3_Unary_Op] -> ShowS

Eq Sc3_Unary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

(==) :: Sc3_Unary_Op -> Sc3_Unary_Op -> Bool

(/=) :: Sc3_Unary_Op -> Sc3_Unary_Op -> Bool

sc3_unary_op_name :: Sc3_Unary_Op -> String

Enum name without Op prefix.

parse_unary :: Case_Rule -> String -> Maybe Sc3_Unary_Op

parse_enum with Op prefix.

>>> Data.Maybe.mapMaybe (parse_unary Base.Cs) (words "Abs Rand")
[OpAbs]

sc3_unary_op_tbl :: [(String, Int)]

Table of operator names (non-symbolic) and indices.

map fst sc3_unary_op_tbl

unary_sym_tbl :: [(Sc3_Unary_Op, String)]

Table of symbolic names for standard unary operators.

unaryName :: Int -> String

Lookup possibly symbolic name for standard unary operators.

unaryIndex :: Case_Rule -> String -> Maybe Int

Given name of unary operator derive index.

>>> Data.Maybe.mapMaybe (unaryIndex Base.Ci) (words "abs Cubed midiCps Neg")
[5,13,17,0]

>>> unaryIndex Base.Cs "SinOsc"
Nothing

is_unary :: Case_Rule -> String -> Bool

isJust of unaryIndex.

>>> map (is_unary Base.Ci) (words "Abs MidiCps Neg")
[True,True,True]

>>> map (is_unary Base.Ci) (words "- rand")
[False,False]

>>> map (is_unary Base.Ci) (words "arctan atan")
[True,False]

Binary

data Sc3_Binary_Op

Enumeration of Sc3 unary operator Ugens. The names here are from the enumeration at "serverpluginsBinaryOpUgens.cpp".

zip (map show [minBound :: Sc3_Binary_Op .. maxBound]) [0..]

Constructors

OpAdd

OpSub

OpMul

OpIdiv

OpFdiv

OpMod

OpEq

OpNe

OpLt

OpGt

OpLe

OpGe

OpMin

OpMax

OpBitAnd

OpBitOr

OpBitXor

OpLcm

OpGcd

OpRoundTo

OpRoundUp

OpTrunc

OpAtan2

OpHypot

OpHypotx

OpPow

OpShiftLeft

OpShiftRight

OpUnsignedShift

OpFill

OpRing1

OpRing2

OpRing3

OpRing4

OpDifSqr

OpSumSqr

OpSqrSum

OpSqrDif

OpAbsDif

OpThresh

OpAmClip

OpScaleNeg

OpClip2

OpExcess

OpFold2

OpWrap2

OpFirstArg

OpRandRange

OpExpRandRange

Instances

Bounded Sc3_Binary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

minBound :: Sc3_Binary_Op

maxBound :: Sc3_Binary_Op

Enum Sc3_Binary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

succ :: Sc3_Binary_Op -> Sc3_Binary_Op

pred :: Sc3_Binary_Op -> Sc3_Binary_Op

toEnum :: Int -> Sc3_Binary_Op

fromEnum :: Sc3_Binary_Op -> Int

enumFrom :: Sc3_Binary_Op -> [Sc3_Binary_Op]

enumFromThen :: Sc3_Binary_Op -> Sc3_Binary_Op -> [Sc3_Binary_Op]

enumFromTo :: Sc3_Binary_Op -> Sc3_Binary_Op -> [Sc3_Binary_Op]

enumFromThenTo :: Sc3_Binary_Op -> Sc3_Binary_Op -> Sc3_Binary_Op -> [Sc3_Binary_Op]

Read Sc3_Binary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

readsPrec :: Int -> ReadS Sc3_Binary_Op

readList :: ReadS [Sc3_Binary_Op]

readPrec :: ReadPrec Sc3_Binary_Op

readListPrec :: ReadPrec [Sc3_Binary_Op]

Show Sc3_Binary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

showsPrec :: Int -> Sc3_Binary_Op -> ShowS

show :: Sc3_Binary_Op -> String

showList :: [Sc3_Binary_Op] -> ShowS

Eq Sc3_Binary_Op

Defined in Sound.Sc3.Common.Math.Operator

Methods

(==) :: Sc3_Binary_Op -> Sc3_Binary_Op -> Bool

(/=) :: Sc3_Binary_Op -> Sc3_Binary_Op -> Bool

sc3_binary_op_name :: Sc3_Binary_Op -> String

Enum name without Op prefix.

sc3_binary_op_tbl :: [(String, Int)]

Table of operator names (non-symbolic) and indices.

parse_binary :: Case_Rule -> String -> Maybe Sc3_Binary_Op

parse_enum with Op prefix.

>>> parse_binary Base.Ci "mul"
Just OpMul

binary_sym_tbl :: [(Sc3_Binary_Op, String)]

Table of symbolic names for standard binary operators.

sc3_binary_op_sym_tbl :: [(String, Int)]

Table of operator names (non-symbolic) and indices.

map fst sc3_binary_op_sym_tbl

binaryName :: Int -> String

Lookup possibly symbolic name for standard binary operators.

>>> map binaryName [1,2,8,12]
["-","*","<","Min"]

binaryIndex :: Case_Rule -> String -> Maybe Int

Given name of binary operator derive index.

>>> Data.Maybe.mapMaybe (binaryIndex Base.Ci) (words "* mul ring1 +")
[2,2,30,0]

>>> binaryIndex Base.Ci "sinosc"
Nothing

>>> map (\x -> (x,binaryIndex Base.Ci x)) (map snd binary_sym_tbl)
[("+",Just 0),("-",Just 1),("*",Just 2),("/",Just 4),("%",Just 5),("==",Just 6),("/=",Just 7),("<",Just 8),(">",Just 9),("<=",Just 10),(">=",Just 11),(".&.",Just 14),(".|.",Just 15),("**",Just 25)]

is_binary :: Case_Rule -> String -> Bool

isJust of binaryIndex.

>>> map (is_binary Base.Ci) (words "== > % Trunc max")
[True,True,True,True,True]

Operator

ugen_operator_name :: String -> Int -> Maybe String

Lookup operator name for operator Ugens, else Ugen name.

resolve_operator :: Case_Rule -> String -> (String, Maybe Int)

Order of lookup: binary then unary.

>>> map (resolve_operator Base.Ci) (words "+ - sub abs max")
[("BinaryOpUGen",Just 0),("BinaryOpUGen",Just 1),("BinaryOpUGen",Just 1),("UnaryOpUGen",Just 5),("BinaryOpUGen",Just 13)]

>>> map (resolve_operator Base.Cs) (words "Abs Add Neg")
[("UnaryOpUGen",Just 5),("BinaryOpUGen",Just 0),("UnaryOpUGen",Just 0)]

resolve_operator_ci :: String -> (String, Maybe Int)

Case-insensitive resolve_operator.

Classes

class (Eq a, Num a) => EqE a where

Variant on Eq class, result is of the same type as the values compared.

Minimal complete definition

Nothing

Methods

equal_to :: a -> a -> a

not_equal_to :: a -> a -> a

Instances

EqE Int32

Defined in Sound.Sc3.Common.Math.Operator

Methods

equal_to :: Int32 -> Int32 -> Int32

not_equal_to :: Int32 -> Int32 -> Int32

EqE Int64

Defined in Sound.Sc3.Common.Math.Operator

Methods

equal_to :: Int64 -> Int64 -> Int64

not_equal_to :: Int64 -> Int64 -> Int64

EqE Ugen

Defined in Sound.Sc3.Ugen.Ugen

Methods

equal_to :: Ugen -> Ugen -> Ugen

not_equal_to :: Ugen -> Ugen -> Ugen

EqE Integer

Defined in Sound.Sc3.Common.Math.Operator

Methods

equal_to :: Integer -> Integer -> Integer

not_equal_to :: Integer -> Integer -> Integer

EqE Double

Defined in Sound.Sc3.Common.Math.Operator

Methods

equal_to :: Double -> Double -> Double

not_equal_to :: Double -> Double -> Double

EqE Float

Defined in Sound.Sc3.Common.Math.Operator

Methods

equal_to :: Float -> Float -> Float

not_equal_to :: Float -> Float -> Float

EqE Int

Defined in Sound.Sc3.Common.Math.Operator

Methods

equal_to :: Int -> Int -> Int

not_equal_to :: Int -> Int -> Int

class (Ord a, Num a) => OrdE a where

Variant on Ord class, result is of the same type as the values compared.

Minimal complete definition

Nothing

Methods

less_than :: a -> a -> a

less_than_or_equal_to :: a -> a -> a

greater_than :: a -> a -> a

greater_than_or_equal_to :: a -> a -> a

Instances

OrdE Int32

Defined in Sound.Sc3.Common.Math.Operator

Methods

less_than :: Int32 -> Int32 -> Int32

less_than_or_equal_to :: Int32 -> Int32 -> Int32

greater_than :: Int32 -> Int32 -> Int32

greater_than_or_equal_to :: Int32 -> Int32 -> Int32

OrdE Int64

Defined in Sound.Sc3.Common.Math.Operator

Methods

less_than :: Int64 -> Int64 -> Int64

less_than_or_equal_to :: Int64 -> Int64 -> Int64

greater_than :: Int64 -> Int64 -> Int64

greater_than_or_equal_to :: Int64 -> Int64 -> Int64

OrdE Ugen

Defined in Sound.Sc3.Ugen.Ugen

Methods

less_than :: Ugen -> Ugen -> Ugen

less_than_or_equal_to :: Ugen -> Ugen -> Ugen

greater_than :: Ugen -> Ugen -> Ugen

greater_than_or_equal_to :: Ugen -> Ugen -> Ugen

OrdE Integer

Defined in Sound.Sc3.Common.Math.Operator

Methods

less_than :: Integer -> Integer -> Integer

less_than_or_equal_to :: Integer -> Integer -> Integer

greater_than :: Integer -> Integer -> Integer

greater_than_or_equal_to :: Integer -> Integer -> Integer

OrdE Double

Defined in Sound.Sc3.Common.Math.Operator

Methods

less_than :: Double -> Double -> Double

less_than_or_equal_to :: Double -> Double -> Double

greater_than :: Double -> Double -> Double

greater_than_or_equal_to :: Double -> Double -> Double

OrdE Float

Defined in Sound.Sc3.Common.Math.Operator

Methods

less_than :: Float -> Float -> Float

less_than_or_equal_to :: Float -> Float -> Float

greater_than :: Float -> Float -> Float

greater_than_or_equal_to :: Float -> Float -> Float

OrdE Int

Defined in Sound.Sc3.Common.Math.Operator

Methods

less_than :: Int -> Int -> Int

less_than_or_equal_to :: Int -> Int -> Int

greater_than :: Int -> Int -> Int

greater_than_or_equal_to :: Int -> Int -> Int

class RealFrac a => RealFracE a where

Variant of RealFrac with non Integral results.

Minimal complete definition

Nothing

Methods

properFractionE :: a -> (a, a)

truncateE :: a -> a

roundE :: a -> a

ceilingE :: a -> a

floorE :: a -> a

Instances

RealFracE Ugen

Defined in Sound.Sc3.Ugen.Ugen

Methods

properFractionE :: Ugen -> (Ugen, Ugen)

truncateE :: Ugen -> Ugen

roundE :: Ugen -> Ugen

ceilingE :: Ugen -> Ugen

floorE :: Ugen -> Ugen

RealFracE Double

Defined in Sound.Sc3.Common.Math.Operator

Methods

properFractionE :: Double -> (Double, Double)

truncateE :: Double -> Double

roundE :: Double -> Double

ceilingE :: Double -> Double

floorE :: Double -> Double

RealFracE Float

Defined in Sound.Sc3.Common.Math.Operator

Methods

properFractionE :: Float -> (Float, Float)

truncateE :: Float -> Float

roundE :: Float -> Float

ceilingE :: Float -> Float

floorE :: Float -> Float

class (Floating a, Ord a) => UnaryOp a where

Unary operator class.

>>> map (floor . (* 1e4) . dbAmp) [-90,-60,-30,0]
[0,10,316,10000]

Minimal complete definition

Nothing

Methods

ampDb :: a -> a

asFloat :: a -> a

asInt :: a -> a

cpsMidi :: a -> a

cpsOct :: a -> a

cubed :: a -> a

dbAmp :: a -> a

distort :: a -> a

frac :: a -> a

isNil :: a -> a

log10 :: a -> a

log2 :: a -> a

midiCps :: a -> a

midiRatio :: a -> a

notE :: a -> a

notNil :: a -> a

octCps :: a -> a

ramp_ :: a -> a

ratioMidi :: a -> a

softClip :: a -> a

squared :: a -> a

Instances

UnaryOp Ugen

Defined in Sound.Sc3.Ugen.Ugen

Methods

ampDb :: Ugen -> Ugen

asFloat :: Ugen -> Ugen

asInt :: Ugen -> Ugen

cpsMidi :: Ugen -> Ugen

cpsOct :: Ugen -> Ugen

cubed :: Ugen -> Ugen

dbAmp :: Ugen -> Ugen

distort :: Ugen -> Ugen

frac :: Ugen -> Ugen

isNil :: Ugen -> Ugen

log10 :: Ugen -> Ugen

log2 :: Ugen -> Ugen

midiCps :: Ugen -> Ugen

midiRatio :: Ugen -> Ugen

notE :: Ugen -> Ugen

notNil :: Ugen -> Ugen

octCps :: Ugen -> Ugen

ramp_ :: Ugen -> Ugen

ratioMidi :: Ugen -> Ugen

softClip :: Ugen -> Ugen

squared :: Ugen -> Ugen

UnaryOp Double

Defined in Sound.Sc3.Common.Math.Operator

Methods

ampDb :: Double -> Double

asFloat :: Double -> Double

asInt :: Double -> Double

cpsMidi :: Double -> Double

cpsOct :: Double -> Double

cubed :: Double -> Double

dbAmp :: Double -> Double

distort :: Double -> Double

frac :: Double -> Double

isNil :: Double -> Double

log10 :: Double -> Double

log2 :: Double -> Double

midiCps :: Double -> Double

midiRatio :: Double -> Double

notE :: Double -> Double

notNil :: Double -> Double

octCps :: Double -> Double

ramp_ :: Double -> Double

ratioMidi :: Double -> Double

softClip :: Double -> Double

squared :: Double -> Double

UnaryOp Float

Defined in Sound.Sc3.Common.Math.Operator

Methods

ampDb :: Float -> Float

asFloat :: Float -> Float

asInt :: Float -> Float

cpsMidi :: Float -> Float

cpsOct :: Float -> Float

cubed :: Float -> Float

dbAmp :: Float -> Float

distort :: Float -> Float

frac :: Float -> Float

isNil :: Float -> Float

log10 :: Float -> Float

log2 :: Float -> Float

midiCps :: Float -> Float

midiRatio :: Float -> Float

notE :: Float -> Float

notNil :: Float -> Float

octCps :: Float -> Float

ramp_ :: Float -> Float

ratioMidi :: Float -> Float

softClip :: Float -> Float

squared :: Float -> Float

class (Floating a, RealFrac a, Ord a) => BinaryOp a where

Sc3_Binary_Op operator class.

Minimal complete definition

Nothing

Methods

absDif :: a -> a -> a

amClip :: a -> a -> a

atan2E :: a -> a -> a

clip2 :: a -> a -> a

difSqr :: a -> a -> a

excess :: a -> a -> a

exprandRange :: a -> a -> a

fill :: a -> a -> a

firstArg :: a -> a -> a

fold2 :: a -> a -> a

gcdE :: a -> a -> a

hypot :: a -> a -> a

hypotx :: a -> a -> a

iDiv :: a -> a -> a

lcmE :: a -> a -> a

modE :: a -> a -> a

randRange :: a -> a -> a

ring1 :: a -> a -> a

ring2 :: a -> a -> a

ring3 :: a -> a -> a

ring4 :: a -> a -> a

roundUp :: a -> a -> a

scaleNeg :: a -> a -> a

sqrDif :: a -> a -> a

sqrSum :: a -> a -> a

sumSqr :: a -> a -> a

thresh :: a -> a -> a

trunc :: a -> a -> a

wrap2 :: a -> a -> a

Instances

BinaryOp Ugen

Defined in Sound.Sc3.Ugen.Ugen

Methods

absDif :: Ugen -> Ugen -> Ugen

amClip :: Ugen -> Ugen -> Ugen

atan2E :: Ugen -> Ugen -> Ugen

clip2 :: Ugen -> Ugen -> Ugen

difSqr :: Ugen -> Ugen -> Ugen

excess :: Ugen -> Ugen -> Ugen

exprandRange :: Ugen -> Ugen -> Ugen

fill :: Ugen -> Ugen -> Ugen

firstArg :: Ugen -> Ugen -> Ugen

fold2 :: Ugen -> Ugen -> Ugen

gcdE :: Ugen -> Ugen -> Ugen

hypot :: Ugen -> Ugen -> Ugen

hypotx :: Ugen -> Ugen -> Ugen

iDiv :: Ugen -> Ugen -> Ugen

lcmE :: Ugen -> Ugen -> Ugen

modE :: Ugen -> Ugen -> Ugen

randRange :: Ugen -> Ugen -> Ugen

ring1 :: Ugen -> Ugen -> Ugen

ring2 :: Ugen -> Ugen -> Ugen

ring3 :: Ugen -> Ugen -> Ugen

ring4 :: Ugen -> Ugen -> Ugen

roundUp :: Ugen -> Ugen -> Ugen

scaleNeg :: Ugen -> Ugen -> Ugen

sqrDif :: Ugen -> Ugen -> Ugen

sqrSum :: Ugen -> Ugen -> Ugen

sumSqr :: Ugen -> Ugen -> Ugen

thresh :: Ugen -> Ugen -> Ugen

trunc :: Ugen -> Ugen -> Ugen

wrap2 :: Ugen -> Ugen -> Ugen

BinaryOp Double

Defined in Sound.Sc3.Common.Math.Operator

Methods

absDif :: Double -> Double -> Double

amClip :: Double -> Double -> Double

atan2E :: Double -> Double -> Double

clip2 :: Double -> Double -> Double

difSqr :: Double -> Double -> Double

excess :: Double -> Double -> Double

exprandRange :: Double -> Double -> Double

fill :: Double -> Double -> Double

firstArg :: Double -> Double -> Double

fold2 :: Double -> Double -> Double

gcdE :: Double -> Double -> Double

hypot :: Double -> Double -> Double

hypotx :: Double -> Double -> Double

iDiv :: Double -> Double -> Double

lcmE :: Double -> Double -> Double

modE :: Double -> Double -> Double

randRange :: Double -> Double -> Double

ring1 :: Double -> Double -> Double

ring2 :: Double -> Double -> Double

ring3 :: Double -> Double -> Double

ring4 :: Double -> Double -> Double

roundUp :: Double -> Double -> Double

scaleNeg :: Double -> Double -> Double

sqrDif :: Double -> Double -> Double

sqrSum :: Double -> Double -> Double

sumSqr :: Double -> Double -> Double

thresh :: Double -> Double -> Double

trunc :: Double -> Double -> Double

wrap2 :: Double -> Double -> Double

BinaryOp Float

Defined in Sound.Sc3.Common.Math.Operator

Methods

absDif :: Float -> Float -> Float

amClip :: Float -> Float -> Float

atan2E :: Float -> Float -> Float

clip2 :: Float -> Float -> Float

difSqr :: Float -> Float -> Float

excess :: Float -> Float -> Float

exprandRange :: Float -> Float -> Float

fill :: Float -> Float -> Float

firstArg :: Float -> Float -> Float

fold2 :: Float -> Float -> Float

gcdE :: Float -> Float -> Float

hypot :: Float -> Float -> Float

hypotx :: Float -> Float -> Float

iDiv :: Float -> Float -> Float

lcmE :: Float -> Float -> Float

modE :: Float -> Float -> Float

randRange :: Float -> Float -> Float

ring1 :: Float -> Float -> Float

ring2 :: Float -> Float -> Float

ring3 :: Float -> Float -> Float

ring4 :: Float -> Float -> Float

roundUp :: Float -> Float -> Float

scaleNeg :: Float -> Float -> Float

sqrDif :: Float -> Float -> Float

sqrSum :: Float -> Float -> Float

sumSqr :: Float -> Float -> Float

thresh :: Float -> Float -> Float

trunc :: Float -> Float -> Float

wrap2 :: Float -> Float -> Float

Infix

(==**) :: EqE a => a -> a -> a

(/=**) :: EqE a => a -> a -> a

(<**) :: OrdE a => a -> a -> a

(<=**) :: OrdE a => a -> a -> a

(>**) :: OrdE a => a -> a -> a

(>=**) :: OrdE a => a -> a -> a

Tables

binop_hs_tbl :: (Real n, Floating n, RealFrac n) => [(Sc3_Binary_Op, n -> n -> n)]

Association table for Sc3_Binary_Op to haskell function implementing operator.

binop_special_hs :: (RealFrac n, Floating n) => Int -> Maybe (n -> n -> n)

lookup binop_hs_tbl via toEnum.

uop_hs_tbl :: (RealFrac n, Floating n) => [(Sc3_Unary_Op, n -> n)]

Association table for Unary to haskell function implementing operator.

uop_special_hs :: (RealFrac n, Floating n) => Int -> Maybe (n -> n)

lookup uop_hs_tbl via toEnum.