[PD] Do these sound familiar??

[Michael McGonagle]

Hello all,

Over the past couple of months, I have developed a few externals, but
now that I am ready to release them, I was wondering if any of these
sound familiar. There are a set of externals that are based on some
functions from a program called CMask (a stochastic CSound score
generator). I will give the names for my externals, with a short
synopsis of what they do. If any of them sound familiar, I would
appreciate any insight you might offer, and where I might find the
similar externals...


**************************
'mask'
     - inlets: signal, map, low, high
     - outlet: scaled_signal

'signal' is expected to be within the range of 0..1 (inclusive).
'map' controls how the signal is "warped" prior to scaling [either
square root, or power].
'low' and 'high' mark the range to which the output is scaled.


this maps the signal, and then scales the value to the output range.


**************************
'quantize'
     - inlets: signal, grid, strength, offset
     - outlet: quantized_signal

'signal' input to process (in any range).
'grid' is the quantization value.
'strength' is the amount of quantization to apply.
'offset' is added to the signal.


quantizes the input signal to the grid with the amount of quantization
controlled by strength, and then applies the offset


**************************
'accum'
     - inlets: signal, mode, init, low, high
     - outlet: signal

'signal' input to process (in any range).
'mode' controls how the accumulator operates.
'init' the initial value for the accumulator
'low' the low end of the accumulators range.
'high' the high end...


keeps an internal state by adding the input signal to the previous
value. the modes available are limit [forces a state to stay within the
     low/high range]; mirror [state is 'reflected' back within the low/high
range]; the 'accum' external also responses to a 'reset' message which
is used to set the state back to its initial value.

**************************
'cbuffer'
     - inlets: signal, flow-control
     - outlet(s): signal (X number of outputs), not-filled

'signal' input to track
'flow-control' a spigot-like flag, stops output action (see note)


for each input value, the value is added to the 'circular buffer'. upon
initializing (or resetting) the buffer, it will be in an unfilled state.
in this state, for each input, there will be an output bang on the
right-most output. This flag can be used to trigger code that is used to
generate the next value in the stream. Once the buffer is filled, output
will be generated for each input value, while the 'flow-control' flag is
NOT 0 (zero).

(Question: would it be better to have one output list with all the
values in that list?)


**************************
'ranger'
    - inlets: signal
    - outlets: scaled-signal, low-difference, high-difference


as a signal is input to a 'ranger', the highest and lowest values are
stored, and used to scale the signal to a range of 0..1 (inclusive). a
'ranger' also responds to a 'reset' message, effectively setting the
lowest and highest state values to opposite maximum possible value.

(Question: while I have created this to track how much the range changes
    [and not the actual values for the highest and lowest], would it be
good to offer an option to have one or the other?? Currently, I use the
'difference' to watch how fast a fractal data set expands as it
iterates, but I can also see uses for having the actual low.)


**************************
'inverter'
    - inlets: signal, toggle
    - outlet: signal

if 'toggle' is NOT 0 (zero), the signal (expected to be in the range of
0..1 [inclusive]) is inverted (out = -(signal - 1.0))





I appreciate your review of these things, and look forward to reading
any comments.

Thanks,

Mike