How do I perform a mod operation between two integers in C++?
`a` and `b` are integers... so why `double`? `modulus_a_b` should be the same type as `a` and `b`.
Mike DeSimone
2010-04-05 22:42:13
@Mike: well, `a % b` will be either `int`, or else the same type as at least one of `a` and `b`. So you have a few choices for the type of `modulus_a_b`, depending on context :-)
Steve Jessop
2010-04-05 22:50:17
@Steve: But only one of those choices is the type that the `%` operator returns. All the others imply a typecast, er, `static_cast<>`. `double` is certainly one of the latter. Also, using `double` means using the slowest math available (unless there's a `long double` type, dog forbid)...
Mike DeSimone
2010-04-05 23:13:50
Woups, fixed, I used too much `double` recently...
Klaim
2010-04-05 23:16:26
The reason I said a lot of choice is because for instance the result of `short % short` is an `int`, not a `short`, but depending on context it probably makes more sense to use it as a `short`. So there's a conflict between "the same type as a and b" vs "avoiding an implicit conversion".
Steve Jessop
2010-04-06 10:38:40
@wilhelmtell: 5.6/4: "(a/b)*b + a%b is equal to a", so round-toward-zero (the overwhelmingly popular implementation, for better or worse) implies that, and it is mandated by C++0x.
Potatoswatter
2010-04-06 00:35:25
Round towards zero is mandated by c++0x, but *not* c++03. In both standards, your formula must hold true, but the sign of `a%b` depends on how integral division is implemented. The sign is well defined as non-negative only if `a` and `b` are both non-negative.
Dennis Zickefoose
2010-04-06 00:41:59
@Dennis the sign is well-defined as non-negative only if _`a` is non-negative and `b` is positive_ :p
wilhelmtell
2010-04-06 00:44:02
In any case, it won't map negative integers onto a http://en.wikipedia.org/wiki/Modular_arithmetic modular arithmetic ring. If it does, you are very lucky and your program is very unportable.
Potatoswatter
2010-04-06 01:35:28
+7
A:
As the other answers have stated, you can use the C++ % operator. But be aware that there's a wrinkle no one has mentioned yet: in the expression a % b, what if a is negative?
Should the result of this operation be positive or negative? The C++ standard leaves this up to the
implementation. So if you want to handle negative inputs portably, you should probably
do something like r = abs(a) % b, then fix up the sign of r to match your requirements.
Jim Lewis
2010-04-05 23:09:22
That's assuming you want the implied `div` operation to be round-towards-zero. If you want round-towards-negative-infinity, then you'll want `r = (unsigned(a) + offset * b) % b`, where `offset` is big enough for `a + offset * b` to always be positive.
Mike DeSimone
2010-04-05 23:19:02
+1
A:
C++ has the % operator, occasionally and misleadingly named "the modulus" operator. In particular the STL has the modulus<> functor in the <functional> header. That's not the mathematical modulus operator, mind you, because in modulus arithmetics a mod b by definition evaluates to a non-negative value for any value of a and any positive value of b. In C++ the sign of the result of a % b is implementation-defined if either of the arguments is negative. So, we would more appropriately name the % operator the remainder operator.
That said, if you truly want the mathematical modulus operator then you can define a function to do just that:
template<typename V>
V mod(const V& a, const V& b)
{
return (a % b + b) % b;
}
So long as b is a positive value a call to the above function will yield a non-negative result.
wilhelmtell
2010-04-05 23:57:41