Feature/fix aroon (#276)

# Describe Request

Introduce Window, MaxSince and MinSince on channels to hopefully fix
#124 as suggested.

Fixed # (issue)

# Change Type

What is the type of this change.


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Streaming sliding-window utilities: Lowest/Highest per-window extrema,
MaxSince/MinSince persistence counters, a reverse-slice iterator, and a
generic Window transformer.

* **Bug Fixes**
* More accurate "since last high" and "since last low" calculations in
trend indicators via specialized helpers.

* **Tests**
* Added unit tests covering sliding-window behavior, extrema persistence
logic, reverse-slice utility, and Aroon/trend validation.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Co-authored-by: heiko <[email protected]>
Co-authored-by: Onur Cinar <[email protected]>

Author: 3 people

helper/Lowest.go

@@ -0,0 +1,15 @@
+// Copyright (c) 2021-2024 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package helper
+
+import "slices"
+
+// Lowest returns a channel that emits the lowest value
+// within a sliding window of size w from the input channel c.
+func Lowest[T Number](c <-chan T, w int) <-chan T {
+	return Window(c, func(s []T, i int) T {
+		return slices.Min(s)
+	}, w)
+}

helper/highest.go

@@ -0,0 +1,15 @@
+// Copyright (c) 2021-2024 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package helper
+
+import "slices"
+
+// Highest returns a channel that emits the highest value
+// within a sliding window of size w from the input channel c.
+func Highest[T Number](c <-chan T, w int) <-chan T {
+	return Window(c, func(s []T, i int) T {
+		return slices.Max(s)
+	}, w)
+}

helper/highest_test.go

@@ -0,0 +1,21 @@
+// Copyright (c) 2021-2024 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package helper
+
+import (
+	"testing"
+)
+
+func TestHighest(t *testing.T) {
+	input := SliceToChan([]int{48, 52, 50, 49, 10})
+	expected := SliceToChan([]int{48, 52, 52, 52, 50})
+	window := 3
+	actual := Highest(input, window)
+
+	err := CheckEquals(actual, expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

helper/lowest_test.go

@@ -0,0 +1,21 @@
+// Copyright (c) 2021-2024 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package helper
+
+import (
+	"testing"
+)
+
+func TestLowest(t *testing.T) {
+	input := SliceToChan([]int{48, 52, 50, 49, 10})
+	expected := SliceToChan([]int{48, 48, 48, 49, 10})
+	window := 3
+	actual := Lowest(input, window)
+
+	err := CheckEquals(actual, expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

helper/max_since.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2021-2024 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package helper
+
+import (
+	"slices"
+)
+
+// MaxSince returns a channel of T indicating since when
+// (number of previous values) the respective value was the maximum
+// within the window of size w.
+func MaxSince[T Number](c <-chan T, w int) <-chan T {
+	return Window(c, func(w []T, i int) T {
+		since := 0
+		found := false
+		m := slices.Max(w)
+		SlicesReverse(w, i, func(n T) bool {
+			if found && n < m {
+				return false
+			}
+			since++
+			if n == m {
+				found = true
+			}
+			return true
+		})
+		return T(since - 1)
+	}, w)
+}

helper/max_since_test.go

@@ -0,0 +1,27 @@
+package helper
+
+import (
+	"testing"
+)
+
+func TestMaxSince(t *testing.T) {
+	input := SliceToChan([]int{48, 49, 47, 52, 52, 52, 53, 50, 55})
+	expected := SliceToChan([]int{0, 0, 1, 0, 1, 2, 0, 1, 0})
+	actual := MaxSince(input, 3)
+
+	err := CheckEquals(actual, expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestMaxSinceAtEnd(t *testing.T) {
+	input := SliceToChan([]int{48, 49, 47, 52, 52, 52, 52})
+	expected := SliceToChan([]int{0, 0, 1, 0, 1, 2, 2})
+	actual := MaxSince(input, 3)
+
+	err := CheckEquals(actual, expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

helper/min_since.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2021-2024 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package helper
+
+import (
+	"slices"
+)
+
+// MinSince returns a channel of T indicating since when
+// (number of previous values) the respective value was the minimum.
+func MinSince[T Number](c <-chan T, w int) <-chan T {
+	return Window(c, func(w []T, i int) T {
+		since := 0
+		found := false
+		m := slices.Min(w)
+		SlicesReverse(w, i, func(n T) bool {
+			if found && n > m {
+				return false
+			}
+			since++
+			if n == m {
+				found = true
+			}
+			return true
+		})
+		return T(since - 1)
+	}, w)
+}

helper/min_since_test.go

@@ -0,0 +1,36 @@
+package helper
+
+import "testing"
+
+func TestMinSince(t *testing.T) {
+	input := SliceToChan([]int{48, 50, 50, 50, 49, 49, 51})
+	expected := SliceToChan([]int{0, 1, 2, 2, 0, 1, 2})
+	actual := MinSince(input, 3)
+
+	err := CheckEquals(actual, expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestMinSinceAtEnd(t *testing.T) {
+	input := SliceToChan([]int{48, 50, 50, 50, 49, 49, 49})
+	expected := SliceToChan([]int{0, 1, 2, 2, 0, 1, 2})
+	actual := MinSince(input, 3)
+
+	err := CheckEquals(actual, expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestMinSinceFromStart(t *testing.T) {
+	input := SliceToChan([]int{1, 1, 3})
+	expected := SliceToChan([]int{0, 1, 2})
+	actual := MinSince(input, 3)
+
+	err := CheckEquals(actual, expected)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

helper/slices_reverse.go

@@ -0,0 +1,21 @@
+package helper
+
+// SlicesReverse loops through a slice in reverse order starting from the given index.
+// The given function is called for each element in the slice. If the function returns false,
+// the loop is terminated.
+func SlicesReverse[T any](r []T, i int, f func(T) bool) {
+	l := len(r)
+	if l == 0 || i < 0 || i >= l {
+		return
+	}
+	for m := i - 1; m >= 0; m-- {
+		if !f(r[m]) {
+			return
+		}
+	}
+	for m := l - 1; m >= i; m-- {
+		if !f(r[m]) {
+			return
+		}
+	}
+}

helper/slices_reverse_test.go

@@ -0,0 +1,32 @@
+package helper
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestSlicesReverseSimple(t *testing.T) {
+	input := []int{1, 2, 3, 4}
+	expected := []int{4, 3, 2, 1}
+	actual := make([]int, 0, len(input))
+	SlicesReverse(input, 0, func(i int) bool {
+		actual = append(actual, i)
+		return true
+	})
+	if !slices.Equal(actual, expected) {
+		t.Fatal("not equal")
+	}
+}
+
+func TestSlicesReverseMiddle(t *testing.T) {
+	input := []int{1, 2, 3, 4}
+	expected := []int{2, 1, 4, 3}
+	actual := make([]int, 0, len(input))
+	SlicesReverse(input, 2, func(i int) bool {
+		actual = append(actual, i)
+		return true
+	})
+	if !slices.Equal(actual, expected) {
+		t.Fatal("not equal")
+	}
+}