While working on MIDI looping, I'm revisiting what has been without question
the most confusing and contentious looping function there is: Multiply

The original Mobius implementation of Multiply was an attempt to make Multiply
behave the way I expected it to, while at the same time allowing through parameters
to behave like the EDP. It ended up doing neither of them very well.

Part of the problem is that EDP Multiply does lots of things: it can make the loop
larger. It can make it smaller. It can change the start and end points. It can
change the tempo. It has complicated implications about where it starts and stops
and what "rounding" means.

What it does is no doubt musically useful, but it is not the only way to think
about Multiply, and certainlly not what I want most of the time.

If you're not comming from an EDP mindset, I'm curious, what do you think
Multiply does?

My goal was never to replicate the EDP, but rather to provide a collection
of fundamental operations you could combine to perform whatever the hell
it is the EDP does. I failed of course, but let's fix that.

I'm working on a much longer paper around this, but I'd like to kick off discussion
for those interested by focusing on a few basic things.

the difference between loop time and loop content
the significance of the starting and ending events

I think there is general agreement that when you make the loop bigger you usually
want that to be with a unit of time that preserves the percieved tempo of the loop
and synchronization with other things. That has been called the "cycle" but you
can think of it as a "bar" or "measure" or whatever. It doesn't matter what the cycle
means to you, the time needs to make rythmic sense in the resulting loop. I don't
want to veer off into chaos looping yet, for me and I expect the majority of users,
I'm making loops that synchronize with something.

When you make a loop longer, what is in that cycle/bar/measure? That's another
complicated issue I don't want to explore right now, let's just focus on time.
They are independent.

Now, how do you ask for the loop to be extended? Multiply is (normally) a "modal"
function, it has a start and an end and you have to press a button twice. While
it is active you are in Multiply Mode.

Perhaps the biggest difference between Mobius and the EDP is the significance
of WHEN you press those two buttons. My original implementation, which everyone
seemed to hate was this:

- Multiply Mode starts when you press Multiply and it behaves like Overdub
- A new cycle is added ONLY IF you allow the loop to reach the endpoint
- If you end multiply early, before the end of the loop, it keeps whatever
  the current length is

Call this "Simple Extension" mode. Cycles are added as they are necessary to
keep the Multiply going, but not after it ends. Consider this highly sophisticated
diagram where "-" represents the loop and "^" represents the pressing of the Multiply
button.

     ----------------------
       ^               ^

In this case Multiply behaves exactly like Overdub. You ended the multiply before
we reached the loop end so it was not necessary to add a cycle. In the next
example we'll let it run beyond the end:

     ----------------------|----------------------
                ^                            ^

Because you let Multiply continue past the loop point, another cycle was added.
Then you end the multiply toward the end of the second cycle, and we're done.
You have a loop with two cycles.

That is the behavior I expected. Let me know what you expected.

I ask because from everything I've gathered over the years (and I could certainly
be wrong), this is NOT how the EDP works. The EDP injects new cycles relative
to where you were when that first button was pressed. Something like this:

     ----------------------|----------------------
                ^                            ^             
                ++++++++++++++++++++++|++++++++++++++++++

Since that second button press was beyond that first added cycle, it rounds
off and adds another one. Since the second start-relative cycle was beyond the
loop length, you end up with this:

     -----------++++++++|+++++++++++++++|++++++----------

This coincidentally is how Insert would also behave, but that I expect since Insert is sticking new content into the middle of an existing loop. But Multiply is merging so I do not expect that extra cycle tacked
on the end just because I wasn't careful about the timing of the start/end buttons.

EDP users, please correct me if I'm wrong about this. I'd love to be, but past discussions seem to indicate that Multiply Mode extensions are relative to the start of the Multiply function, not the start of the cycle
that contained the Multiply function. Which is consistent with Insert.

Well, that's enough for now....