Files refactored for lint compliance. Tests and benchmarks added.

Signed-off-by: Jobin John <[email protected]>

Author: Mystigan

.github/workflows/golangci-lint.yml

@@ -34,3 +34,7 @@ jobs:
       # - run: golangci-lint run --no-config "strings/single string matching"   || true
       - run: golangci-lint run --no-config strings/levenshteindistance
       - run: golangci-lint run --no-config strings/naivesearch
+      - run: golangci-lint run --no-config math/gcd
+      - run: golangci-lint run --no-config math/power
+      - run: golangci-lint run --no-config math/primecheck
+      - run: golangci-lint run --no-config math/sieve                         || true"

math/fastExponent.go

@@ -0,0 +1,9 @@
+package gcd
+
+// Gcd finds and returns the greatest common divisor of a given integer.
+func Gcd(a, b int) int {
+	if b == 0 {
+		return a
+	}
+	return Gcd(b, a%b)
+}

math/gcd/greatest_common_divisor.go

@@ -0,0 +1,31 @@
+package gcd
+
+import "testing"
+
+var testCases = []struct {
+	name   string
+	a      int
+	b      int
+	output int
+}{
+	{"gcd of 10 and 0", 10, 0, 10},
+	{"gcd of 98 and 56", 98, 56, 14},
+	{"gcd of 0 and 10", 0, 10, 10},
+}
+
+func TestGCD(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := Gcd(tc.a, tc.b)
+			if actual != tc.output {
+				t.Errorf("Expected GCD of %d and %d to be: %v, but got: %d", tc.a, tc.b, tc.output, actual)
+			}
+		})
+	}
+}
+
+func BenchmarkGCD(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Gcd(98, 56)
+	}
+}

math/gcd/greatest_common_divisor_test.go

@@ -0,0 +1,39 @@
+package power
+
+// IterativePower is iterative O(logn) function for pow(x, y)
+func IterativePower(n uint, power uint) uint {
+	var res uint = 1
+	for power > 0 {
+
+		if (power & 1) != 0 {
+			res = res * n
+		}
+
+		power = power >> 1
+		n = n * n
+	}
+	return res
+}
+
+// RecursivePower is recursive O(logn) function for pow(x, y)
+func RecursivePower(n uint, power uint) uint {
+	if power == 0 {
+		return 1
+	}
+	var temp = RecursivePower(n, power/2)
+	if power%2 == 0 {
+		return temp * temp
+	}
+	return n * temp * temp
+}
+
+// RecursivePower1 is recursive O(n) function for pow(x, y)
+func RecursivePower1(n uint, power uint) uint {
+	if power == 0 {
+		return 1
+	} else if power%2 == 0 {
+		return RecursivePower1(n, power/2) * RecursivePower1(n, power/2)
+	} else {
+		return n * RecursivePower1(n, power/2) * RecursivePower1(n, power/2)
+	}
+}

math/greatest_common_divisor.go

@@ -0,0 +1,67 @@
+package power
+
+import "testing"
+
+var testCases = []struct {
+	name     string
+	base     uint
+	power    uint
+	expected uint
+}{
+	{"0^2", 0, 2, 0},
+	{"2^0", 2, 0, 1},
+	{"2^3", 2, 3, 8},
+	{"8^3", 8, 3, 512},
+	{"10^5", 10, 5, 100000},
+}
+
+func TestIterativePower(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := IterativePower(tc.base, tc.power)
+			if actual != tc.expected {
+				t.Errorf("Expected %d to the power of %d to be: %d, but got: %d", tc.base, tc.power, tc.expected, actual)
+			}
+		})
+	}
+}
+
+func TestRecursivePower(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := RecursivePower(tc.base, tc.power)
+			if actual != tc.expected {
+				t.Errorf("Expected %d to the power of %d to be: %d, but got: %d", tc.base, tc.power, tc.expected, actual)
+			}
+		})
+	}
+}
+
+func TestRecursivePower1(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := RecursivePower1(tc.base, tc.power)
+			if actual != tc.expected {
+				t.Errorf("Expected %d to the power of %d to be: %d, but got: %d", tc.base, tc.power, tc.expected, actual)
+			}
+		})
+	}
+}
+
+func BenchmarkIterativePower(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		IterativePower(10, 5)
+	}
+}
+
+func BenchmarkRecursivePower(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		RecursivePower(10, 5)
+	}
+}
+
+func BenchmarkRecursivePower1(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		RecursivePower1(10, 5)
+	}
+}

math/power/fastExponent.go

@@ -1,8 +1,10 @@
-//A primality test is an algorithm for determining whether an input number is prime.Among other fields of mathematics, it is used for cryptography.
+package primecheck
+
+// A primality test is an algorithm for determining whether an input number is prime.Among other fields of mathematics, it is used for cryptography.
 //Unlike integer factorization, primality tests do not generally give prime factors, only stating whether the input number is prime or not.
 //Source - Wikipedia https://en.wikipedia.org/wiki/Primality_test
-package main
 
+// NaiveApproach checks if an integer is prime or not. Returns a bool.
 func NaiveApproach(n int) bool {
 	if n < 2 {
 		return false
@@ -16,6 +18,7 @@ func NaiveApproach(n int) bool {
 	return true
 }
 
+// PairApproach checks primality of an integer and returns a bool. More efficient than the naive approach as number of iterations are less.
 func PairApproach(n int) bool {
 	if n < 2 {
 		return false
@@ -27,8 +30,3 @@ func PairApproach(n int) bool {
 	}
 	return true
 }
-
-//goos: windows
-//goarch: amd64
-//BenchmarkNaiveApproach-12       660980034                1.81 ns/op
-//BenchmarkPairApproach-12        664641356                1.82 ns/op

math/power/fastExponent_test.go

@@ -0,0 +1,62 @@
+package primecheck
+
+import (
+	"testing"
+)
+
+func TestTableNaiveApproach(t *testing.T) {
+	var tests = []struct {
+		name     string
+		input    int
+		expected bool
+	}{
+		{"smallest prime", 2, true},
+		{"random prime", 3, true},
+		{"neither prime nor composite", 1, false},
+		{"random non-prime", 10, false},
+		{"another random prime", 23, true},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if output := NaiveApproach(test.input); output != test.expected {
+				t.Errorf("For input: %d, expected: %v, but got: %v", test.input, test.expected, output)
+			}
+		})
+	}
+
+}
+func TestTablePairApproach(t *testing.T) {
+	var tests = []struct {
+		name     string
+		input    int
+		expected bool
+	}{
+		{"smallest prime", 2, true},
+		{"random prime", 3, true},
+		{"neither prime nor composite", 1, false},
+		{"random non-prime", 10, false},
+		{"another random prime", 23, true},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if output := NaiveApproach(test.input); output != test.expected {
+				t.Errorf("For input: %d, expected: %v, but got: %v", test.input, test.expected, output)
+			}
+		})
+	}
+
+}
+
+func BenchmarkNaiveApproach(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NaiveApproach(23)
+	}
+}
+
+func BenchmarkPairApproach(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		PairApproach(23)
+	}
+}