Report a bug
		
				If you spot a problem with this page, click here to create a Bugzilla issue.
		
			Improve this page
		
			Quickly fork, edit online, and submit a pull request for this page.
			Requires a signed-in GitHub account. This works well for small changes.
			If you'd like to make larger changes you may want to consider using
			a local clone.
		
	core.checkedint
This module implements integral arithmetic primitives that check
 for out-of-range results.
Integral arithmetic operators operate on fixed width types.
 Results that are not representable in those fixed widths are silently
 truncated to fit.
 This module offers integral arithmetic primitives that produce the
 same results, but set an 'overflow' flag when such truncation occurs.
 The setting is sticky, meaning that numerous operations can be cascaded
 and then the flag need only be checked at the end.
 Whether the operation is signed or unsigned is indicated by an 's' or 'u'
 suffix, respectively. While this could be achieved without such suffixes by
 using overloading on the signedness of the types, the suffix makes it clear
 which is happening without needing to examine the types.
 While the generic versions of these functions are computationally expensive
 relative to the cost of the operation itself, compiler implementations are free
 to recognize them and generate equivalent and faster code.
 The functions here are templates so they can be used with -betterC,
 as betterC does not link with this library.
References Fast Integer Overflow Checks
License: 
Authors: 
Walter Bright
Source core/checkedint.d
- intadds()(intx, inty, ref booloverflow);
 longadds()(longx, longy, ref booloverflow);
- Add two signed integers, checking for overflow.The overflow is sticky, meaning a sequence of operations can be done and overflow need only be checked at the end.Parameters:int xleft operand int yright operand bool overflowset if an overflow occurs, is not affected otherwise Returns:the sumExamples:bool overflow; assert(adds(2, 3, overflow) == 5); assert(!overflow); assert(adds(1, int.max - 1, overflow) == int.max); assert(!overflow); assert(adds(int.min + 1, -1, overflow) == int.min); assert(!overflow); assert(adds(int.max, 1, overflow) == int.min); assert(overflow); overflow = false; assert(adds(int.min, -1, overflow) == int.max); assert(overflow); assert(adds(0, 0, overflow) == 0); assert(overflow); // sticky Examples:bool overflow; assert(adds(2L, 3L, overflow) == 5); assert(!overflow); assert(adds(1L, long.max - 1, overflow) == long.max); assert(!overflow); assert(adds(long.min + 1, -1, overflow) == long.min); assert(!overflow); assert(adds(long.max, 1, overflow) == long.min); assert(overflow); overflow = false; assert(adds(long.min, -1, overflow) == long.max); assert(overflow); assert(adds(0L, 0L, overflow) == 0); assert(overflow); // sticky 
- uintaddu()(uintx, uinty, ref booloverflow);
 ulongaddu()(ulongx, ulongy, ref booloverflow);
- Add two unsigned integers, checking for overflow (aka carry).The overflow is sticky, meaning a sequence of operations can be done and overflow need only be checked at the end.Parameters:uint xleft operand uint yright operand bool overflowset if an overflow occurs, is not affected otherwise Returns:the sumExamples:for (uint i = 0; i < 10; ++i) { bool overflow; immutable uint r = addu (uint.max - i, uint.max - i, overflow); assert(r == 2 * (uint.max - i)); assert(overflow); } bool overflow; assert(addu(2, 3, overflow) == 5); assert(!overflow); assert(addu(1, uint.max - 1, overflow) == uint.max); assert(!overflow); assert(addu(uint.min, -1, overflow) == uint.max); assert(!overflow); assert(addu(uint.max, 1, overflow) == uint.min); assert(overflow); overflow = false; assert(addu(uint.min + 1, -1, overflow) == uint.min); assert(overflow); assert(addu(0, 0, overflow) == 0); assert(overflow); // sticky Examples:bool overflow; assert(addu(2L, 3L, overflow) == 5); assert(!overflow); assert(addu(1, ulong.max - 1, overflow) == ulong.max); assert(!overflow); assert(addu(ulong.min, -1L, overflow) == ulong.max); assert(!overflow); assert(addu(ulong.max, 1, overflow) == ulong.min); assert(overflow); overflow = false; assert(addu(ulong.min + 1, -1L, overflow) == ulong.min); assert(overflow); assert(addu(0L, 0L, overflow) == 0); assert(overflow); // sticky 
- intsubs()(intx, inty, ref booloverflow);
 longsubs()(longx, longy, ref booloverflow);
- Subtract two signed integers, checking for overflow.The overflow is sticky, meaning a sequence of operations can be done and overflow need only be checked at the end.Parameters:int xleft operand int yright operand bool overflowset if an overflow occurs, is not affected otherwise Returns:the differenceExamples:bool overflow; assert(subs(2, -3, overflow) == 5); assert(!overflow); assert(subs(1, -int.max + 1, overflow) == int.max); assert(!overflow); assert(subs(int.min + 1, 1, overflow) == int.min); assert(!overflow); assert(subs(int.max, -1, overflow) == int.min); assert(overflow); overflow = false; assert(subs(int.min, 1, overflow) == int.max); assert(overflow); assert(subs(0, 0, overflow) == 0); assert(overflow); // sticky Examples:bool overflow; assert(subs(2L, -3L, overflow) == 5); assert(!overflow); assert(subs(1L, -long.max + 1, overflow) == long.max); assert(!overflow); assert(subs(long.min + 1, 1, overflow) == long.min); assert(!overflow); assert(subs(-1L, long.min, overflow) == long.max); assert(!overflow); assert(subs(long.max, -1, overflow) == long.min); assert(overflow); overflow = false; assert(subs(long.min, 1, overflow) == long.max); assert(overflow); assert(subs(0L, 0L, overflow) == 0); assert(overflow); // sticky 
- uintsubu()(uintx, uinty, ref booloverflow);
 ulongsubu()(ulongx, ulongy, ref booloverflow);
- Subtract two unsigned integers, checking for overflow (aka borrow).The overflow is sticky, meaning a sequence of operations can be done and overflow need only be checked at the end.Parameters:uint xleft operand uint yright operand bool overflowset if an overflow occurs, is not affected otherwise Returns:the differenceExamples:bool overflow; assert(subu(3, 2, overflow) == 1); assert(!overflow); assert(subu(uint.max, 1, overflow) == uint.max - 1); assert(!overflow); assert(subu(1, 1, overflow) == uint.min); assert(!overflow); assert(subu(0, 1, overflow) == uint.max); assert(overflow); overflow = false; assert(subu(uint.max - 1, uint.max, overflow) == uint.max); assert(overflow); assert(subu(0, 0, overflow) == 0); assert(overflow); // sticky Examples:bool overflow; assert(subu(3UL, 2UL, overflow) == 1); assert(!overflow); assert(subu(ulong.max, 1, overflow) == ulong.max - 1); assert(!overflow); assert(subu(1UL, 1UL, overflow) == ulong.min); assert(!overflow); assert(subu(0UL, 1UL, overflow) == ulong.max); assert(overflow); overflow = false; assert(subu(ulong.max - 1, ulong.max, overflow) == ulong.max); assert(overflow); assert(subu(0UL, 0UL, overflow) == 0); assert(overflow); // sticky 
- intnegs()(intx, ref booloverflow);
 longnegs()(longx, ref booloverflow);
- Negate an integer.Parameters:int xoperand bool overflowset if x cannot be negated, is not affected otherwise Returns:the negation of xExamples:bool overflow; assert(negs(0, overflow) == -0); assert(!overflow); assert(negs(1234, overflow) == -1234); assert(!overflow); assert(negs(-5678, overflow) == 5678); assert(!overflow); assert(negs(int.min, overflow) == -int.min); assert(overflow); assert(negs(0, overflow) == -0); assert(overflow); // sticky Examples:bool overflow; assert(negs(0L, overflow) == -0); assert(!overflow); assert(negs(1234L, overflow) == -1234); assert(!overflow); assert(negs(-5678L, overflow) == 5678); assert(!overflow); assert(negs(long.min, overflow) == -long.min); assert(overflow); assert(negs(0L, overflow) == -0); assert(overflow); // sticky 
- intmuls()(intx, inty, ref booloverflow);
 longmuls()(longx, longy, ref booloverflow);
- Multiply two signed integers, checking for overflow.The overflow is sticky, meaning a sequence of operations can be done and overflow need only be checked at the end.Parameters:int xleft operand int yright operand bool overflowset if an overflow occurs, is not affected otherwise Returns:the productExamples:bool overflow; assert(muls(2, 3, overflow) == 6); assert(!overflow); assert(muls(-200, 300, overflow) == -60_000); assert(!overflow); assert(muls(1, int.max, overflow) == int.max); assert(!overflow); assert(muls(int.min, 1, overflow) == int.min); assert(!overflow); assert(muls(int.max, 2, overflow) == (int.max * 2)); assert(overflow); overflow = false; assert(muls(int.min, -1, overflow) == int.min); assert(overflow); assert(muls(0, 0, overflow) == 0); assert(overflow); // sticky Examples:bool overflow; assert(muls(2L, 3L, overflow) == 6); assert(!overflow); assert(muls(-200L, 300L, overflow) == -60_000); assert(!overflow); assert(muls(1, long.max, overflow) == long.max); assert(!overflow); assert(muls(long.min, 1L, overflow) == long.min); assert(!overflow); assert(muls(long.max, 2L, overflow) == (long.max * 2)); assert(overflow); overflow = false; assert(muls(-1L, long.min, overflow) == long.min); assert(overflow); overflow = false; assert(muls(long.min, -1L, overflow) == long.min); assert(overflow); assert(muls(0L, 0L, overflow) == 0); assert(overflow); // sticky 
- uintmulu()(uintx, uinty, ref booloverflow);
 ulongmulu()(ulongx, uinty, ref booloverflow);
 ulongmulu()(ulongx, ulongy, ref booloverflow);
- Multiply two unsigned integers, checking for overflow (aka carry).The overflow is sticky, meaning a sequence of operations can be done and overflow need only be checked at the end.Parameters:uint xleft operand uint yright operand bool overflowset if an overflow occurs, is not affected otherwise Returns:the product
Copyright © 1999-2025 by the D Language Foundation | Page generated by
Ddoc on Mon Mar 31 10:27:31 2025