Mike:
Definitely worth documenting!
Maybe even include your example.

I had more in mind lazy evaluation so that the pre- and postfix timing was still respected, but that the actual operation was performed by the in-place operator.

C doesn't have an 'ans' variable and Matlab doesn't have '++'/'--' operators so there is no compatibility requirements that say we couldn't make these operators do somethin special, like not return the ans variable.

But I'm also not too bothered if we just want to document the difference.

IMHO redoing the ++ and -- operators to be the same thing as +=1 and -=1 would not be a good thing and would break some behavior. The ++ and -- operators currently mimic the C prefix and postfix behavior, which to me is a good and intentional thing worth keeping.

Specifically, the following postfix behavior would change

>> x = 1;
>> y = x++;
x, y
x =  2
y =  1
>> x = 1;
>> y = (x += 1);
x, y
x =  2
y =  2

I think it would be better to fully document the differences, that "X += 1" only affects X, while "X++" affects X and also returns a copy of the previous value of X as a side effect, which may take up a lot of memory depending on the size of X.

Another possibiliy would be to make the ++ and -- operators be syntatic sugar for += 1 and -= 1.  Currently I believe they are recognized by the parser and mapped on to their own operators.

I re-titled the bug report, but yes, this is ordinary and expected Octave behavior.  Whenever you execute an operation, for which no variable is assigned, then the default variable 'ans' gets the output.

The easy workaround, as mentioned, is to use assignment so that 'ans' is not created.  Alternatively, you could look at using a different algorithm that doesn't use so much memory.  If your matrices are large, but mostly 0 elements, then use sparse arrays.  And as a last resort, just run on a machine with more memory.

Actually, for maximal performance use

A += 1
OR
A -= 1

In-place operators have been optimized so that a second copy is never created.  Even

A = A + 1

is not guaranteed not to create a temporary matrix.  Octave may, and most likely will, do

tmp = A + 1;
A = tmp;

for "A = A + 1".

The increment and decrement operators should map on to the in-place operators, but they don't yet.

I'm lowering the severity because there is a simple work-around of using += or -= operators.