math: Added RoundDecimalPlaces() and refactoring of IntPow, Sqrt and IsPrime (#187)

Made a few changes to IntPow, Sqrt and IsPrime

Co-authored-by: Kashif Khan <[email protected]>

Author: addvanced

math/EXAMPLES.md

@@ -460,3 +460,27 @@ func main() {
 [1 24 2 12 3 8 4 6]
 ```
 ---
+## `RoundDecimalPlaces`
+
+```go
+package main
+
+import (
+	"fmt"
+
+	utils "github.com/kashifkhan0771/utils/math"
+)
+
+func main() {
+	fmt.Println(utils.RoundDecimalPlaces(3.14159, 2)) // Rounds to 2 decimal places
+	fmt.Println(utils.RoundDecimalPlaces(3.14159, -1)) // Negative places are clamped to 0 (rounds to a whole number)
+}   
+```
+
+#### Output:
+
+```
+3.14
+3.0
+```
+---

math/README.md

@@ -24,16 +24,15 @@
 
 - **LCM**: Finds the least common multiple (LCM) of two integers.
 
-- **Sqrt**: Finds square root of the given number. Works for both integers and floating-point numbers. If the input is negative, it returns the initial given number.
-+ **Sqrt**: Finds the square root of the given number. Works for both integers and floating-point numbers. If the input is negative, it returns an error along with the original negative number.
+- **Sqrt**: Finds the square root of the given number. Works for both integers and floating-point numbers. If the input is negative, it returns an error along with the original negative number.
 
 - **IsPrime**: Checks if a number is prime or not. Only works for non-negative integers.
 
 - **PrimeList**: Returns a slice of prime numbers up to n.
 
 - **GetDivisors**: Returns the divisors of a positive integer as an unordered slice. Returns an empty slice for negative inputs.
 
-
+- **RoundDecimalPlaces**: Rounds a float64 to the specified number of decimal places using `math.Round` (half away from zero). Negative values for `places` are clamped to `0` (i.e., rounds to a whole number).
 
 ## Examples:
 

math/math.go

@@ -2,7 +2,7 @@ package math
 
 import (
 	"errors"
-	"log"
+	"math"
 )
 
 // number is a type constraint that matches all numeric types (integers and floats).
@@ -72,35 +72,7 @@ func Clamp[T number](min, max, value T) T {
 // IntPow calculates base raised to the power of exp.
 // Supports both positive and negative exponents. Returns float64 for fractional results.
 func IntPow(base, exp int) float64 {
-	if base == 0 && exp < 0 {
-		log.Fatal("IntPow: Error, base 0 raised to a negative number simplifies to 1/0(Impossible).")
-	}
-	if exp == 0 {
-		return 1 // Any number to the power of 0 is 1
-	}
-
-	result := 1
-	isNegative := exp < 0
-
-	// Use absolute value of exp for calculations
-	if isNegative {
-		exp = -exp
-	}
-
-	for exp > 0 {
-		if exp%2 == 1 {
-			result *= base
-		}
-		base *= base
-		exp /= 2
-	}
-
-	// If the exponent was negative, return the reciprocal
-	if isNegative {
-		return 1 / float64(result)
-	}
-
-	return float64(result)
+	return math.Pow(float64(base), float64(exp))
 }
 
 // IsEven checks if an integer x is even.
@@ -160,46 +132,31 @@ func LCM(x, y int) int {
 	return (x / GCD(x, y)) * y
 }
 
-// Sqrt computes the square root of a number using Newton's method.
+// Sqrt computes the square root of a number using the standard library's math.Sqrt.
+// For negative inputs, it returns the original value and an error.
 func Sqrt[T number](x T) (float64, error) {
 	if x < 0 {
 		return float64(x), errors.New("square root of a negative number is undefined")
-	} else if x == 0 {
-		return 0.0, nil
 	}
 
-	epsilon := 1e-10 // Precision threshold
-	z := float64(x)  // Initial guess
-
-	for {
-		nextZ := z - (z*z-float64(x))/(2*z)
-		if Abs[float64](nextZ-z) < epsilon {
-			return z, nil
-		}
-		z = nextZ
-	}
+	return math.Sqrt(float64(x)), nil
 }
 
-// check if a number is a prime number complexity = O(sqrt(n)
+// IsPrime checks if a number is prime. Complexity = O(sqrt(n)).
 func IsPrime(x int) bool {
-	// 1 and 0 are not primes and handle all negative numbers as non prime
-	if x < 2 {
+	// 1 and 0 are not primes and handle all negative numbers as non-prime.
+	if x < 2 || (x != 2 && IsEven(x)) {
 		return false
 	}
+
 	// 2 is the only even number that is a prime number
 	if x == 2 {
 		return true
 	}
-	// No need to handle sqrt error since we elimnated negative numbers
-	fsqrx, _ := Sqrt(x)
-	sqrx := int(fsqrx)
-	// If it's an even number that is not 2 then it's not a prime number
-	if x%2 == 0 {
-		return false
-	}
-	// Since we eliminated all even numbers we can just iterate over only odd numbers
-	// I'm iterating up to sqrx+1 just to account for any rounding errors
-	for i := 3; i <= sqrx+1; i += 2 {
+
+	// Since even numbers are eliminated, iterate over odd divisors only.
+	// Use i*i <= x to avoid float conversions and rounding concerns.
+	for i := 3; i*i <= x; i += 2 {
 		if x%i == 0 {
 			return false
 		}
@@ -255,3 +212,11 @@ func GetDivisors(n int) []int {
 	// The list is not sorted.
 	return list
 }
+
+// RoundDecimalPlaces rounds a float64 to the specified number of decimal places.
+// Negative values for places are clamped to 0 (i.e., rounds to a whole number).
+func RoundDecimalPlaces(val float64, places int) float64 {
+	p := math.Pow10(max(places, 0))
+
+	return math.Round(val*p) / p
+}

math/math_test.go

@@ -884,6 +884,69 @@ func TestGetDivisors(t *testing.T) {
 	}
 }
 
+func TestRoundDecimalPlaces(t *testing.T) {
+	tests := []struct {
+		name     string
+		value    float64
+		places   int
+		expected float64
+	}{
+		{
+			name:     "success - round to 2 decimal places",
+			value:    3.14159,
+			places:   2,
+			expected: 3.14,
+		},
+		{
+			name:     "success - round to 3 decimal places",
+			value:    2.718281828459045,
+			places:   3,
+			expected: 2.718,
+		},
+		{
+			name:     "success - round to 0 decimal places",
+			value:    1.9999,
+			places:   0,
+			expected: 2.0,
+		},
+		{
+			name:     "success - round negative number to 1 decimal place",
+			value:    -1.2345,
+			places:   1,
+			expected: -1.2,
+		},
+		{
+			name:     "success - round to 4 decimal places",
+			value:    0.123456789,
+			places:   4,
+			expected: 0.1235,
+		},
+		{
+			name:     "success - round to 5 decimal places",
+			value:    0.123456789,
+			places:   5,
+			expected: 0.12346,
+		},
+		{
+			name:     "success - round to 0 decimal places with negative number",
+			value:    3.14159,
+			places:   -1,
+			expected: 3.0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			result := RoundDecimalPlaces(tt.value, tt.places)
+			if result != tt.expected {
+				t.Errorf("RoundDecimalPlaces(%v, %d) = %v; want %v", tt.value, tt.places, result, tt.expected)
+			}
+		})
+	}
+}
+
 // ================================================================================
 // ### BENCHMARKS
 // ================================================================================