Love this idea!
It reminded me to a paper by synth designer Peter Blasser (Ciat Lonbarde) “Deconstructing the triangle wave”.
The inertia wave you draw has a similar quality as a drawing of Peter:
It is a fascinating text.
1 Like
It made me think of this one :
A module that interests me a lot, for sure… The list of things you can do with it :
- a rich oscillator with 5+ octaves of temperature-compensated V/O and CV over skew
- a quadrature sine wave oscillator
- an LFO divider
- a filter with controllable, skewable resonance, from a light touch to screaming glitches
- an envelope generator with nuanced, natural sounding control over the minutiae of the attack and decay stages
- an intuitive sine wave skew LFO
- a phase locked loop
- a voltage controlled exponential slew limiter
- a slew limiter with controllable overshoot and settling (like a Wogglebug)
- a percussive sound generator
- etc
Bref, I’d be super interested to see something like that in VCV !!
2 Likes
Oh, interesting, I’ll read it later
Hmmm, it is similar to what I was thinking about! Nice, so it exists therefore it is possible to do in VCV… I think
Well, I whipped out this BASICally script that maybe does the inertia part, albeit with an extremely naïve notion about how physics works:
WHEN start()
pos = in1
velocity = 0
' Maximum acceleration per sample.
' Should be computed from something more
' intuitive.
max_accel = 0.001
' Maximum amount of ground pos can cover
' in a sample.
max_vel = 0.07
' A friction coefficient to prevent
' infinite wobble around IN1?
friction = 0.00009
END WHEN
ALSO
diff = in1 - pos
IF velocity > 0 THEN
velocity = max(velocity - friction, 0)
ELSE
velocity = min(velocity + friction, 0)
END IF
if diff > 0 THEN
velocity = velocity + min(max_accel, diff)
ELSE
velocity = velocity + max(-1 * max_accel, diff)
END IF
IF velocity > 0 THEN
velocity = min(velocity, max_vel)
ELSE
velocity = max(velocity, -1 * max_vel)
END IF
pos = pos + velocity
out1 = pos
END ALSO
Those variables max_accel, max_vel, and friction values are worth playing with.
Just throwing out some half-baked implementation for you.
3 Likes
Ooooh! Cool! I’ll try it right now! Thanks!
It also somehow reminded me of this :
3 Likes
New idea - Quantinuity. So it is a quantizer that tracks the distance between continuous and quantized values. For example, 0v is C4, right? So 0,01 is something that is a bit higher than C4. And our quantizer would output a quantized note and a distance, difference between input and output, in this case it would be, coincidentally, the raw signal and a quantized one. But if you think about it, the value of this “difference output” would always be 0 to whatever the scale is (I prefer the interactable quantizers), so the maximum would be something a bit short of 1v.
Why it might be interesting to the users? Well, to me it is interesting because I was thinking of a gliding melody with a couple of accentuated tones. It is not fully quantized, but it put accents on the scale notes. I can think of vcv rack implementation with a couple of modules, like this for example (quantizer mode set as “Down”, for the difference to be positive).
It is easy to do, but I wonder why I can’t find any quantizers that would do that? So I want one! Also it would be cool to have an ability to rescale/offset this output (like on the screenshot) and make it exponential or linear if needed…
**I forgot to invert Level CV, so 0 would be the loudest. Sorry! The way it presented it actually accentuates the notes half between the usual scale. Or so I think now
4 Likes
Hi! I had an idea and figured I might use this thread so it can live together with other (much wilder! haha) requests. This one goes to @CountModula and @trickyflemming. First of all, I’m super grateful for the work both of you put into Rack. I was looking into the Leibniz subsystem by Xaoc Devices today and playing with some stuff in Rack, namely Lunetta Modula’s Binary 8 and Hetrick CV’s Analog to Digital, trying to get a feel for it. I wish there was just a few more ways to scan through the different binary values in these modules (similar to what is achieved by tweaking the value knob on Binary 8; or the offset knob in Analog to Digital when nothing is patched to the input; or patching an LFO to the input of Analog to Digital). I believe adding a couple of inputs would do the job:
A. Scan input - allows you to scan through the different binary values by sending it voltage (this is already possible on the ADC modules by both Hetrick and Lunetta Modula, but I don’t know if the inputs are calibrated to go though all the 256 values in order, like the Xaoc’s stuff does);
B. Clock input - each pulse advances a single value;
C. Reset input - send it a trigger to reset the value to the first one (zero).
Anyway, I’ll just stack this onto the wishlist in case either of you decides to upgrade their module and add some extra features! In my opinion those changes would allow for very creative uses, specially when it comes to sequencing. Needless to say, these modules are already super functional and fun to use in their current state and I’m aware that my requests cover use cases which are specific to me, and not everyone. Also, I know next to nothing about coding or binaries, so thanks again for being awesome and baring with me. Bye!
Yep! Just send it a linear, unipolar ramp. This will go through the values sequentially. You can change the encoder mode to go through other counting types.
For this, I would recommend a secondary Accumulator module, which is essentially how the Erfurt functions in the Leibniz system. If you imagine the linear, ascending ramp from the previous step, Reset sets the ramp to 0.0f, while each gate received at the Clock input would increment the ramp by 1.0/255.0f;
Additionally, with the Erfurt, its input bus can change the increment amount. This, to me in my usage, ends up being maybe too complicated of a workflow since it pretty much ties up a Lipsk module if you want it to count by anything other than 1.
I think this should work perfectly:
Just set Step to 5.0/255.0 (the easy to remember 0.01960784313 
). If you want it to reset when the binary counter is full, set Trsh (Threshold) to 5.0 so that it pulses the Trig output when the HetrickCV ADC input is “full”. Then, plug the Trig output back into the ACC Reset input.
2 Likes
Hi! Thank you so much for taking the time to teach me this. Of course, it worked beautifully. 
Exactly what I needed!
1 Like
I’d been thinking that BASICally could be used for quantizing, so your suggestion spurred me to investigate it. Here’s what I have so far; while the UI leaves much to be desired, it is really flexible.
' IN1 is the input value.
' OUT1 is the quantized value.
' OUT2 is IN1 - OUT1.
' OUT3 is the absolute value of OUT2.
' NB: There is a very short (sub-millisecond) delay between when
' IN1 gets a new value and when OUT1/2/3 are updated.
' Which notes are selected is determined in the notes[] line below.
' Be sure to update notes_len with the number of entries in notes[]!
WHEN start()
' notes[] should only have values from 0 to 1.
' That's the c4-b4 octave.
notes[0] = { c4, c#4, d4, d#4, e4, f4, f#4, g4, g#4, a4, a#4, b4 }
' You MUST SET THIS to the length of notes[]!
notes_len = 12
' Setup lookup table.
' We sort notes[] first. Sort notes[] using Insertion Sort.
for i = 1 to notes_len - 1
x = notes[i]
j = i - 1
IF notes[j] > x THEN ' Makes already sorted array bit faster.
' A WHILE loop for a language that doesn't have one.
FOR while = 0 TO 1 STEP 0
IF j < 0 OR notes[j] <= x THEN
EXIT FOR
END IF
notes[j + 1] = notes[j]
j = j - 1
NEXT
notes[j + 1] = x
END IF
NEXT
' Now create an array of range end points.
' One wrinkle is that the input value will always be 0 <= x < 1.
end_range = 0
range_start = (notes[notes_len - 1] - 1 + notes[0]) / 2
if range_start < 0 THEN ' Need to add this to the end.
end_range = range_start + 1
end_value = notes[0] + 1
END IF
range[0] = 0
FOR i = 1 TO notes_len - 1
range[i] = (notes[i - 1] + notes[i]) / 2
value[i - 1] = notes[i - 1]
NEXT
range[notes_len] = (notes[0] + 1 + notes[notes_len - 1]) / 2
value[notes_len - 1] = notes[notes_len - 1]
IF end_range THEN
range[notes_len + 1] = 1
value[notes_len] = end_value
range_len = notes_len + 1
ELSE
range_len = notes_len
END IF
prev_in = -111 ' A value IN1 will likely not be on start.
END WHEN
ALSO
IF prev_in != IN1 THEN ' Must recompute.
' Need to preserve IN1, since might change while in FOR loop.
new_in = IN1
octave = floor(abs(new_in))
part = mod(abs(new_in), 1)
FOR k = 0 TO notes_len
if range[k] <= part AND range[k+1] > part THEN
' Found it!
prev_in = new_in
if new_in == 0 THEN
OUT1 = value[k] + octave
ELSE
OUT1 = (value[k] + octave) * sign(new_in)
END IF
OUT2 = new_in - OUT1
OUT3 = abs(OUT2)
EXIT FOR
END IF
NEXT
END IF
END ALSO
Note several somewhat unusual features:
- You don’t need to use actual well-tempered notes. You could tweak the values as you wish, for example, let’s do a minor chord, but make that minor 3rd a little sharp.
notes[0] = { c4, eb4 + 0.03, g4}
- You are not limited to a mere 12 notes. Agree with Harry Partch that there could be 43 notes per octave? Go for it!
- They don’t have to be notes at all. You can just pick values for numbers you like. Quantize the inputs to things besides V/Oct.
notes[0] = { 0.1, 0.333, 0.7, 0.987}
- And of course, it has the distance-from-input outputs that you suggested.
This has gotten me thinking about quantization a lot, so I expect that at some point there will be a couple presets in BASICally as a result of this suggestion. So thanks for that!
Comparing my results to those of other quantizers in VCV made me see that there are several ways to quantize; this one just moves to the numerically nearest available value.
Enjoy.
3 Likes
Mmmm, this code is not correct. It does not treat negative inputs correctly; I thought I had it right, but I definitely don’t.
1 Like
quantizers are hard. The few times I’ve made them I had a lot of issues. and a ton of unit tests to make sure they really did what I wanted…
1 Like
I ran a little test couple of days ago, it seemed fine! One problem was that there’s no scaling to the output, so I had to use three Bogaudio scale modules to rise it up to usable numbers…I think it would be cool to have knobs on Basically for that reason. Of course, you can just connect some kind of sequencer ofr offset to the inputs or you can just write it into the code, but it would be a bit more convenient to have it on the panel, I think…
Another thing! I remember I had this idea about Euclidean quantizer. It acts like an euclidean sequencer, but it quantizes the voltage instead of, you know, producing the triggers or gates. I think Basically should be fine with this… But I don’t have time to think about it for now. SO I’ll push it to you if you feel interested in this experiment, haha.
There is an expander to Quad Algorithmic Rhythm that does a lot of this
4 Likes
I’ll take a look at that, cheers for the heads up
Edit: took a look, but nothing really stood out. There is one of the Frozen Wasteland units that intrigued me though, Filling Station. Never seen that before and maybe that could be adapted to do what I’m thinking of.
I don’t want to be that guy that turns every post into some kind of self promotion, but anyway, I think that my Frozen Wasteland - Probably Note (Math Nerds) which lets you you use a lot of techniques including Euclidean Rhythms to generate scales might pique your interest
2 Likes
ah ok,I missed it in the help file here
because the screenshot of the module didn’t load for me. Either way even though it may do some of what I want the description seems pretty opaque, will have to play with it to get an understanding of what it does.
I feel seen. Mea Culpa.