tur/notation

(nil-value)

(list-nil? [lst :int])

(cons [value :int next :int])

(head [lst :int])

(tail [lst :int])

(tidal-ok [x :int])

(tidal-err [e :int])

(tidal-ok? [r :ptr<void>])

(tidal-err? [r :ptr<void>])

(tidal-ok-val [r :ptr<void>])

(tidal-err-val [r :ptr<void>])

(tidal-void)

(tidal-cstr-as-int [s :cstr])

(tidal-cstr-eq? [a :cstr b :cstr])

(tidal-cstr-is-rest? [s :cstr])

(tidal-int-to-float [n :int])

(tidal-float-to-int [f :float])

(tidal-int-div [a :int b :int])

(tidal-int-mod [a :int b :int])

(tidal-int-max [a :int b :int])

(tidal-pat-alloc [kind :int])

(tidal-pat-add-child [pat :int child :int w :float])

(tidal-pat-kind [pat :int])

(tidal-pat-value [pat :int])

(tidal-pat-set-value [pat :int v :cstr])

(tidal-pat-count [pat :int])

(tidal-pat-child [pat :int i :int])

(tidal-pat-weight [pat :int i :int])

(tidal-pat-param-f [pat :int])

(tidal-pat-param-n [pat :int])

(tidal-pat-param-k [pat :int])

(tidal-pat-set-param-f [pat :int f :float])

(tidal-pat-set-param-n [pat :int v :int])

(tidal-pat-set-param-k [pat :int v :int])

(tidal-pat-total-weight [pat :int])

(tidal-pat-free-raw [pat :int])

free a PatNode tree iteratively (no nested C functions).

(tidal-tokenize [text :cstr])

(tidal-tok-count [ta :int])

(tidal-tok-type [ta :int i :int])

(tidal-ttidal-ok-value [ta :int i :int])

(tidal-tok-free [ta :int])

(tidal-atom-base [s :cstr])

(tidal-atom-mod-type [s :cstr])

(tidal-atom-mod-n [s :cstr])

(tidal-atom-mod-k [s :cstr])

(tidal-atom-mod-f [s :cstr])

(tidal-parse-element [ta :int i :int])

(tidal-parse-seq-body [ta :int i :int node :int])

(tidal-parse-alt-body [ta :int i :int node :int])

(tidal-parse-seq [text :cstr])

(tidal-el-new)

(tidal-el-push [el :int onset :float dur :float value :cstr])

(tidal-el-count [el :int])

(tidal-el-get [el :int i :int])

(tidal-el-to-cons [el :int])

(tidal-el-free-all [el :int])

(tidal-el-free-struct [el :int])

(tidal-ev-onset [e :int])

(tidal-ev-dur [e :int])

(tidal-ev-value [e :int])

(tidal-bjorklund [n :int k :int])

(tidal-bjorklund-get [arr :int i :int])

(tidal-bjorklund-free [arr :int])

(tidal-rand)

(tidal-eval [pat :int cycle :int onset :float dur :float el :int])

(tidal-child-dur [dur :float w :float total-w :float])

(tidal-slow-frac [r :float fa :float])

(tidal-eval-seq-children [pat :int n :int cycle :int onset :float dur :float i :int el :int total-w :float])

(tidal-eval-repeat-steps [child :int n :int cycle :int onset :float step-dur :float i :int el :int])

(tidal-eval-fast-steps [child :int fi :int cycle :int onset :float step-dur :float i :int el :int])

(tidal-eval-stack-children [pat :int n :int cycle :int onset :float dur :float i :int el :int])

(tidal-eval-euclid-steps [child :int pulses :int k :int cycle :int onset :float step-dur :float i :int el :int])

(tidal-eval-slow-filter [temp-el :int i :int frac :float frac-end :float onset :float dur :float factor :float el :int])

(tidal-eval-slow [pat :int cycle :int onset :float dur :float el :int])

(tidal-eval-rev-build [temp-el :int n :int i :int onset :float dur :float el :int])

(tidal-eval-degrade-filter [temp-el :int n :int i :int prob :float el :int])

(tidal-eval-to-cons [pat :int cycle :int])

evaluate pattern at cycle, return cons list of event handles.

(let [evts (tidal-eval-to-cons p 0)]
    (if (list-nil? evts) "empty" "has events"))

Since: TD1

(parse-notation [text :cstr])

parse mini-notation text into a pattern handle.

(let [r (parse-notation "bd sd cp")]
    (if (tidal-ok? r) (tidal-ok-val r) "error"))

Since: TD1

(notation-free [p :int])

free a pattern returned by parse-notation.

(notation-free p)

Since: TD1

(pattern-events [p :int cycle :int])

evaluate a pattern at the given cycle number.

(let [evts (pattern-events p 0)]
    (if (list-nil? evts) "empty" "has events"))

Since: TD1