hello all!
i would like to create a delay effect that would take an input and would delay it, gradually decreasing its delay time (like a bouncing ball). the volume should stay constant if possible, and the number of repeats controllable... how would one go about doing this?

thank you in advance
shpeck

sounds more like a stutter effect than a delay!? use the search function keyword "stutter", i'm sure, you will get a lot of hits.

If you'd like to get a bouncing ball timing then start out with an initial time and then for every "bounce" divide that time by the next number in the Fibonacci sequence.

Example: Start with 500ms
Fibonacci: 1,1,2,3,5,8,13,21...

timings: 500, 500, 250, 166.67, 100, 62.5, 38.46, 23.81...

good idea, saturno. for those who are interested, i built a little patch in when i began with pd for generating fibonacci sequence.

http://www.pdpatchrepo.info/hurleur/fibonacci.pd

I did something once with [bonk] and a line on the delay time

Here's a version that doesn't use recursion, based on Binet's formula
http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html

You give it N and it returns you the Fibonacci number in the Nth place

http://www.pdpatchrepo.info/hurleur/fibo.pd

Mr. Shpeck, you want to "control the number of delays" - what are you thinking of, like '1-2-3-4-5-6-nomore' ? Also do you mean that with a lesser number of repeats they would be closer to each other?
I wonder if Fibonacci numbers would do in that case, it would need to be a curve that changes according to the number of repeats, like if the 'weight' of the object bouncing is different from case to case...
I find this intriguing. And I remember a very very old demo patch on supercollider that did that with a 2-liner. But there were no changes in speed etc.
Toxonic, how do you invert your fibo numbers? or in a patch like this, would you use the numbers for a progression of a devisor?

If you'd like to actually do the physical modeling and use the spring constant as your parameter than you'd have to implement something around Hooke's Law. http://en.wikipedia.org/wiki/Hooke%27s_law

But it turns out that intervals between the bounces is inversely proportional to the Fibonacci sequence. Just choose an initial time between the first and second bounce and then divide that number by the Fibonacci sequence to get the rest of the bounces. Start at the second number in the sequence so that it goes 1,2,3,5,8,13...

Computationally far easier to do but in this case the parameter is the initial bounce instead of the spring constant. In music I also prefer it this way since I like to specify the length of the first interval.

If you'd like to actually model the sound and not just the timing of the bouncing ball than you also have to lower the volume as well as add an attenuation at the higher frequencies proportional to the Fibonacci sequence.

In PD I wouldn't implement this with delread~, instead I would use an Array, saving the sound there and then triggering a tabplay~ according to the calculated timings.

Here's a patch I did years ago that models a bouncing ball. It's been too long and can barely remember the math behind.

The first inlet is the bounce index, which bounce is this? Usually start with 1 and then count up incrementally. (1,2,3,4,5,6...)

The second inlet is the spring constant, though I'm not sure of this. Give it a value that is less 1 to simulate a realistic bounce. If you give it 1 it'll stay fixed at the same time interval. A value greater than one will give it an unreal bounce. One in which the ball keeps bouncing higher and higher.

The third inlet is the starting height in meters.'

The outlet is the interval between bounces in MS.

To make this work use a [counter] object to feed the first inlet. Hook up its outlet to a [del] object. Make sure to use a [moses] to terminate the simulation at some small time interval, like 2.

Check out help-pmBounce

http://www.pdpatchrepo.info/hurleur/pmBounce.zip

Sounds like you want a delay where the delay time and the gain decreases as it goes on. Can't you just modulate these values by some simple functions?

Plot exp(-x) * sin(x^2) to see what I mean.. or else you could just try modelling an actual ball, but the solutions are essentially that function.