I want to reduce the linearity of a triangle wave by reducing the bit-depth of the amplitude, basically make it into a fine, triangle-shaped step-function. I'm trying to think of what would be the best way (least CPU work) to achieve this?

I suppose the most direct approach would be to convert from digital to a low-resolution (like 8-bit or even 4-bit low) analog approximation, but is that possible in PD?

Could I somehow get the triangle into a table, and then use tabwrite~ (or tabosc4~?) to create another table that is incremented at the same rate (hopefully real-time), but the amplitude values written to the new table are only updated on every n-th sample of the input? I'm a little confused on the differences between the various table objects... I know I need to do some more reading, but I'm hoping someone may have a quick answer for me

my quick answer,

[tri~] [phasor~]
| /
[samphold~]

where, [tri~] is whatever you are using to generate your triangle wave,

and the rate of [phasor~] is the sample rate. [phasor~ 44100] should give you cd quality, whereas [phasor~ 100] will step every 10ms..

no...ignore that, it doesn't work how i hoped.

if you want to use an external, then [decimate~] will do exactly what you want

@hardoff said:

my quick answer,

[tri~] [phasor~]
| /
[samphold~]

Thats almost it Hardoff, the phasor must be synchronous with the triangle, so best trick is to do this

[phasor~ x]
| \
| \
| [*~ 8] <- vary quantisation here
| [wrap~]
| |
[samphold~]

Then derive the triangle from the quantised phasor using the usual methods

http://www.pdpatchrepo.info/hurleur/quantised-triangle.pd

Thanks guys, I'm gonna check this out. I'll still need to look back to Ch 2 or 3 of Puckette's book so I'll better understand what I'm doing, but that is the kind of lead I was looking for!

I had another thought for a quick & dirty way, I'm not gonna test it out because I should already have all I need from above, but I'm still curious:
What if I scaled my triangle up (by a factor proportional to the desired de-res factor), and passed it through [int] to get a roughly-triangular floor function? I know that wouldn't work since [int] takes a control input, but suppose I make my own [int~]? Would this be too slow, regardless of my truncating algorithm?

i thought about syncing it, but the problem with that is that your bitrate will change depending on the frequency of the original phasor~

i guess you could add some scaling factor if you needed a regular bitrate.

I've been playing around with this. There were some nasty partials that I took out with a key-following [lop~], and tuning the cutoff more precisely I can get the sound I'm looking for (the Nintendo 2A03's triangle wave with its metallic groan at bass frequencies).

One thing I noticed was that the sound would "break" past 2757 Hz, which I noticed was about 1/16 of the 44.1k sampling rate. I realized it was due to the multiplied phasor (set to 16 at the time) trying to generate a signal faster than the sampling rate. If I adjusted multiplier down to 8 or 4, then I could sweep up to 1/8 or 1/4 of the sampling rate before getting breakup. If there's no easy way around this I can probably use a "real" triangle with different filtering as a second voice to get the higher ranges.

The other thing I've noticed is that if I sweep the fund. frequency in mid or high ranges (at any multiplier setting) there's a noticeable "waw" like when you tune an old radio, I'm not sure what that is or how to get rid of it. I've often heard it on old arcade sound devices, but the 2A03 didn't do this. Could it be foldover from the multiplied phasor generating over the nyquist frequency?

yeah, that was the problem with my initial suggestion...the nyquist thing...

i just tried your idea:

>>What if I scaled my triangle up (by a factor proportional to the desired de-res factor), and passed it through [int] to get a roughly-triangular floor function? I know that wouldn't work since [int] takes a control input, but suppose I make my own [int~]? Would this be too slow, regardless of my truncating algorithm?<<

easiest way i could think of was with the zexy [>~ ] object...like this:

[*~ 8]
|
[>~ 1] [>~2].......[>~ 7]
|
[/~ 8]

with patch cords going from the [*~ 8] into every [>~ ] object, and then patch cords coming out of every [>~ ] object, into the [/~ 8]

this sounds nice and lofi, and avoids any nyquist problems.