Fix Aroon Indicator

add highest and lowest

add window, use it from highest and lowest

add Max/MinSince with helper Window and SlicesReverse

change aroon indicator as suggested by #124

add a another test for Aroon

applied some ai suggesttions

update aroon strategy test data to match new actions

add another Aroon Test inspired by an R implementation

Update testdata to fix depending test of no_loss_strategy

fix depending testdata

Author: heiko

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")
+	}
+}