added kelner

Author: Don Johnson

README.md

@@ -18,7 +18,8 @@ A **Go (Golang) library** of popular technical analysis indicators. This is a **
 12. [MFI (Money Flow Index)](#12-mfi-money-flow-index)  
 13. [Ultimate Oscillator (UO)](#13-ultimate-oscillator-uo)  
 14. [Ichimoku Kinko Hyo (Ichimoku Cloud)](#14-ichimoku-kinko-hyo-ichimoku-cloud)  
-15. [Parabolic SAR](#15-parabolic-sar)
+15. [Parabolic SAR](#15-parabolic-sar)  
+16. [Keltner Channels](#16-keltner-channels)
 
 ---
 
@@ -201,3 +202,18 @@ A **Go (Golang) library** of popular technical analysis indicators. This is a **
 - **Use Cases & Patterns**:  
   - **Trend-following** with automated trailing stops.  
   - Dots appear below price in an uptrend and above price in a downtrend; reversal triggers when price crosses the SAR level.
+
+---
+
+## 16. Keltner Channels
+
+- **Origin**: Based on work by Chester Keltner in the 1960s, later modified/popularized by Linda Bradford Raschke.  
+- **Description**: A volatility-based envelope indicator. The middle line is typically an EMA of typical price (High+Low+Close/3), and the upper/lower lines are offset by a multiple of ATR.  
+- **Common Parameters**:  
+  - `emaPeriod` for the middle line (e.g., 20).  
+  - `atrPeriod` (e.g., 10).  
+  - `mult` as a multiplier for the ATR offset (commonly around 2.0).  
+- **Use Cases & Patterns**:  
+  - **Volatility-based bands** that contract/expand with market moves.  
+  - Similar to Bollinger Bands but uses ATR instead of standard deviation.  
+  - Can signal breakouts when price strongly pierces the upper or lower channel.

indicators/keltner_channels.go

@@ -0,0 +1,75 @@
+package indicators
+
+import (
+	"errors"
+)
+
+// KeltnerChannels holds the configuration for computing the middle line (EMA of typical price)
+// and bands offset by a multiple of ATR.
+type KeltnerChannels struct {
+	EmaPeriod int     // Period for the EMA of typical price (middle line)
+	AtrPeriod int     // Period for the ATR calculation
+	Mult      float64 // Multiplier for the ATR offset
+}
+
+// NewKeltnerChannels creates a KeltnerChannels instance with a given EMA period, ATR period, and ATR multiplier.
+func NewKeltnerChannels(emaPeriod, atrPeriod int, multiplier float64) *KeltnerChannels {
+	return &KeltnerChannels{
+		EmaPeriod: emaPeriod,
+		AtrPeriod: atrPeriod,
+		Mult:      multiplier,
+	}
+}
+
+// Calculate returns three slices (middle, upper, lower), each the same length as the inputs.
+// - middle line = EMA of typical price
+// - upper line  = middle line + (mult * ATR)
+// - lower line  = middle line - (mult * ATR)
+//
+// The function needs high, low, close arrays of equal length. (Volume is not used here.)
+func (kc *KeltnerChannels) Calculate(high, low, close []float64) ([]float64, []float64, []float64, error) {
+	length := len(high)
+	if length != len(low) || length != len(close) {
+		return nil, nil, nil, errors.New("high, low, and close must have the same length")
+	}
+	if length == 0 {
+		return nil, nil, nil, errors.New("no price data provided")
+	}
+
+	// 1) Compute typical price: (High + Low + Close) / 3
+	typicalPrices := make([]float64, length)
+	for i := 0; i < length; i++ {
+		typicalPrices[i] = (high[i] + low[i] + close[i]) / 3.0
+	}
+
+	// 2) Compute EMA of typical price
+	emaCalc := NewEMA(kc.EmaPeriod)
+	emaValues, err := emaCalc.Calculate(typicalPrices)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	// 3) Compute ATR for the same length
+	// Note: We already have an ATR indicator that expects (high, low, close).
+	// We'll re-use it here.
+	atrCalc := NewATR(kc.AtrPeriod)
+	atrValues, err := atrCalc.Calculate(high, low, close)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	// 4) Build the final Keltner Channels
+	middle := make([]float64, length)
+	upper := make([]float64, length)
+	lower := make([]float64, length)
+
+	for i := 0; i < length; i++ {
+		m := emaValues[i]
+		a := atrValues[i]
+		middle[i] = m
+		upper[i] = m + kc.Mult*a
+		lower[i] = m - kc.Mult*a
+	}
+
+	return middle, upper, lower, nil
+}

tests/keltner_channels_test.go

@@ -0,0 +1,47 @@
+package tests
+
+import (
+	"math"
+	"testing"
+
+	"github.com/copyleftdev/indicator-libs/indicators"
+)
+
+func TestKeltnerChannels(t *testing.T) {
+	// Small sample data for demonstration.
+	// In reality, more bars would give a more reliable test.
+	highs := []float64{10, 10.5, 11, 11.2, 11.1, 11.3, 11.7, 12.0}
+	lows := []float64{9, 10.0, 10.2, 10.6, 10.8, 10.9, 11.1, 11.6}
+	closes := []float64{9.5, 10.2, 10.5, 11.0, 10.9, 11.1, 11.4, 11.8}
+
+	// Suppose we choose typical Keltner settings: EMA period=3, ATR period=3, multiplier=1.5
+	// These are small for testing on a short data set.
+	kc := indicators.NewKeltnerChannels(3, 3, 1.5)
+	mid, up, low, err := kc.Calculate(highs, lows, closes)
+	if err != nil {
+		t.Fatalf("Calculate returned error: %v", err)
+	}
+
+	// All outputs should match input length
+	if len(mid) != len(highs) || len(up) != len(highs) || len(low) != len(highs) {
+		t.Errorf("output slice lengths must match input: got mid=%d, up=%d, low=%d, want=%d",
+			len(mid), len(up), len(low), len(highs))
+	}
+
+	// Basic check: ensure no NaNs in final results (some early bars might be 0 or partial due to warm-up).
+	for i := range mid {
+		if math.IsNaN(mid[i]) {
+			t.Errorf("mid[%d] is NaN, expected a valid float", i)
+		}
+		if math.IsNaN(up[i]) {
+			t.Errorf("up[%d] is NaN, expected a valid float", i)
+		}
+		if math.IsNaN(low[i]) {
+			t.Errorf("low[%d] is NaN, expected a valid float", i)
+		}
+	}
+
+	// If you want to compare to known references, place them here.
+	t.Logf("Final Keltner Channels => mid=%.3f, up=%.3f, low=%.3f",
+		mid[len(mid)-1], up[len(up)-1], low[len(low)-1])
+}