Fix STC dividing by a near-zero denominator, producing -Inf/huge swings

STC = 100*(MACD-%K)/(%D-%K) divided by a denominator that's frequently
near zero (%K and %D are both stochastic-smoothed values of the same
MACD series and track each other closely), so real-world input could
yield -Inf or swings like 1435/-710 for an indicator documented to
oscillate 0-100.

The standard Schaff Trend Cycle algorithm instead applies the
rolling-min/max stochastic normalization *twice* -- once to MACD to
get %K1/%D1, then again to %D1 to get %K2/%D2 -- with STC = %D2. Both
stages stay bounded in [0, 100] by construction, since they're each a
range-normalized percentage smoothed by an SMA, not a division against
another stochastic-smoothed value.

TestStcFull's fixture was too short for the new, larger warm-up (two
stochastic passes need more lead-in than one), so it now generates its
own longer synthetic series instead of testdata/stochastic.csv.

Fixes #425

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: cinar

trend/stc.go

@@ -33,10 +33,17 @@ const (
 //	EMA2 = EMA(values, slowPeriod)
 //	MACD = EMA1 - EMA2
 //
-//	%K = Stochastic %K of MACD with kPeriod
-//	%D = Stochastic %D of MACD with dPeriod
+//	%K1, %D1 = Stochastic(MACD, kPeriod, dPeriod)
+//	%K2, %D2 = Stochastic(%D1, kPeriod, dPeriod)
 //
-//	STC = 100 * (MACD - %K) / (%D - %K)
+//	STC = %D2
+//
+// The Stochastic pass (rolling-min/max normalization to a 0-100 range,
+// then smoothed by an SMA) is applied twice, once to MACD and again to
+// the first pass's %D, the way the standard Schaff Trend Cycle algorithm
+// double-smooths MACD -- not once to MACD with a second division against
+// its own %K/%D, which isn't bounded to 0-100 and can divide by a
+// near-zero denominator.
 //
 // Example:
 //
@@ -96,47 +103,22 @@ func (s *Stc[T]) ComputeWithContext(ctx context.Context, c <-chan T) <-chan T {
 	c = helper.BufferedWithContext(ctx, c, s.SlowPeriod)
 	macd := s.Apo.ComputeWithContext(ctx, c)
 
-	macd = helper.BufferedWithContext(ctx, macd, s.Stochastic.Period)
-	inputs := helper.DuplicateWithContext(ctx, macd, 4)
-
-	movingMin := NewMovingMinWithPeriod[T](s.Stochastic.Period)
-	movingMax := NewMovingMaxWithPeriod[T](s.Stochastic.Period)
-
-	lowestSplice := helper.DuplicateWithContext(ctx, movingMin.ComputeWithContext(ctx, inputs[0]),
-		2,
-	)
+	// %K1 and %K2 are unused (STC only needs the doubly-smoothed %D), but
+	// each comes from the same internal duplicate fan-out as %D1/%D2, so
+	// it still has to be drained -- an unread duplicate branch blocks the
+	// shared producer, stalling %D1/%D2 too.
+	k1, d1 := s.Stochastic.ComputeWithContext(ctx, macd)
+	go helper.DrainWithContext(ctx, k1)
 
-	highest := movingMax.ComputeWithContext(ctx, inputs[1])
-
-	skipped := helper.SkipWithContext(ctx, inputs[2], movingMin.IdlePeriod())
-
-	kValues := helper.MultiplyByWithContext(ctx, helper.DivideWithContext(ctx, helper.SubtractWithContext(ctx, skipped, lowestSplice[0]),
-		helper.SubtractWithContext(ctx, highest, lowestSplice[1]),
-	),
-		100,
-	)
+	k2, d2 := s.Stochastic.ComputeWithContext(ctx, d1)
+	go helper.DrainWithContext(ctx, k2)
 
-	kDuplicate := helper.DuplicateWithContext(ctx, kValues, 2)
-
-	d := s.Stochastic.Sma.ComputeWithContext(ctx, kDuplicate[0])
-
-	kForStcSplice := helper.DuplicateWithContext(ctx,
-		helper.SkipWithContext(ctx, kDuplicate[1], s.Stochastic.Sma.IdlePeriod()),
-		2,
-	)
-
-	macdForStc := helper.SkipWithContext(ctx, inputs[3], s.Stochastic.IdlePeriod())
-
-	return helper.MultiplyByWithContext(ctx, helper.DivideWithContext(ctx, helper.SubtractWithContext(ctx, macdForStc, kForStcSplice[0]),
-		helper.SubtractWithContext(ctx, d, kForStcSplice[1]),
-	),
-		100,
-	)
+	return d2
 }
 
 // IdlePeriod is the initial period that STC won't yield any results.
 func (s *Stc[T]) IdlePeriod() int {
-	return s.Apo.IdlePeriod() + s.Stochastic.IdlePeriod()
+	return s.Apo.IdlePeriod() + 2*s.Stochastic.IdlePeriod()
 }
 
 // Compute wraps ComputeWithContext for backwards compatibility.

trend/stc_test.go

@@ -51,27 +51,23 @@ func TestStcSlowStochastic(t *testing.T) {
 	}
 }
 
+// TestStcFull checks that STC's output length matches IdlePeriod() once the
+// Stochastic pass is applied twice (once to MACD, again to its %D), which
+// needs more warm-up than the 19-row testdata/stochastic.csv fixture
+// (shared with TestStcSlowStochastic/TestStochastic) has, so this generates
+// its own longer synthetic series instead.
 func TestStcFull(t *testing.T) {
-	type Data struct {
-		Value float64
-		K     float64
-		D     float64
+	values := make([]float64, 200)
+	for i := range values {
+		values[i] = 100 + float64(i%7)
 	}
 
-	input, err := helper.ReadFromCsvFile[Data]("testdata/stochastic.csv")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	inputSlice := helper.ChanToSlice(input)
-	values := helper.Map(helper.SliceToChan(inputSlice), func(d *Data) float64 { return d.Value })
-
 	stc := trend.NewStcWithPeriod[float64](5, 10, 5, 3)
-	result := stc.Compute(values)
+	result := stc.Compute(helper.SliceToChan(values))
 
 	slice := helper.ChanToSlice(result)
 
-	expected := len(inputSlice) - stc.IdlePeriod()
+	expected := len(values) - stc.IdlePeriod()
 	if len(slice) != expected {
 		t.Fatalf("expected %d values, got %d", expected, len(slice))
 	}