Add support for uint type overflow detection

Author: rwxe

README.md

@@ -1,6 +1,6 @@
 [![Build Status](https://travis-ci.org/JohnCGriffin/overflow.png)](https://travis-ci.org/JohnCGriffin/overflow)
 # overflow
-Check for int/int8/int16/int64/int32 integer overflow in Golang arithmetic.
+Check for integer overflow in Golang arithmetic.
 ### Install
 ```
 go get github.com/johncgriffin/overflow
@@ -46,8 +46,7 @@ yields the output
 9223372036854775802+9 -> (0,false)
 ```
 
-For int, int64, and int32 types, provide Add, Add32, Add64, Sub, Sub32, Sub64, etc.  
-Unsigned types not covered at the moment, but such additions are welcome.
+For (u)int types, provide (U)Add, (U)Sub, (U)Mul, (U)Div, (U)Quotient, etc.
 
 ### Stay calm and panic
 

overflow.go

@@ -1,4 +1,5 @@
-/*Package overflow offers overflow-checked integer arithmetic operations
+/*
+Package overflow offers overflow-checked integer arithmetic operations
 for int, int32, and int64. Each of the operations returns a
 result,bool combination.  This was prompted by the need to know when
 to flow into higher precision types from the math.big library.
@@ -16,7 +17,8 @@ overflow.Add(math.MaxInt64,1) -> (0, false)
 Add, Sub, Mul, Div are for int.  Add64, Add32, etc. are specifically sized.
 
 If anybody wishes an unsigned version, submit a pull request for code
-and new tests. */
+and new tests.
+*/
 package overflow
 
 //go:generate ./overflow_template.sh
@@ -50,6 +52,16 @@ func Add(a, b int) (int, bool) {
 	return int(r32), ok
 }
 
+// UAdd sums two uints, returning the result and a boolean status.
+func UAdd(a, b uint) (uint, bool) {
+	if _is64Bit() {
+		r64, ok := UAdd64(uint64(a), uint64(b))
+		return uint(r64), ok
+	}
+	r32, ok := UAdd32(uint32(a), uint32(b))
+	return uint(r32), ok
+}
+
 // Sub returns the difference of two ints and a boolean status.
 func Sub(a, b int) (int, bool) {
 	if _is64Bit() {
@@ -60,6 +72,16 @@ func Sub(a, b int) (int, bool) {
 	return int(r32), ok
 }
 
+// USub returns the difference of two uints and a boolean status.
+func USub(a, b uint) (uint, bool) {
+	if _is64Bit() {
+		r64, ok := USub64(uint64(a), uint64(b))
+		return uint(r64), ok
+	}
+	r32, ok := USub32(uint32(a), uint32(b))
+	return uint(r32), ok
+}
+
 // Mul returns the product of two ints and a boolean status.
 func Mul(a, b int) (int, bool) {
 	if _is64Bit() {
@@ -70,6 +92,16 @@ func Mul(a, b int) (int, bool) {
 	return int(r32), ok
 }
 
+// UMul returns the product of two uints and a boolean status.
+func UMul(a, b uint) (uint, bool) {
+	if _is64Bit() {
+		r64, ok := UMul64(uint64(a), uint64(b))
+		return uint(r64), ok
+	}
+	r32, ok := UMul32(uint32(a), uint32(b))
+	return uint(r32), ok
+}
+
 // Div returns the quotient of two ints and a boolean status
 func Div(a, b int) (int, bool) {
 	if _is64Bit() {
@@ -80,6 +112,16 @@ func Div(a, b int) (int, bool) {
 	return int(r32), ok
 }
 
+// UDiv returns the quotient of two uints and a boolean status
+func UDiv(a, b uint) (uint, bool) {
+	if _is64Bit() {
+		r64, ok := UDiv64(uint64(a), uint64(b))
+		return uint(r64), ok
+	}
+	r32, ok := UDiv32(uint32(a), uint32(b))
+	return uint(r32), ok
+}
+
 // Quotient returns the quotient, remainder and status of two ints
 func Quotient(a, b int) (int, int, bool) {
 	if _is64Bit() {
@@ -90,6 +132,16 @@ func Quotient(a, b int) (int, int, bool) {
 	return int(q32), int(r32), ok
 }
 
+// UQuotient returns the quotient, remainder and status of two uints
+func UQuotient(a, b uint) (uint, uint, bool) {
+	if _is64Bit() {
+		uq64, ur64, ok := UQuotient64(uint64(a), uint64(b))
+		return uint(uq64), uint(ur64), ok
+	}
+	uq32, ur32, ok := UQuotient32(uint32(a), uint32(b))
+	return uint(uq32), uint(ur32), ok
+}
+
 /************* Panic versions for int ****************/
 
 // Addp returns the sum of two ints, panicking on overflow
@@ -101,6 +153,15 @@ func Addp(a, b int) int {
 	return r
 }
 
+// UAddp returns the sum of two uints, panicking on overflow
+func UAddp(a, b uint) uint {
+	r, ok := UAdd(a, b)
+	if !ok {
+		panic("addition overflow")
+	}
+	return r
+}
+
 // Subp returns the difference of two ints, panicking on overflow.
 func Subp(a, b int) int {
 	r, ok := Sub(a, b)
@@ -110,6 +171,15 @@ func Subp(a, b int) int {
 	return r
 }
 
+// USubp returns the difference of two uints, panicking on overflow.
+func USubp(a, b uint) uint {
+	r, ok := USub(a, b)
+	if !ok {
+		panic("subtraction overflow")
+	}
+	return r
+}
+
 // Mulp returns the product of two ints, panicking on overflow.
 func Mulp(a, b int) int {
 	r, ok := Mul(a, b)
@@ -119,6 +189,15 @@ func Mulp(a, b int) int {
 	return r
 }
 
+// UMulp returns the product of two uints, panicking on overflow.
+func UMulp(a, b uint) uint {
+	r, ok := UMul(a, b)
+	if !ok {
+		panic("multiplication overflow")
+	}
+	return r
+}
+
 // Divp returns the quotient of two ints, panicking on overflow.
 func Divp(a, b int) int {
 	r, ok := Div(a, b)
@@ -127,3 +206,12 @@ func Divp(a, b int) int {
 	}
 	return r
 }
+
+// UDivp returns the quotient of two uints, panicking on overflow.
+func UDivp(a, b uint) uint {
+	r, ok := UDiv(a, b)
+	if !ok {
+		panic("division failure")
+	}
+	return r
+}