Choppiness Index (CHOP) added. (#333)

# Describe Request

Choppiness Index (CHOP) added.

Fixed #306 

# Change Type

New indicator.

Author: cinar

volatility/README.md

@@ -48,6 +48,12 @@ The information provided on this project is strictly for informational purposes
   - [func NewChandelierExit\[T helper.Number\]\(\) \*ChandelierExit\[T\]](<#NewChandelierExit>)
   - [func \(c \*ChandelierExit\[T\]\) Compute\(highs, lows, closings \<\-chan T\) \(\<\-chan T, \<\-chan T\)](<#ChandelierExit[T].Compute>)
   - [func \(c \*ChandelierExit\[T\]\) IdlePeriod\(\) int](<#ChandelierExit[T].IdlePeriod>)
+- [type Chop](<#Chop>)
+  - [func NewChop\[T helper.Number\]\(\) \*Chop\[T\]](<#NewChop>)
+  - [func NewChopWithPeriod\[T helper.Number\]\(period int\) \*Chop\[T\]](<#NewChopWithPeriod>)
+  - [func \(c \*Chop\[T\]\) Compute\(highs, lows, closings \<\-chan T\) \<\-chan T](<#Chop[T].Compute>)
+  - [func \(c \*Chop\[T\]\) IdlePeriod\(\) int](<#Chop[T].IdlePeriod>)
+  - [func \(c \*Chop\[T\]\) String\(\) string](<#Chop[T].String>)
 - [type DonchianChannel](<#DonchianChannel>)
   - [func NewDonchianChannel\[T helper.Number\]\(\) \*DonchianChannel\[T\]](<#NewDonchianChannel>)
   - [func NewDonchianChannelWithPeriod\[T helper.Number\]\(period int\) \*DonchianChannel\[T\]](<#NewDonchianChannelWithPeriod>)
@@ -139,6 +145,15 @@ const (
 )
 ```
 
+<a name="DefaultChopPeriod"></a>
+
+```go
+const (
+    // DefaultChopPeriod is the default period for the Choppiness Index (CHOP).
+    DefaultChopPeriod = 14
+)
+```
+
 <a name="DefaultDonchianChannelPeriod"></a>
 
 ```go
@@ -474,6 +489,67 @@ func (c *ChandelierExit[T]) IdlePeriod() int
 
 IdlePeriod is the initial period that Chandelier Exit won't yield any results.
 
+<a name="Chop"></a>
+## type [Chop](<https://github.com/cinar/indicator/blob/master/volatility/chop.go#L24-L27>)
+
+Chop represents the configuration parameters for calculating the Choppiness Index \(CHOP\). It is a technical analysis indicator that measures the market's trendiness or choppiness.
+
+```
+CHOP = 100 * LOG10( SUM(ATR(1), n) / (MAX(High, n) - MIN(Low, n)) ) / LOG10(n)
+```
+
+```go
+type Chop[T helper.Number] struct {
+    // Period is the period for the CHOP.
+    Period int
+}
+```
+
+<a name="NewChop"></a>
+### func [NewChop](<https://github.com/cinar/indicator/blob/master/volatility/chop.go#L30>)
+
+```go
+func NewChop[T helper.Number]() *Chop[T]
+```
+
+NewChop function initializes a new CHOP instance with the default parameters.
+
+<a name="NewChopWithPeriod"></a>
+### func [NewChopWithPeriod](<https://github.com/cinar/indicator/blob/master/volatility/chop.go#L35>)
+
+```go
+func NewChopWithPeriod[T helper.Number](period int) *Chop[T]
+```
+
+NewChopWithPeriod function initializes a new CHOP instance with the given period.
+
+<a name="Chop[T].Compute"></a>
+### func \(\*Chop\[T\]\) [Compute](<https://github.com/cinar/indicator/blob/master/volatility/chop.go#L42>)
+
+```go
+func (c *Chop[T]) Compute(highs, lows, closings <-chan T) <-chan T
+```
+
+Compute function takes channels of highs, lows, and closings, and computes the CHOP over the specified period.
+
+<a name="Chop[T].IdlePeriod"></a>
+### func \(\*Chop\[T\]\) [IdlePeriod](<https://github.com/cinar/indicator/blob/master/volatility/chop.go#L81>)
+
+```go
+func (c *Chop[T]) IdlePeriod() int
+```
+
+IdlePeriod is the initial period that CHOP won't yield any results.
+
+<a name="Chop[T].String"></a>
+### func \(\*Chop\[T\]\) [String](<https://github.com/cinar/indicator/blob/master/volatility/chop.go#L86>)
+
+```go
+func (c *Chop[T]) String() string
+```
+
+String function returns a string representation of the CHOP.
+
 <a name="DonchianChannel"></a>
 ## type [DonchianChannel](<https://github.com/cinar/indicator/blob/master/volatility/donchian_channel.go#L30-L36>)
 

volatility/chop.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2021-2026 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package volatility
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/cinar/indicator/v2/helper"
+	"github.com/cinar/indicator/v2/trend"
+)
+
+const (
+	// DefaultChopPeriod is the default period for the Choppiness Index (CHOP).
+	DefaultChopPeriod = 14
+)
+
+// Chop represents the configuration parameters for calculating the Choppiness Index (CHOP).
+// It is a technical analysis indicator that measures the market's trendiness or choppiness.
+//
+//	CHOP = 100 * LOG10( SUM(ATR(1), n) / (MAX(High, n) - MIN(Low, n)) ) / LOG10(n)
+type Chop[T helper.Number] struct {
+	// Period is the period for the CHOP.
+	Period int
+}
+
+// NewChop function initializes a new CHOP instance with the default parameters.
+func NewChop[T helper.Number]() *Chop[T] {
+	return NewChopWithPeriod[T](DefaultChopPeriod)
+}
+
+// NewChopWithPeriod function initializes a new CHOP instance with the given period.
+func NewChopWithPeriod[T helper.Number](period int) *Chop[T] {
+	return &Chop[T]{
+		Period: period,
+	}
+}
+
+// Compute function takes channels of highs, lows, and closings, and computes the CHOP over the specified period.
+func (c *Chop[T]) Compute(highs, lows, closings <-chan T) <-chan T {
+	highs2 := helper.Duplicate(highs, 2)
+	lows2 := helper.Duplicate(lows, 2)
+
+	// TR calculation
+	// Use previous closing by skipping highs and lows by one.
+	trHighs := helper.Skip(highs2[0], 1)
+	trLows := helper.Skip(lows2[0], 1)
+
+	tr := helper.Operate3(trHighs, trLows, closings, func(high, low, closing T) T {
+		return T(math.Max(float64(high-low), math.Max(float64(high-closing), float64(closing-low))))
+	})
+
+	sumTr := trend.NewMovingSumWithPeriod[T](c.Period).Compute(tr)
+
+	// MAX(High, n) and MIN(Low, n)
+	// They should be aligned with the TR bars (starting from bar 1).
+	rangeHighs := helper.Skip(highs2[1], 1)
+	rangeLows := helper.Skip(lows2[1], 1)
+
+	maxHigh := trend.NewMovingMaxWithPeriod[T](c.Period).Compute(rangeHighs)
+	minLow := trend.NewMovingMinWithPeriod[T](c.Period).Compute(rangeLows)
+
+	log10n := math.Log10(float64(c.Period))
+
+	chop := helper.Operate3(sumTr, maxHigh, minLow, func(sum, max, min T) T {
+		diff := float64(max - min)
+		if diff == 0 {
+			return 0
+		}
+
+		val := 100 * math.Log10(float64(sum)/diff) / log10n
+		return T(val)
+	})
+
+	return chop
+}
+
+// IdlePeriod is the initial period that CHOP won't yield any results.
+func (c *Chop[T]) IdlePeriod() int {
+	return c.Period
+}
+
+// String function returns a string representation of the CHOP.
+func (c *Chop[T]) String() string {
+	return fmt.Sprintf("CHOP(%d)", c.Period)
+}

volatility/chop_test.go

@@ -0,0 +1,89 @@
+// Copyright (c) 2021-2026 Onur Cinar.
+// The source code is provided under GNU AGPLv3 License.
+// https://github.com/cinar/indicator
+
+package volatility_test
+
+import (
+	"testing"
+
+	"github.com/cinar/indicator/v2/helper"
+	"github.com/cinar/indicator/v2/volatility"
+)
+
+func TestChop(t *testing.T) {
+	type Data struct {
+		High     float64 `header:"High"`
+		Low      float64 `header:"Low"`
+		Close    float64 `header:"Close"`
+		Expected float64 `header:"Expected"`
+	}
+
+	input, err := helper.ReadFromCsvFile[Data]("testdata/chop.csv")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	inputs := helper.Duplicate(input, 4)
+
+	highs := helper.Map(inputs[0], func(d *Data) float64 { return d.High })
+	lows := helper.Map(inputs[1], func(d *Data) float64 { return d.Low })
+	closings := helper.Map(inputs[2], func(d *Data) float64 { return d.Close })
+
+	chop := volatility.NewChop[float64]()
+	actuals := chop.Compute(highs, lows, closings)
+	actuals = helper.RoundDigits(actuals, 6)
+
+	inputs[3] = helper.Skip(inputs[3], chop.IdlePeriod())
+
+	for data := range inputs[3] {
+		actual, ok := <-actuals
+		if !ok {
+			t.Fatal("actuals channel closed early")
+		}
+		if actual != data.Expected {
+			t.Fatalf("actual %v expected %v for High=%v Low=%v Close=%v", actual, data.Expected, data.High, data.Low, data.Close)
+		}
+	}
+
+	if _, ok := <-actuals; ok {
+		t.Fatal("actuals channel should be closed")
+	}
+
+	if chop.String() != "CHOP(14)" {
+		t.Fatalf("expected CHOP(14) but got %s", chop.String())
+	}
+
+	if chop.IdlePeriod() != 14 {
+		t.Fatalf("expected 14 but got %d", chop.IdlePeriod())
+	}
+}
+
+func TestNewChop(t *testing.T) {
+	chop := volatility.NewChop[float64]()
+	if chop == nil {
+		t.Fatal("NewChop should not be nil")
+	}
+}
+
+func TestNewChopWithPeriod(t *testing.T) {
+	chop := volatility.NewChopWithPeriod[float64](10)
+	if chop.Period != 10 {
+		t.Fatalf("expected 10 but got %d", chop.Period)
+	}
+}
+
+func TestChopDiffZero(t *testing.T) {
+	highs := helper.SliceToChan([]float64{10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10})
+	lows := helper.SliceToChan([]float64{10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10})
+	closings := helper.SliceToChan([]float64{10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10})
+
+	chop := volatility.NewChopWithPeriod[float64](2)
+	actuals := chop.Compute(highs, lows, closings)
+
+	for actual := range actuals {
+		if actual != 0 {
+			t.Fatalf("expected 0 but got %v", actual)
+		}
+	}
+}