Add Scalar Product example

examples/ScalarProduct/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+)
+
+//Type detection in impl finds all valid type targets
+//goast.net/x/iter looks for a type that matchs []interface{}
+//Botch Vector and Vectors match this, so both will have `iter` implemented
+//go:generate goast write impl goast.net/x/iter
+
+type Vector []int64
+type Vectors []Vector
+
+func (v Vector) Product() int64 {
+	return v.Fold(1, func(a, b int64) int64 { return a * b })
+}
+
+func (v Vector) Sum() int64 {
+	return v.Fold(0, func(a, b int64) int64 { return a + b })
+}
+
+func (v Vector) ScalarProduct(vex ...Vector) int64 {
+	var zipped Vectors = v.Zip(vex...)
+	return zipped.Fold(Vector{}, func(acc, vec Vector) Vector {
+		return append(acc, vec.Product())
+	}).Sum()
+}
+
+func main() {
+	x := Vector{1, 2, 3, 4, 5}
+	y := Vector{10, 10, 10, 10, 10}
+
+	sp := x.ScalarProduct(y)
+	//(1*10) + (2*10) + (3*10) + (4*10) + (5*10) == 150
+	fmt.Printf("Scalar Product: %d\n", sp)
+}

examples/ScalarProduct/vector_iter.go

@@ -0,0 +1,95 @@
+package main
+
+func (s Vector) All(fn func(int64) bool) bool {
+	for _, v := range s {
+		if !fn(v) {
+			return false
+		}
+	}
+	return true
+}
+func (s Vector) Any(fn func(int64) bool) bool {
+	for _, v := range s {
+		if fn(v) {
+			return true
+		}
+	}
+	return false
+}
+func (s Vector) Count(fn func(int64) bool) int {
+	count := 0
+	for _, v := range s {
+		if fn(v) {
+			count += 1
+		}
+	}
+	return count
+}
+func (s Vector) Each(fn func(int64)) {
+	for _, v := range s {
+		fn(v)
+	}
+}
+func (s *Vector) Extract(fn func(int64) bool) (removed Vector) {
+	pos := 0
+	kept := *s
+	for i := 0; i < len(kept); i++ {
+		if fn(kept[i]) {
+			removed = append(removed, kept[i])
+		} else {
+			kept[pos] = kept[i]
+			pos++
+		}
+	}
+	kept = kept[:pos:pos]
+	*s = kept
+	return removed
+}
+func (s Vector) First(fn func(int64) bool) (match int64, found bool) {
+	for _, v := range s {
+		if fn(v) {
+			match = v
+			found = true
+			break
+		}
+	}
+	return
+}
+func (s Vector) Fold(initial int64, fn func(int64, int64) int64) int64 {
+	folded := initial
+	for _, v := range s {
+		folded = fn(folded, v)
+	}
+	return folded
+}
+func (s Vector) FoldR(initial int64, fn func(int64, int64) int64) int64 {
+	folded := initial
+	for i := len(s) - 1; i >= 0; i-- {
+		folded = fn(folded, s[i])
+	}
+	return folded
+}
+func (s Vector) Where(fn func(int64) bool) (result Vector) {
+	for _, v := range s {
+		if fn(v) {
+			result = append(result, v)
+		}
+	}
+	return result
+}
+func (s Vector) Zip(in ...Vector) (result []Vector) {
+	minLen := len(s)
+	for _, x := range in {
+		if len(x) < minLen {
+			minLen = len(x)
+		}
+	}
+	for i := 0; i < minLen; i++ {
+		row := Vector{s[i]}
+		for _, x := range in {
+			row = append(row, x[i])
+		}
+		result = append(result, row)
+	}
+	return
+}

examples/ScalarProduct/vectors_iter.go

@@ -0,0 +1,95 @@
+package main
+
+func (s Vectors) All(fn func(Vector) bool) bool {
+	for _, v := range s {
+		if !fn(v) {
+			return false
+		}
+	}
+	return true
+}
+func (s Vectors) Any(fn func(Vector) bool) bool {
+	for _, v := range s {
+		if fn(v) {
+			return true
+		}
+	}
+	return false
+}
+func (s Vectors) Count(fn func(Vector) bool) int {
+	count := 0
+	for _, v := range s {
+		if fn(v) {
+			count += 1
+		}
+	}
+	return count
+}
+func (s Vectors) Each(fn func(Vector)) {
+	for _, v := range s {
+		fn(v)
+	}
+}
+func (s *Vectors) Extract(fn func(Vector) bool) (removed Vectors) {
+	pos := 0
+	kept := *s
+	for i := 0; i < len(kept); i++ {
+		if fn(kept[i]) {
+			removed = append(removed, kept[i])
+		} else {
+			kept[pos] = kept[i]
+			pos++
+		}
+	}
+	kept = kept[:pos:pos]
+	*s = kept
+	return removed
+}
+func (s Vectors) First(fn func(Vector) bool) (match Vector, found bool) {
+	for _, v := range s {
+		if fn(v) {
+			match = v
+			found = true
+			break
+		}
+	}
+	return
+}
+func (s Vectors) Fold(initial Vector, fn func(Vector, Vector) Vector) Vector {
+	folded := initial
+	for _, v := range s {
+		folded = fn(folded, v)
+	}
+	return folded
+}
+func (s Vectors) FoldR(initial Vector, fn func(Vector, Vector) Vector) Vector {
+	folded := initial
+	for i := len(s) - 1; i >= 0; i-- {
+		folded = fn(folded, s[i])
+	}
+	return folded
+}
+func (s Vectors) Where(fn func(Vector) bool) (result Vectors) {
+	for _, v := range s {
+		if fn(v) {
+			result = append(result, v)
+		}
+	}
+	return result
+}
+func (s Vectors) Zip(in ...Vectors) (result []Vectors) {
+	minLen := len(s)
+	for _, x := range in {
+		if len(x) < minLen {
+			minLen = len(x)
+		}
+	}
+	for i := 0; i < minLen; i++ {
+		row := Vectors{s[i]}
+		for _, x := range in {
+			row = append(row, x[i])
+		}
+		result = append(result, row)
+	}
+	return
+}