Gary Lee Nelson

Does anyone use accum? One of my students found it and used in his first

patch. It doesn't seem to do what I expected and the help and manual don't

Does anyone use accum?  One of my students found it and used in his first
patch.  It doesn't seem to do what I expected and the help and manual don't
help or man...Is it me or is funky?

Cheers
Gary Lee Nelson
Oberlin College
www.timara.oberlin.edu/GaryLeeNelson

accum

it's a pretty basic object. it's cleaner than using a bunch of [int] and [+] and [*] objects.

try opening the help patch on it. send a value into the left inlet, and that will set (and output) the "initial value" stored in the accum object. then, send a value into the middle inlet. that value will be added to the "initial value", and then that sum will be stored as the "current value". however, nothing is output until it receives a bang in its left inlet. similarly, values sent into the right inlet will multiply the current value.

if your confusion comes from the fact that nothing is output when the object's value changes, then try using a [t b i] object to trigger a bang to the left inlet whenever a value is sent to the middle or right inlets.

it's a pretty basic object.  it's cleaner than using a bunch of [int] and [+] and [*] objects.  

try opening the help patch on it.  send a value into the left inlet, and that will set (and output) the "initial value" stored in the accum object.  then, send a value into the middle inlet.  that value will be added to the "initial value", and then that sum will be stored as the "current value".  however, nothing is output until it receives a bang in its left inlet.  similarly, values sent into the right inlet will multiply the current value.

I've used it a few times. It's like a very odd counter. The trick is 

you have to always send a value to the center inlet (the amount you 

want to add to the "accumulation", then bang the left inlet to get 

On Feb 22, 2007, at 3:31 PM, Gary Lee Nelson wrote:

> Does anyone use accum? One of my students found it and used in his 

> patch. It doesn't seem to do what I expected and the help and 

I've used it a few times. It's like a very odd counter. The trick is  
you have to always send a value to the center inlet (the amount you  
want to add to the "accumulation", then bang the left inlet to get  
the result. e.g.

> Does anyone use accum?  One of my students found it and used in his  
> first
> patch.  It doesn't seem to do what I expected and the help and  
> manual don't
> help or man...Is it me or is funky?
>
> Cheers
> Gary Lee Nelson
> Oberlin College
> www.timara.oberlin.edu/GaryLeeNelson
>
>


Ah, then it IS funky! The manual should say in big red letters that, unlike

all other max objects inputs to the right must happen before action at the

left-most inlet causes output. I learn once again that blind faith is

> it's a pretty basic object. it's cleaner than using a bunch of [int] and [+]

> try opening the help patch on it. send a value into the left inlet, and that

> will set (and output) the "initial value" stored in the accum object. then,

> send a value into the middle inlet. that value will be added to the "initial

> value", and then that sum will be stored as the "current value". however,

> nothing is output until it receives a bang in its left inlet. similarly,

> values sent into the right inlet will multiply the current value.

> if your confusion comes from the fact that nothing is output when the object's

> value changes, then try using a [t b i] object to trigger a bang to the left

> inlet whenever a value is sent to the middle or right inlets.

Ah, then it IS funky!  The manual should say in big red letters that, unlike
all other max objects inputs to the right must happen before action at the
left-most inlet causes output.  I learn once again that blind faith is
dangerous.  :-)

>
> it's a pretty basic object.  it's cleaner than using a bunch of [int] and [+]
> and [*] objects. 
>
> try opening the help patch on it.  send a value into the left inlet, and that
> will set (and output) the "initial value" stored in the accum object.  then,
> send a value into the middle inlet.  that value will be added to the "initial
> value", and then that sum will be stored as the "current value".  however,
> nothing is output until it receives a bang in its left inlet.  similarly,
> values sent into the right inlet will multiply the current value.
>
> if your confusion comes from the fact that nothing is output when the object's
> value changes, then try using a [t b i] object to trigger a bang to the left
> inlet whenever a value is sent to the middle or right inlets.
>
> -scott

OK OK there must have been some copypaste mistake from me ;-)

Here is the real thing (makes more sense) :

At 8:21 PM +0200 4/1/07, raphael seguin wrote:

>gimmee back my patchcords you thiefs !!!

OK, that _is_ strange. It seems like accum, after a certain point, refuses to acknowledge any number less than 16. (in your example it comes after processing step 31)

Here's your patch set up for single stepping with a bunch of debugging stuff scattered around. This version runs until the accum number and the + number are different. You notice that once it breaks (at step 31) accum is a little wacky. You can bang in numbers < 17 with no output, but numbers >= 17 cause output, as normal.

Chris Muir | "There are many futures and only one status quo.

cbm@well.com | This is why conservatives mostly agree,

 | and radicals always argue." - Brian Eno

At 8:21 PM +0200 4/1/07, raphael seguin wrote:
>gimmee back my patchcords you thiefs !!!

-- 
Chris Muir           | "There are many futures and only one status quo.
cbm@well.com         |  This is why conservatives mostly agree,
http://www.xfade.com |  and radicals always argue." - Brian Eno


Accum