arithmetic

Signed arithmetic avoids unintended consequences for comparisons and arithmetic, and enables better loop optimizations by the compiler.

A key difference is whether the type is meant to be an index (counting) or for arithmetic.

Using signed arithmetic is already suspicious: what does it mean to scale a window by a negative fraction?

Not experiencing undefined behavior is a desirable thing for arithmetic so unsigned has some appeal for arithmetic too, I'd say.

The amount of float point arithmetic done on the CPU in modern games is less than you'd think.

Mostly the errors are expecting that a calculation is using signed arithmetic when it's not, and getting a large positive value where you expected a small negative value.

From free play and 'building' to patterns, simple arithmetic, they just keep providing a direct physical analogue for numerical operations.

This causes unsigned arithmetic to contaminate parts of your code that you thought were signed.

I've found them to be pretty effective at helping her build the concepts around manipulating numbers for arithmetic.

Grep for all arithmetic in your choice of program and the vast, vast majority are not deliberately using overflow behavior for some effect.

If you can't program until you can read and write then you can't do arithmetic until you can read and write -- i.e.

It always feels like I'm trying to emulate floating-point arithmetic on a CPU without hard float support.

Is it possible that they're using "sequential" strictly, to mean that the arithmetic isn't vectorized?