I’ve been thinking about this a bit. It’s trickier than you think.
I’ve been trying to find time to play with my ‘inline array’ operators: to re-cap:
ARP2 a b i // pick the i'th index from the repeating sequence "a b a b a b ..." (like an arpeggiator)
ARP7 a b c d e f g i // as above but with 7 values for the arp, instead of 2
SCL2 a b // define a scale with 'a' and 'b', based on 12 note western music, get the i'th degree
SCL7 a b c d e f g i // as above but with 7 values, so you could write out a major or minor scale with it
I really haven’t had much time to get it finalised. But some of my shower thoughts have been directed towards applying the same scheme towards quantiation (e.g.
QNT7). However the difficulty comes about from deciding what type of value we’re trying to quantise.
On the Teletype we have 2 ways to represent pitch, chromatic notes, or raw CV values. And we can convert from chromatic note numbers to CV with the
Let’s consider that we want to quantise “something” to a scale that contains C and E (duotonic?). (Please bear with my descriptions of scales and such, I have zero musical training.)
Firstly let’s consider it with our input being chromatic notes. If I pass in a C#, I’d expect a C out of my quantisation function, and if I pass in a D#, I’d expect an E. But what if I pass in a D? There are 4 options:
- quantise up
- quantise down
- choose randomly
- prefer better quality intervals (so unison trumps perfect 5th, which trumps perfect 4th, which trumps…), the assumption being that the first value provided to the function would be the root
Secondly let’s consider it with CV inputs. In this scenario, some things are actually much easier, as the probability of hitting the CV value that’s exactly half way between C and E is much harder (remember CV values go from 0 to 16,383.) But it get’s much hard to specify the scale as we’d need to use
N convert the value e.g.
QNT2 N 0 N 4 IN. So rather we’d need a different version that did the conversion for us (
QNN2 0 4 IN).
Anyway, that’s probably a bit of a ramble.
My general plan of attack is to get the current array ops finished (
BNDx - bounded arrays, and
UNBx unbounded arrays), I’m trying to get something pushed to my git repo this week, sorry to those that I had indicated that it might be sooner.
If they end up making their way into the official firmware, then I figure we can start talking about quantisation. But I’m afraid it’s all happening at my speed (it took me 6 months to do 2.0), sorry about that!