strudel/study.md

study: why are there so many calls?

• pure('c3') => 746 calls per second...
• shapeshifted: (async()=>{return reify("c3").withLocation([1,5,20],[1,9,24])})()Ï => same # of calls with or without shapeshifting
• without highlighting (// strudel disable-highlighting), there are only 15 calls

call stack

this is how the ~15 calls are made for the first query:

• keypress -> activateCode -> evaluate -> safeEval -> pure -> new Pattern (pretty simple)
• query 0
  • const timespan = new TimeSpan(0,1)
    • Fraction(0), Fraction(1)
  • onQuery(new State(timespan))
    • pattern.query(state)
      • pure.query(state)
        • state.span.spanCycles
          • end.sam() -> this.floor -> new Fraction
          • begin.sam -> this.floor -> new Fraction
          • begin.nextSam
            • begin.sam -> this.floor -> new Fraction
            • .add(1) -> new Fraction
        • Fraction(0).wholeCycle -> new TimeSpan(0, 1)
          • this.sam -> new Fraction(0)
          • this.nextSam -> new Fraction(1)
        • new Hap(TimeSpan(0,1), TimeSpan(0,1), 'c3')
  • Tone.getTransport().cancel(0);
  • queryNextTime = 0.5
  • t = 0.6

from simple to complicated

(all without highlighting)

• pure('c3'): 15 calls
• pure('c3').fast(1): 74 calls
• pure('c3').fast(1).fast(1): 133 calls
• pure('c3').fast(1).fast(1).fast(1): 192 calls
• pure('c3').fast(1).fast(1).fast(1).fast(1): 251 calls
• pure('c3').fast(1).fast(1).fast(1).fast(1).fast(1): 310 calls
• pure('c3').fast(2): 94 calls
• pure('c3').fast(2).fast(2): 264 calls
• pure('c3').fast(2).fast(2).fast(2): 636 calls
• pure('c3').fast(4): 134 calls

WIL

• Fraction.wholeCycle: returns a timespan for the whole cycle the given fraction is in. Fraction(n).wholeCycle -> TimeSpan(n.floor, n.floor+1)
  • e.g. Fraction(0.5).wholeCycle -> TimeSpan(0, 1)
• TimeSpan.spanCycles: returns an array of whole cycle timespans that intersect with the given timespan
  • e.g. TimeSpan(0.5, 1.5) -> [TimeSpan(0, 1), TimeSpan(1, 2)]
• pure: returns one Hap for spanCycles of query span. Hap will get wholeCycle as whole and query span as part
• reify: turns non patterns into patterns using pure. makes sure you get a pattern

notes

• slowcat -> sequence -> fastcat -> slowcat is a somewhat hidden recursion
• slowcat -> pat_n can be negative and will then return an empty array. is that good? shouldn't pat_n be always a positive index?
• slowcat offset: how to think about this?
• slowcat: why add offset and sub it from the query span?