Thread overview
It is possible to substract 5 from 3 unsigned integer
Oct 06
ikod
Oct 06
Johan
Oct 08
Kagamin
October 06
Is that the expected behavior of the programmer?
Opinions can differ. Feel free to elaborate.
October 06
On Tuesday, 6 October 2020 at 12:24:56 UTC, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.
E.g. length of a string unsigned long.
October 06
On Tuesday, 6 October 2020 at 12:24:56 UTC, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.

Elaborate please. Are you really asking if one can do subtraction in D.
October 06
On Tuesday, 6 October 2020 at 12:24:56 UTC, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.

It's expected behavior:

"If both operands are of integral types and an overflow or underflow occurs in the computation, wrapping will happen. For example, uint.max + 1 == uint.min, uint.min - 1 == uint.max, int.max + 1 == int.min, and int.min - 1 == int.max."

https://dlang.org/spec/expression.html#add_expressions
October 06
On 10/6/20 5:24 AM, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.

The following is even more "expected". ;) Subtract zero from -1 and you get size_t.max.

void main() {
  int[] arr;
  int i = -1;

  auto u = (i - arr.length);    // -1 - 0

  assert(u == size_t.max);                   // the surprise
  static assert (is (typeof(u) == size_t));  // the reason
}

Ali
October 06
There are two subtractions possible.
A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
A logical one. For the last one higher classes might be needed.
October 06
On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> There are two subtractions possible.
> A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
> A logical one. For the last one higher classes might be needed.

Hello,

You may try https://dlang.org/phobos/std_experimental_checkedint.html in this case.

Regards,
October 06
On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> There are two subtractions possible.
> A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
> A logical one. For the last one higher classes might be needed.

The (signed and unsigned) integer wrap around is well-defined in D, and is architecture independent. That means for example that if a specific architecture does not have a subtract instruction that wraps around according to what D specifies, then the compiler will generate the necessary instructions such that still int.min - 1 == int.max. That's similar to how integer multiplication 'just works' on architectures that do not have a multiply instruction.

-Johan

October 08
On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> There are two subtractions possible.
> A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
> A logical one. For the last one higher classes might be needed.

Or use BigInt
October 08
On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> A logical one. For the last one higher classes might be needed.

Also assert(5/3==1);