Add powers in terms of logarithms (TheAlgorithms#348)

Author: i-redbyte

math/pi/spigotpi.go

@@ -0,0 +1,59 @@
+// spigotpi.go
+// description: A Spigot Algorithm for the Digits of Pi
+// details:
+// implementation of Spigot Algorithm for the Digits of Pi - [Spigot algorithm](https://en.wikipedia.org/wiki/Spigot_algorithm)
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see spigotpi_test.go
+
+package pi
+
+import "strconv"
+
+func Spigot(n int) string {
+	pi := ""
+	boxes := n * 10 / 3
+	remainders := make([]int, boxes)
+	for i := 0; i < boxes; i++ {
+		remainders[i] = 2
+	}
+	digitsHeld := 0
+	for i := 0; i < n; i++ {
+		carriedOver := 0
+		sum := 0
+		for j := boxes - 1; j >= 0; j-- {
+			remainders[j] *= 10
+			sum = remainders[j] + carriedOver
+			quotient := sum / (j*2 + 1)
+			remainders[j] = sum % (j*2 + 1)
+			carriedOver = quotient * j
+		}
+		remainders[0] = sum % 10
+		q := sum / 10
+		switch q {
+		case 9:
+			digitsHeld++
+		case 10:
+			q = 0
+			for k := 1; k <= digitsHeld; k++ {
+				replaced, _ := strconv.Atoi(pi[i-k : i-k+1])
+				if replaced == 9 {
+					replaced = 0
+				} else {
+					replaced++
+				}
+				pi = delChar(pi, i-k)
+				pi = pi[:i-k] + strconv.Itoa(replaced) + pi[i-k:]
+			}
+			digitsHeld = 1
+		default:
+			digitsHeld = 1
+		}
+		pi += strconv.Itoa(q)
+	}
+	return pi
+}
+
+func delChar(s string, index int) string {
+	tmp := []rune(s)
+	return string(append(tmp[0:index], tmp[index+1:]...))
+}

math/pi/spigotpi_test.go

@@ -0,0 +1,50 @@
+// spigotpi_test.go
+// description: Test for Spigot Algorithm for the Digits of Pi
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see spigotpi.go
+package pi
+
+import (
+	"strconv"
+	"testing"
+)
+
+func TestSpigot(t *testing.T) {
+	var tests = []struct {
+		result string
+		n      int
+	}{
+		{"314159", 6},
+		{"31415926535", 11},
+		{"314159265358", 12},
+		{"314159265358979323846", 21},
+		{"314", 3},
+		{"31415", 5},
+	}
+	for _, tv := range tests {
+		t.Run(strconv.Itoa(tv.n)+":"+tv.result, func(t *testing.T) {
+			result := Spigot(tv.n)
+			if result != tv.result {
+				t.Errorf("Bad result %d:%s", tv.n, tv.result)
+			}
+		})
+	}
+}
+
+func BenchmarkPiSpigotN10(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Spigot(10)
+	}
+}
+
+func BenchmarkPiSpigotN100(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Spigot(100)
+	}
+}
+
+func BenchmarkPiSpigotN1000(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Spigot(1000)
+	}
+}

math/power/powvialogarithm.go

@@ -0,0 +1,24 @@
+// powvialogarithm.go
+// description: Powers in terms of logarithms
+// details:
+// implementation of exponentiation using exponent and logarithm, without using loops  - [Powers via logarithms wiki](https://en.wikipedia.org/wiki/Exponentiation#Powers_via_logarithms)
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see powvialogarithm_test.go
+
+package power
+
+import (
+	"math"
+)
+
+func UsingLog(a float64, b float64) float64 {
+	var p float64
+	p = 1
+	if a < 0 && int(b)&1 != 0 {
+		p = -1
+	}
+	log := math.Log(math.Abs(a))
+	exp := math.Exp(b * log)
+	result := exp * p
+	return math.Round(result)
+}

math/power/powvialogarithm_test.go

@@ -0,0 +1,44 @@
+// powvialogarithm_test.go
+// description: Test for UsingLog
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see powvialogarithm.go
+
+package power
+
+import "testing"
+
+func TestUsingLog(t *testing.T) {
+	var tests = []struct {
+		name     string
+		base     float64
+		power    float64
+		expected float64
+	}{
+		{"0^0", 99, 1, 99},
+		{"-3^9", -3, 9, -19683},
+		{"0^2", 0, 2, 0},
+		{"2^0", 2, 0, 1},
+		{"2^3", 2, 3, 8},
+		{"8^3", 8, 3, 512},
+		{"11^11", 11, 11, 285311670611},
+		{"5^5", 5, 5, 3125},
+		{"-7^2", -7, 2, 49},
+		{"-6^3", -6, 3, -216},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := UsingLog(tc.base, tc.power)
+			t.Log(result)
+			if result != tc.expected {
+				t.Errorf("Expected %.2f to the power of %.2f to be: %.2f, but got: %.2f", tc.base, tc.power, tc.expected, result)
+			}
+		})
+	}
+}
+
+func BenchmarkUsingLog(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		UsingLog(10, 5)
+	}
+}