Additional helper functions

[capital-G]

quoting

I think the most useful gen~ objects are: phasor, noise, cycle, accum, clip, wrap, fold, max, latch, delta, mix, switch, selector and peek and poke with variable Interpolation.

Name	EEL2?	Comment
phasor	-	A non-bandlimited sawtooth-waveform signal generator which can be used as LFO audio signal or a sample-accurate timing/control signal.
noise	rand(x) -- returns a psuedorandom number between 0 and the parameter.
cycle	-	An interpolating oscillator that reads repeatedly through one cycle of a sine wave. By default it is driven by a frequency input, but if the @index attribute is set to 'phase', it can be driven by a phase input instead.
accum	+=	The object adds to, and then outputs, an internal sum. This occurs at sample-rate, so the sum can grow very large, very fast. The value to be added is specified by either the first inlet or argument. The internal sum can be reset to the minimum by sending a nonzero value to the right-most inlet. The minimum value is 0 by default, but can be changed with the @min attribute. An optional maximum value can be specified with the @max attribute; values will wrap at the maximum.
clip	-	Implemented in 0.3.0
wrap	-	Implemented in 0.3.0
fold	-	Implemented in 0.3.0
max	max	-
latch	if ?	Conditionally passes or holds input. The first inlet is the 'input' and the second inlet is the 'control'. When the control is non-zero, the input value is passed through. When the control is zero, the previous input value is output. It can be used to periodically sample & hold a source signal with a simpler trigger logic than the sah operator.
delta	delta = newX - x (?)	Returns the difference between the current and previous input.
mix	-	implemented via lin in 0.3.0
switch	in0 > 0.5 ? in1 : in2	-
selector	-	-
peek	bufRead	Read values from a data/buffer object. The first argument should be a name of a data or buffer object in the gen patcher. The second argument specifies the number of output channels. The first inlet specifes a sample index to read (no interpolation); indices out of range return zero. The last inlet specifies a channel offset (default 0).
poke	bufWrite	Write values into a data/buffer object. The first argument should be a name of a data or buffer object in the gen patcher. The second argument (or third inlet if omitted) specifies which channel to use. The first inlet specifies a value to write, while the second inlet specifies the sample index within the data/buffer. If the index is out of range, no value is written.
counter	-	Accumulates and outputs a stored count, similarly to Max's counter object, but triggered at sample-rate. The amount to accumulate per sample is set by the first input (incr). The count can be reset by a non-zero value in the second input (reset). The third inlet (max) sets a maximum value; the counter will wrap if it reaches this value. However if the maximum value is set to 0 (the default), the counter will assume no limit and count indefinitely. The first outlet outputs the current count, the second outlet outputs 1 when the count wraps at the maximum and zero otherwise, and the third outlet outputs the number of wraps (the carry count).
gate	-	Similar to the MSP gate~ object. It takes an argument for number of outputs (one is the default) and lets you choose which the incoming signal (at the right inlet) is sent to according to the (integer) value in the left inlet. A value of zero or less to the left inlet will choose no output; a value greater than the number of outlets will select the last outlet. Like gate~, un-selected outlets will send zero.

https://docs.cycling74.com/userguide/gen/gen~_operators/ and https://docs.cycling74.com/userguide/gen/gen_common_operators/ seems like a good resource for ideas

[capital-G]

Additional resource for gen https://github.com/electro-smith/oopsy/blob/main/source/gen_dsp/genlib_ops.h => problems w/ license, don't use it as a source

[bladelore]

I would also add scale, round and DCBlock. I also think sampstoms and mstosamps are useful convenience functions but easy enough to roll our own.

just fyi, peek and poke have quite a lot of methods in their interface. To me the most useful parts of peek and poke (that differ from normal buffer indexing anyway) is the interpolation mode for peek when reading back with float values.. (from reference)

Specify the interpolation mode: "none" and "step" perform no interpolation, 
"linear" performs two-point linear interpolation, 
"cosine" performs two-point cosine interpolation, 
"cubic" performs four-point cubic interpolation, 
"spline" performs four-point Catmull-Rom spline interpolation, 
and "spline6" performs six-point (5th order) B-spline interpolation..

and the overdub mode on poke

How overdubbing is applied: "mix" crossfades between current and new sample according to the overdub factor, "accum" scales the new sample by the overdub factor and adds it to the current sample. Possible values:

0 = 'accum'
1 = 'mix'

[bladelore]

It would also be cool to think of some new functions that aren't directly inspired by gen!

[dietcv]

mix is linear interpolation between two inputs where the mix factor is between 0 and 1.

inline float lerp(float a, float b, float t) {
    return a + t * (b - a);
}

inline float cosineInterp(float a, float b, float t) {
    float mu2 = (1.0f - std::cos(t * PI)) / 2.0f;
    return a * (1.0f - mu2) + b * mu2;
}

[dietcv]

and cubic interpolation from the plugin interface:
https://github.com/supercollider/supercollider/blob/develop/include/plugin_interface/SC_SndBuf.h

inline float cubicinterp(float x, float y0, float y1, float y2, float y3) {
    // 4-point, 3rd-order Hermite (x-form)
    float c0 = y1;
    float c1 = 0.5f * (y2 - y0);
    float c2 = y0 - 2.5f * y1 + 2.f * y2 - 0.5f * y3;
    float c3 = 0.5f * (y3 - y0) + 1.5f * (y1 - y2);

    return ((c3 * x + c2) * x + c1) * x + c0;
}

[dietcv]

bipolar noise could be implemented with frand2 from the plugin interface:
https://github.com/supercollider/supercollider/blob/develop/include/plugin_interface/SC_RGen.h

/// Generate a float from -1.0 to +0.999...
inline float RGen::frand2() {
    union {
        uint32 i;
        float f;
    } u; // union for floating point conversion of result
    u.i = 0x40000000 | (trand() >> 9);
    return u.f - 3.f;
}

[dietcv]

accum is a sample counter with reset, similiar to Sweep running at samplerate or my RampAccumulator Ugen, here is the struct:

struct RampAccumulator {
    double m_sampleCount{0.0};
    bool m_hasTriggered{false};
   
    float process(bool trigger, float subSampleOffset) {
        // 1. Handle trigger - reset sample count with subsample offset
        if (trigger) {
            m_sampleCount = subSampleOffset;
            m_hasTriggered = true;
        }
       
        // 2. Output current count
        float output = 0.0f;
        if (m_hasTriggered) {
            output = static_cast<float>(m_sampleCount);
        }
   
        // 3. Increment sample count
        m_sampleCount++;
   
        return output;
    }
   
    void reset() {
        m_sampleCount = 0.0;
        m_hasTriggered = false;
    }
};

[dietcv]

sorry for the spam, if the buffer has a power-of-2 size one can use bitwise wrapping which is faster then using sc_wrap by providing a mask

// Fast no-interpolation peek with bitwise wrapping - (for power-of-2 sizes)
inline float peekNoInterp(const float* buffer, int index, int mask) {
    const int wrappedIndex = index & mask;
    return buffer[wrappedIndex];
}

// Fast linear interpolation peek with bitwise wrapping - (for power-of-2 sizes)
inline float peekLinearInterp(const float* buffer, float phase, int mask) {

    const int intPart = static_cast<int>(phase);
    const float fracPart = phase - static_cast<float>(intPart);
    
    const int idx1 = intPart & mask;
    const int idx2 = (intPart + 1) & mask;
    
    const float a = buffer[idx1];
    const float b = buffer[idx2];
    
    return lerp(a, b, fracPart);
}

// Fast cubic interpolation peek with bitwise wrapping - (for power-of-2 sizes)
inline float peekCubicInterp(const float* buffer, float phase, int mask) {
    const int intPart = static_cast<int>(phase);
    const float fracPart = phase - static_cast<float>(intPart);
    
    const int idx0 = (intPart - 1) & mask;
    const int idx1 = intPart & mask;
    const int idx2 = (intPart + 1) & mask;
    const int idx3 = (intPart + 2) & mask;
    
    const float a = buffer[idx0];
    const float b = buffer[idx1];
    const float c = buffer[idx2];
    const float d = buffer[idx3];
    
    return cubicinterp(fracPart, a, b, c, d);
}

[dietcv]

ceil, floor and sign which is used for change (delta into sign) and frac which is wrapping between 0 and 1 can be found here:
https://github.com/supercollider/supercollider/blob/develop/include/plugin_interface/SC_InlineUnaryOp.h

Here you can find sc_clip, sc_fold, sc_wrap, sc_round etc.
https://github.com/supercollider/supercollider/blob/develop/include/plugin_interface/SC_InlineBinaryOp.h

Here you can find sc_abs, sc_min and sc_max:
https://github.com/supercollider/supercollider/blob/develop/include/common/SC_BoundsMacros.h

[capital-G]

Thanks for the collection, highly appreciated!

accum is a sample counter with reset, similiar to Sweep running at samplerate or my RampAccumulator Ugen, here is the struct:

This is a bit more difficult since it is an impure function.
I have to look more into EEL2 how one could make this work, but I think it is possible w/ hijacking of the process function(?) The rest shouldn't be too hard :)

[dietcv]

I would also add min, abs, round and gate to the list.

[capital-G]

I would also add min, abs, round and gate to the list.

min, abs and round are already part of the eel2 implementation, see https://www.cockos.com/EEL2/

I added gate to the list

[dietcv]

In my opinion no Interpolation, linear Interpolation, cosine Interpolation and SCs cubic Interpolation which is a 3rd order hermite spline with catmull-rom tangents are sufficient Interpolation options for peek (so more or less what SC users already know from Ugens like BufRd). The b-spline doesnt go through actual points. Splines in general have a problem with overshooting for steep tangents, the LFDNoise ugens therefore scale the amplitude by the magic number of 0.8.

[dietcv]

What would be beyond gen~ just because @bladelore mentioned that, is to additionally implement an integrator. Integration and Accumulation are different. An accumulator is just counting samples which are added to a running total and you can scale that by multiplying with a static value, while an integrator takes a current dynamic value and adds it to a running total. For some context, an integrator enables FM, while an accumulator does not. I have already shared RampAccumulator from my ugens here is RampIntegrator. Im pretty sure these are not the best implementations just wanted to point out the difference.

struct RampIntegrator {
    double m_phase{0.0};
    bool m_hasTriggered{false};
    
    float process(bool trigger, float rate, float subSampleOffset, float sampleRate) {

        // 1. Calculate slope from rate
        double slope = rate / sampleRate;
        
        // 2. Handle trigger - reset phase with subsample offset
        if (trigger) {
            m_phase = slope * subSampleOffset;
            m_hasTriggered = true;
        }
        
        // 3. Output current phase
        float output = 0.0f;
        if (m_hasTriggered) {
            output = sc_frac(static_cast<float>(m_phase));
        }
    
        // 4. Increment phase
        m_phase += slope;
    
        return output;
    }
    
    void reset() {
        m_phase = 0.0;
        m_hasTriggered = false;
    }
};