math functions

README.md

@@ -73,7 +73,7 @@ func main() {
 
 ### Range
 
-Range is a bound iteractor that counts up from 0 to n-1 the value specified
+Range is a bound iterator that emits values incrementally starting from 0 and increasing to n-1, with n being the value specified in the Range constructor.
 
 ```golang
 package main
@@ -85,18 +85,7 @@ import (
 )
 
 func main() {
-    arr := iter.Range(5)
-
-    sum := 0
-    for {
-        val, err := arr.Next()
-        if err != nil {
-            break
-        }
-        sum += val
-    }
-
     // Prints: 10 (0 + 1 + 2 + 3 + 4)
-    fmt.Println(sum)
+    fmt.Println(iter.Sum(iter.Range(5)))
 }
 ```

array_iterator.go

@@ -5,8 +5,8 @@ type ArrayIterator[T any] struct {
 	pointer int
 }
 
-func Array[T any](data []T) ArrayIterator[T] {
-	return ArrayIterator[T]{
+func Array[T any](data []T) *ArrayIterator[T] {
+	return &ArrayIterator[T]{
 		data: data,
 	}
 }

errors.go

@@ -8,3 +8,6 @@ var ErrAtEnd = errors.New("iterator is at the end")
 // Error to indicate that the bound iterator is attempting to have an element
 // accessed that is out of it's bounds.
 var ErrNotInBounds = errors.New("index is outside of iterator bounds")
+
+// Error to indicate the value passed into the Range iterator is invalid.
+var ErrInvalidRangeValue = errors.New("range iterator can not be constructed with values less than 0")

iterops/chunk_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestChunk(t *testing.T) {
 	arr := iter.Array([]int{1, 2, 3, 4, 5})
-	chunkedIterator := iterops.Chunk[int](&arr, 2)
+	chunkedIterator := iterops.Chunk[int](arr, 2)
 
 	mappedData := iter.ReadFull(chunkedIterator)
 
@@ -22,7 +22,7 @@ func TestChunk(t *testing.T) {
 
 func TestChunkPerfect(t *testing.T) {
 	arr := iter.Array([]int{1, 2, 3, 4, 5, 6})
-	chunkedIterator := iterops.Chunk[int](&arr, 2)
+	chunkedIterator := iterops.Chunk[int](arr, 2)
 
 	mappedData := iter.ReadFull(chunkedIterator)
 

iterops/filter_test.go

@@ -11,8 +11,8 @@ import (
 func TestFilter(t *testing.T) {
 	arr := iter.Array([]int{1, 2, 3, 4, 5})
 
-	mapper := iterops.Filter[int](&arr, func(i int) bool {
-		return i % 2 == 0
+	mapper := iterops.Filter[int](arr, func(i int) bool {
+		return i%2 == 0
 	})
 
 	mappedData := iter.ReadFull(mapper)

iterops/flatten_test.go

@@ -18,7 +18,7 @@ func TestFlatten(t *testing.T) {
 		{},
 	})
 
-	flatten := iterops.Flatten[int](&arr)
+	flatten := iterops.Flatten[int](arr)
 
 	flattenData := iter.ReadFull(flatten)
 

iterops/maps_test.go

@@ -12,7 +12,7 @@ import (
 func TestMap(t *testing.T) {
 	arr := iter.Array([]string{"1", "2", "3", "4", "5"})
 
-	mapper := iterops.Map[string, int](&arr, func(s string) int {
+	mapper := iterops.Map[string, int](arr, func(s string) int {
 		parsed, _ := strconv.Atoi(s)
 		return parsed
 	})

iterops/scan_test.go

@@ -11,7 +11,7 @@ import (
 func TestScan(t *testing.T) {
 	arr := iter.Array([]int{1, 2, 3, 4})
 
-	mapper := iterops.Scan[int](&arr, func(cur, acc int) int {
+	mapper := iterops.Scan[int](arr, func(cur, acc int) int {
 		return cur + acc
 	})
 

iterops/zip_test.go

@@ -13,7 +13,7 @@ func TestZip(t *testing.T) {
 	arrA := iter.Array([]int{1, 2, 3, 4, 5})
 	arrB := iter.Array([]string{"A", "B", "C", "D", "E"})
 
-	mapper := iterops.Zip[int, string, string](&arrA, &arrB, func(i int, s string) string {
+	mapper := iterops.Zip[int, string, string](arrA, arrB, func(i int, s string) string {
 		return fmt.Sprintf("%d%s", i, s)
 	})
 
@@ -26,7 +26,7 @@ func TestZipStreamEndsEarly(t *testing.T) {
 	arrA := iter.Array([]int{1, 2, 3, 4, 5})
 	arrB := iter.Array([]string{"A", "B", "C", "D"})
 
-	mapper := iterops.Zip[int, string, string](&arrA, &arrB, func(i int, s string) string {
+	mapper := iterops.Zip[int, string, string](arrA, arrB, func(i int, s string) string {
 		return fmt.Sprintf("%d%s", i, s)
 	})
 

math.go

@@ -0,0 +1,106 @@
+package iter
+
+import "math"
+
+type Number interface {
+	float32 | float64 | int | int32 | int64
+}
+
+func Sum[T Number](i Iterator[T]) T {
+	var sum T
+	for {
+		val, err := i.Next()
+		if err != nil {
+			break
+		}
+		sum += val
+	}
+	return sum
+}
+
+func Min[T Number](i Iterator[T]) T {
+	var min T
+
+	switch i.(type) {
+	case Iterator[int]:
+		max := math.MaxInt
+		min = T(max)
+
+	case Iterator[int32]:
+		min = T(math.MaxInt32)
+
+	case Iterator[int64]:
+		max := math.MaxInt64
+		min = T(max)
+
+	case Iterator[float32]:
+		max := math.MaxFloat32
+		min = T(max)
+
+	case Iterator[float64]:
+		max := math.MaxFloat64
+		min = T(max)
+	}
+
+	for {
+		val, err := i.Next()
+		if err != nil {
+			break
+		}
+		if min > val {
+			min = val
+		}
+	}
+	return min
+}
+
+func Max[T Number](i Iterator[T]) T {
+	var max T
+
+	switch i.(type) {
+	case Iterator[int]:
+		min := math.MinInt
+		max = T(min)
+
+	case Iterator[int32]:
+		max = T(math.MinInt32)
+
+	case Iterator[int64]:
+		min := math.MinInt64
+		max = T(min)
+
+	case Iterator[float32]:
+		min := -math.MaxFloat32
+		max = T(min)
+
+	case Iterator[float64]:
+		min := -math.MaxFloat64
+		max = T(min)
+	}
+
+	for {
+		val, err := i.Next()
+		if err != nil {
+			break
+		}
+		if max < val {
+			max = val
+		}
+
+	}
+	return max
+}
+
+func Average[T Number](i Iterator[T]) float64 {
+	var sum T
+	count := 0.
+	for {
+		val, err := i.Next()
+		if err != nil {
+			break
+		}
+		sum += val
+		count++
+	}
+	return float64(sum) / count
+}

math_test.go

@@ -0,0 +1,50 @@
+package iter_test
+
+import (
+	"testing"
+
+	"github.com/EliCDavis/iter"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSum(t *testing.T) {
+	assert.Equal(t, 10, iter.Sum(iter.Range(5)))
+}
+
+func TestAverage(t *testing.T) {
+	assert.Equal(t, 2., iter.Average(iter.Range(5)))
+}
+
+func TestMin(t *testing.T) {
+	assert.Equal(t, 3, iter.Min(iter.Array([]int{5, 4, 3, 4, 5})))
+	assert.Equal(t, -5, iter.Min(iter.Array([]int{-5, -4, -3, -4, -5})))
+
+	assert.Equal(t, int32(3), iter.Min(iter.Array([]int32{5, 4, 3, 4, 5})))
+	assert.Equal(t, int32(-5), iter.Min(iter.Array([]int32{-5, -4, -3, -4, -5})))
+
+	assert.Equal(t, int64(3), iter.Min(iter.Array([]int64{5, 4, 3, 4, 5})))
+	assert.Equal(t, int64(-5), iter.Min(iter.Array([]int64{-5, -4, -3, -4, -5})))
+
+	assert.Equal(t, float32(3), iter.Min(iter.Array([]float32{5, 4, 3, 4, 5})))
+	assert.Equal(t, float32(-5), iter.Min(iter.Array([]float32{-5, -4, -3, -4, -5})))
+
+	assert.Equal(t, 3., iter.Min(iter.Array([]float64{5, 4, 3, 4, 5})))
+	assert.Equal(t, -5., iter.Min(iter.Array([]float64{-5, -4, -3, -4, -5})))
+}
+
+func TestMax(t *testing.T) {
+	assert.Equal(t, 5, iter.Max(iter.Array([]int{3, 4, 5, 4, 3})))
+	assert.Equal(t, -3, iter.Max(iter.Array([]int{-3, -4, -5, -4, -3})))
+
+	assert.Equal(t, int32(5), iter.Max(iter.Array([]int32{3, 4, 5, 4, 3})))
+	assert.Equal(t, int32(-3), iter.Max(iter.Array([]int32{-3, -4, -5, -4, -3})))
+
+	assert.Equal(t, int64(5), iter.Max(iter.Array([]int64{3, 4, 5, 4, 3})))
+	assert.Equal(t, int64(-3), iter.Max(iter.Array([]int64{-3, -4, -5, -4, -3})))
+
+	assert.Equal(t, float32(5), iter.Max(iter.Array([]float32{3, 4, 5, 4, 3})))
+	assert.Equal(t, float32(-3), iter.Max(iter.Array([]float32{-3, -4, -5, -4, -3})))
+
+	assert.Equal(t, 5., iter.Max(iter.Array([]float64{3, 4, 5, 4, 3})))
+	assert.Equal(t, -3., iter.Max(iter.Array([]float64{-3, -4, -5, -4, -3})))
+}

range_iterator.go

@@ -5,8 +5,11 @@ type RangeIterator struct {
 	pointer int
 }
 
-func Range(size int) RangeIterator {
-	return RangeIterator{
+func Range(size int) *RangeIterator {
+	if size < 0 {
+		panic(ErrInvalidRangeValue)
+	}
+	return &RangeIterator{
 		size:    size,
 		pointer: 0,
 	}

range_iterator_test.go

@@ -14,7 +14,7 @@ func TestRange(t *testing.T) {
 	assert.Equal(t, 0, i.Current())
 
 	// test reading all elements
-	assert.Equal(t, []int{0, 1, 2, 3, 4}, iter.ReadFull[int](&i))
+	assert.Equal(t, []int{0, 1, 2, 3, 4}, iter.ReadFull[int](i))
 
 	// test at
 	assert.Equal(t, 0, i.At(0))
@@ -39,3 +39,9 @@ func TestRange(t *testing.T) {
 		i.At(-1)
 	})
 }
+
+func TestRangePanicsWithValueLessThan0(t *testing.T) {
+	assert.PanicsWithError(t, iter.ErrInvalidRangeValue.Error(), func() {
+		iter.Range(-1)
+	})
+}

read_test.go

@@ -10,5 +10,5 @@ import (
 func TestReadFull(t *testing.T) {
 	original := []int{1, 2, 3, 4, 5}
 	i := iter.Array(original)
-	assert.Equal(t, original, iter.ReadFull[int](&i))
+	assert.Equal(t, original, iter.ReadFull[int](i))
 }