Add safe absolute value operation

Author: rwxe

README.md

@@ -26,19 +26,14 @@ go generate
 
 #### Arithmetic overflow detection
 ```go
-package main
-
-import "fmt"
-import "math"
 import "github.com/rwxe/overflow"
 
 func main() {
-	addend := math.MaxInt64 - 5
-	for i := 0; i < 10; i++ {
-		sum, ok := overflow.Add(addend, i)
-		fmt.Printf("%v+%v -> (%v,%v)\n",
-			addend, i, sum, ok)
-	}
+    addend := math.MaxInt64 - 5
+    for i := 0; i < 10; i++ {
+        sum, ok := overflow.Add(addend, i)
+        fmt.Printf("%v+%v -> (%v,%v)\n", addend, i, sum, ok)
+    }
 }
 ```
 yields the output
@@ -56,16 +51,14 @@ yields the output
 ```
 For (u)int types, provide (U)Add, (U)Sub, (U)Mul, (U)Div, (U)Quotient, etc.
 
-
 #### Type conversion overflow detection
 ```go
 func main() {
-	var i uint
-	for i = math.MaxInt - 5; i <= math.MaxInt+5; i++ {
-		ret, ok := overflow.UintToInt(i)
-		fmt.Printf("%v -> (%v,%v)\n",
-			i, ret, ok)
-	}
+    var i uint
+    for i = math.MaxInt - 5; i <= math.MaxInt+5; i++ {
+        ret, ok := overflow.UintToInt(i)
+        fmt.Printf("%v -> (%v,%v)\n", i, ret, ok)
+    }
 }
 ```
 yields the output
@@ -84,9 +77,41 @@ yields the output
 ```
 Provide UintToInt, IntToUint, Uint64ToInt32, Int32ToUint64, etc.
 
+#### Get absolute value
+```go
+func main() {
+    normalAbs := func(x int64) int64 {
+        if x < 0 {
+            x = -x
+        }
+        return x
+    }
+    var i1, j1, k1 int64 = -9007199254740993, -9007199254740993, -9007199254740993
+    fmt.Println(int64(math.Abs(float64(i1))))
+    fmt.Println(normalAbs(j1))
+    fmt.Println(overflow.Abs64(k1))
+
+    var i2, j2, k2 int64 = math.MinInt64, math.MinInt64, math.MinInt64
+    fmt.Println(int64(math.Abs(float64(i2))))
+    fmt.Println(normalAbs(j2))
+    fmt.Println(overflow.Abs64(k2))
+}
+```
+yields the output
+```go
+9007199254740992 // Mantissa overflow, precision lost
+9007199254740993
+9007199254740993 true
+-9223372036854775808
+-9223372036854775808
+-9223372036854775808 false // Overflow detected
+```
+
+For int, provides an absolute value including overflow detection.
+
 ### Stay calm and panic
 
-There's a good case to be made that a panic is an unidiomatic but proper response.  Iff you believe that there's no valid way to continue your program after math goes wayward, you can use the easier Addp, Mulp, Subp, Divp, IntToUintp, UintToIntp versions which return the normal result or panic.
+There's a good case to be made that a panic is an unidiomatic but proper response. If you believe that there's no valid way to continue your program after math goes wayward, you can use the easier Addp, Mulp, Subp, Divp, IntToUintp, Absp etc, which return the normal result or panic.
 
 ### Performance considerations
 

README.zh_CN.md

@@ -82,9 +82,41 @@ func main() {
 ```
 提供UintToInt、IntToUint、Uint64ToInt32、Int32ToUint64等操作。
 
+#### 取绝对值
+```go
+func main() {
+    normalAbs := func(x int64) int64 {
+        if x < 0 {
+            x = -x
+        }
+        return x
+    }
+    var i1, j1, k1 int64 = -9007199254740993, -9007199254740993, -9007199254740993
+    fmt.Println(int64(math.Abs(float64(i1))))
+    fmt.Println(normalAbs(j1))
+    fmt.Println(overflow.Abs64(k1))
+
+    var i2, j2, k2 int64 = math.MinInt64, math.MinInt64, math.MinInt64
+    fmt.Println(int64(math.Abs(float64(i2))))
+    fmt.Println(normalAbs(j2))
+    fmt.Println(overflow.Abs64(k2))
+}
+```
+yields the output
+```go
+9007199254740992 // Mantissa overflow, precision lost
+9007199254740993
+9007199254740993 true
+-9223372036854775808
+-9223372036854775808
+-9223372036854775808 false // Overflow detected
+```
+
+对于整数，提供包含溢出检测的取绝对值操作。
+
 ### 保持冷静并恐慌
 
-有充分的证据表明，恐慌是一种不惯用但正确的反应。 如果你相信在算术和转换出现问题后，没有有效的方法可以继续你的程序，你可以使用更简单的 Addp、Mulp、Subp 、Divp、UintToIntp、IntToUintp 版本，它们返回正常结果或恐慌。
+有充分的证据表明，恐慌是一种不惯用但正确的反应。 如果你相信在算术和转换出现问题后，没有有效的方法可以继续你的程序，你可以使用更简单的 Addp、Mulp、Subp 、Divp、UintToIntp、Absp等版本，它们返回正常结果或恐慌。
 
 ### 性能考虑
 

overflow.go

@@ -42,6 +42,16 @@ So, FEEL FREE to carefully review the code visually.
 
 // Unspecified size, i.e. normal signed int
 
+// Abs get absolute value of an int, returning the result and a ok result indicating whether the operation is safe.
+func Abs(x int) (int, bool) {
+	if _is64Bit() {
+		r64, ok := Abs64(int64(x))
+		return int(r64), ok
+	}
+	r32, ok := Abs32(int32(x))
+	return int(r32), ok
+}
+
 // Add sums two ints, returning the result and a ok result indicating whether the operation is safe.
 func Add(a, b int) (int, bool) {
 	if _is64Bit() {
@@ -166,6 +176,15 @@ func UintToInt(x uint) (int, bool) {
 
 /************* Panic versions for int ****************/
 
+// Absp returns the absolute value, panicking on overflow
+func Absp(x int) int {
+	r, ok := Abs(x)
+	if !ok {
+		panic("absolute value overflow")
+	}
+	return r
+}
+
 // Addp returns the sum of two ints, panicking on overflow
 func Addp(a, b int) int {
 	r, ok := Add(a, b)

overflow_impl.go

@@ -8,6 +8,18 @@ import "math"
 
 
 
+// Abs8 performs absolute value operation on an int8 operand
+// returning a result and a ok result indicating whether the operation is safe.
+func Abs8(x int8) (int8, bool) {
+        if x == math.MinInt8 {
+                return x, false
+        }
+        if x >= 0 {
+                return x, true
+        }
+        return -x, true
+}
+
 // Add8 performs + operation on two int8 operands
 // returning a result and a ok result indicating whether the operation is safe.
 func Add8(a, b int8) (int8, bool) {
@@ -188,6 +200,18 @@ func UQuotient8(a, b uint8) (uint8, uint8, bool) {
 
 
 
+// Abs16 performs absolute value operation on an int16 operand
+// returning a result and a ok result indicating whether the operation is safe.
+func Abs16(x int16) (int16, bool) {
+        if x == math.MinInt16 {
+                return x, false
+        }
+        if x >= 0 {
+                return x, true
+        }
+        return -x, true
+}
+
 // Add16 performs + operation on two int16 operands
 // returning a result and a ok result indicating whether the operation is safe.
 func Add16(a, b int16) (int16, bool) {
@@ -368,6 +392,18 @@ func UQuotient16(a, b uint16) (uint16, uint16, bool) {
 
 
 
+// Abs32 performs absolute value operation on an int32 operand
+// returning a result and a ok result indicating whether the operation is safe.
+func Abs32(x int32) (int32, bool) {
+        if x == math.MinInt32 {
+                return x, false
+        }
+        if x >= 0 {
+                return x, true
+        }
+        return -x, true
+}
+
 // Add32 performs + operation on two int32 operands
 // returning a result and a ok result indicating whether the operation is safe.
 func Add32(a, b int32) (int32, bool) {
@@ -548,6 +584,18 @@ func UQuotient32(a, b uint32) (uint32, uint32, bool) {
 
 
 
+// Abs64 performs absolute value operation on an int64 operand
+// returning a result and a ok result indicating whether the operation is safe.
+func Abs64(x int64) (int64, bool) {
+        if x == math.MinInt64 {
+                return x, false
+        }
+        if x >= 0 {
+                return x, true
+        }
+        return -x, true
+}
+
 // Add64 performs + operation on two int64 operands
 // returning a result and a ok result indicating whether the operation is safe.
 func Add64(a, b int64) (int64, bool) {

overflow_template.sh

@@ -16,6 +16,18 @@ for SIZE in 8 16 32 64
 do
 echo "
 
+// Abs${SIZE} performs absolute value operation on an int${SIZE} operand
+// returning a result and a ok result indicating whether the operation is safe.
+func Abs${SIZE}(x int${SIZE}) (int${SIZE}, bool) {
+        if x == math.MinInt${SIZE} {
+                return x, false
+        }
+        if x >= 0 {
+                return x, true
+        }
+        return -x, true
+}
+
 // Add${SIZE} performs + operation on two int${SIZE} operands
 // returning a result and a ok result indicating whether the operation is safe.
 func Add${SIZE}(a, b int${SIZE}) (int${SIZE}, bool) {

overflow_test.go

@@ -201,6 +201,24 @@ func TestQuotient(t *testing.T) {
 	}
 }
 
+func TestAbs(t *testing.T) {
+	if _, ok := Abs(math.MinInt); ok {
+		t.Error("unexpected ok, absolute value overflow")
+	}
+	if _, ok := Abs64(math.MinInt64); ok {
+		t.Error("unexpected ok, absolute value overflow")
+	}
+	if _, ok := Abs32(math.MinInt32); ok {
+		t.Error("unexpected ok, absolute value overflow")
+	}
+	if _, ok := Abs16(math.MinInt16); ok {
+		t.Error("unexpected ok, absolute value overflow")
+	}
+	if _, ok := Abs8(math.MinInt8); ok {
+		t.Error("unexpected ok, absolute value overflow")
+	}
+}
+
 //func TestAdditionInt(t *testing.T) {
 //	fmt.Printf("\nminint8 = %v\n", math.MinInt8)
 //	fmt.Printf("maxint8 = %v\n\n", math.MaxInt8)