Merge pull request #118 from danilovict2/rand

Rand

Author: kashifkhan0771

EXAMPLES.md

@@ -660,7 +660,7 @@ func main() {
 ## 6. Random
 
 
-### Generate a Random Number
+### Generate a Pseudo-Random Number
 
 ```go
 package main
@@ -671,17 +671,41 @@ import (
 )
 
 func main() {
-	num, err := rand.Number()
+	i := rand.Int()
+	i64 := rand.Int64()
+	fmt.Println("Random Number:", i)
+	fmt.Println("Random Number(63-bit):", i64)
+}
+```
+#### Output:
+```
+Random Number: 1983964840637203872
+Random Number(63-bit): 8714503361527813617
+```
+
+### Generate a Cryptographically Secure Random Number
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/kashifkhan0771/utils/rand"
+)
+
+func main() {
+	n, err := rand.SecureNumber()
 	if err != nil {
 		fmt.Println("Error:", err)
 		return
 	}
-	fmt.Println("Random Number:", num)
+
+	fmt.Println("Cryptographically Secure Random Number:", n)
 }
 ```
 #### Output:
 ```
-Random Number: 8507643814357583841
+Cryptographically Secure Random Number: 5251369289452281710
 ```
 
 ### Generate a Random Number in a Range

README.md

@@ -71,7 +71,9 @@ require github.com/kashifkhan0771/utils v0.3.0
 - **NullableString**: Returns the value of a string pointer or an empty string if nil.
 
 ### 6. Random (rand)
-- **Number**: Generates a random number.
+- **Int**: Generates a pseudo-random integer.
+- **Int64**: Generates a pseudo-random 63-bit integer.
+- **SecureNumber**: Generates a cryptographically secure random number.
 - **NumberInRange**: Generates a random number within a specified range.
 - **String**: Generates a random alphanumeric string.
 - **StringWithLength**: Generates a random string of a custom length.

rand/rand.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"math"
 	"math/big"
+	randv2 "math/rand/v2"
 	"strings"
 )
 
@@ -16,7 +17,19 @@ const (
 	DefaultLength = 10
 )
 
-func Number() (int64, error) {
+// Int returns a pseudo-random integer
+func Int() int {
+	return randv2.Int()
+}
+
+// Int64 returns a pseudo-random 63-bit integer
+func Int64() int64 {
+	return randv2.Int64()
+}
+
+// SecureNumber returns a cryptographically secure random number.
+// Note: This function is significantly slower than Int() and Int64() due to the use of crypto/rand.
+func SecureNumber() (int64, error) {
 	n, err := rand.Int(rand.Reader, big.NewInt(math.MaxInt64))
 	if err != nil {
 		return 0, fmt.Errorf("failed to generate random number: %w", err)
@@ -25,7 +38,7 @@ func Number() (int64, error) {
 	return n.Int64(), nil
 }
 
-// NumberInRange generates a random number between min and max
+// NumberInRange generates a pseudo-random number between min and max
 func NumberInRange(min, max int64) (int64, error) {
 	if min > max {
 		return 0, fmt.Errorf("min (%d) cannot be greater than max (%d)", min, max)
@@ -41,13 +54,10 @@ func NumberInRange(min, max int64) (int64, error) {
 	limit := math.MaxInt64 - (math.MaxInt64 % rangeSize)
 
 	for {
-		n, err := rand.Int(rand.Reader, big.NewInt(math.MaxInt64))
-		if err != nil {
-			return 0, fmt.Errorf("failed to generate random number in range: %w", err)
-		}
+		n := randv2.Int64N(math.MaxInt64)
 
-		if n.Int64() < limit {
-			return min + (n.Int64() % rangeSize), nil
+		if n < limit {
+			return min + (n % rangeSize), nil
 		}
 		// If we're above the limit, try again to ensure uniform distribution
 	}
@@ -107,14 +117,10 @@ func StringWithCharset(length int, charset string) (string, error) {
 	}
 
 	result := make([]byte, length)
-	charsetLength := big.NewInt(int64(len(trimmedCharset)))
 
-	for i := 0; i < length; i++ {
-		n, err := rand.Int(rand.Reader, charsetLength)
-		if err != nil {
-			return "", fmt.Errorf("failed to generate random string: %w", err)
-		}
-		result[i] = trimmedCharset[n.Int64()]
+	for i := range length {
+		n := randv2.Int64N(int64(len(trimmedCharset)))
+		result[i] = trimmedCharset[n]
 	}
 
 	return string(result), nil

rand/rand_test.go

@@ -2,19 +2,54 @@ package rand
 
 import (
 	"math/rand"
-	randv2 "math/rand/v2"
 	"strings"
 	"testing"
 )
 
-func TestNumber(t *testing.T) {
+func TestInt(t *testing.T) {
+	const iterations = 1000
+	seen := make(map[int]bool)
+
+	for range iterations {
+		n := Int()
+		// Track unique numbers
+		seen[n] = true
+	}
+
+	// With true randomness, we expect a high percentage of unique numbers
+	// Given the massive range of int64, getting even 2 duplicates would be extremely unlikely
+	uniqueRatio := float64(len(seen)) / float64(iterations)
+	if uniqueRatio < 0.99 {
+		t.Errorf("Expected mostly unique numbers, but got uniqueness ratio of %v", uniqueRatio)
+	}
+}
+
+func TestInt64(t *testing.T) {
+	const iterations = 1000
+	seen := make(map[int64]bool)
+
+	for range iterations {
+		n := Int64()
+		// Track unique numbers
+		seen[n] = true
+	}
+
+	// With true randomness, we expect a high percentage of unique numbers
+	// Given the massive range of int64, getting even 2 duplicates would be extremely unlikely
+	uniqueRatio := float64(len(seen)) / float64(iterations)
+	if uniqueRatio < 0.99 {
+		t.Errorf("Expected mostly unique numbers, but got uniqueness ratio of %v", uniqueRatio)
+	}
+}
+
+func TestSecureNumber(t *testing.T) {
 	const iterations = 1000
 	seen := make(map[int64]bool)
 
-	for i := 0; i < iterations; i++ {
-		n, err := Number()
+	for range iterations {
+		n, err := SecureNumber()
 		if err != nil {
-			t.Errorf("Number() error = %v", err)
+			t.Errorf("SecureNumber() error = %v", err)
 
 			return
 		}
@@ -313,7 +348,7 @@ func contains[T comparable](slice []T, item T) bool {
 func BenchmarkNumberCrypto(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
-		_, _ = Number()
+		_, _ = SecureNumber()
 	}
 }
 
@@ -329,15 +364,17 @@ func BenchmarkNumberMath(b *testing.B) {
 	}
 }
 
-// Using math/rand/v2
-func numberMathRandV2() (int64, error) {
-	return randv2.Int64(), nil
+func BenchmarkIntMathV2(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = Int()
+	}
 }
 
-func BenchmarkNumberMathV2(b *testing.B) {
+func BenchmarkInt64MathV2(b *testing.B) {
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
-		_, _ = numberMathRandV2()
+		_ = Int64()
 	}
 }