Hey all
When doing calculations on a large set of numbers, it's for obvious reasons much faster to do with tilde objects than doing it in message domain with some until loop. Doing calculations on an array with dsp objects has the disadvantage that they're tied to sampling rate and cannot be done instantaneously. So I'm asking myself if there is a way to eat my cake and have it, too, i. e. exploit the efficiency of tilde classes while retaining control of execution time.
I know about the trick of up-sampling a subpatch so that you get _faster_ results, but it doesn't enable you to get the results in 0 logical time.
Is "0 logical time" and "good efficiency" at the same time possible somehow?
Roman
Le 19/10/2016 à 10:30, Roman Haefeli a écrit :
Hey all
When doing calculations on a large set of numbers, it's for obvious reasons much faster to do with tilde objects than doing it in message domain with some until loop. Doing calculations on an array with dsp objects has the disadvantage that they're tied to sampling rate and cannot be done instantaneously. So I'm asking myself if there is a way to eat my cake and have it, too, i. e. exploit the efficiency of tilde classes while retaining control of execution time.
I know about the trick of up-sampling a subpatch so that you get _faster_ results, but it doesn't enable you to get the results in 0 logical time.
Is "0 logical time" and "good efficiency" at the same time possible somehow?
you almost found the solution.
you need to use the bang feature of the block~ object to compute one (huge) block in 0 logical time. cheers c
Roman
Pd-list@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.puredata.info/listinfo/pd-list
On Wed, 2016-10-19 at 10:42 +0200, cyrille henry wrote:
Le 19/10/2016 à 10:30, Roman Haefeli a écrit :
Hey all
When doing calculations on a large set of numbers, it's for obvious reasons much faster to do with tilde objects than doing it in message domain with some until loop. Doing calculations on an array with dsp objects has the disadvantage that they're tied to sampling rate and cannot be done instantaneously. So I'm asking myself if there is a way to eat my cake and have it, too, i. e. exploit the efficiency of tilde classes while retaining control of execution time.
I know about the trick of up-sampling a subpatch so that you get _faster_ results, but it doesn't enable you to get the results in 0 logical time.
Is "0 logical time" and "good efficiency" at the same time possible somehow?
you almost found the solution.
you need to use the bang feature of the block~ object to compute one (huge) block in 0 logical time. cheers c
Oh, sweet. I'm going to try that. Thanks a lot.
Roman
On Wed, 2016-10-19 at 10:42 +0200, cyrille henry wrote:
Is "0 logical time" and "good efficiency" at the same time possible somehow?
you almost found the solution.
you need to use the bang feature of the block~ object to compute one (huge) block in 0 logical time.
It seems it works with [switch~], not with [block~] and it's even described in block~-help.pd. It's an invaluably valuable feature. Thanks again!
Roman
-
cyrille henry -
Roman Haefeli