trend

Dec 24, 2024

Changes in this version

+ type WeightedClose struct

+ func NewWeightedClose[T helper.Number]() *WeightedClose[T]

+ func (*WeightedClose[T]) Compute(highs, lows, closes <-chan T) <-chan T

+ func (*WeightedClose[T]) IdlePeriod() int

+ func (*WeightedClose[T]) String() string

Dec 24, 2024

Changes in this version

+ const DefaultSmmaPeriod

+ type Smma struct

+ Period int

+ func NewSmmaWithPeriod[T helper.Number](period int) *Smma[T]

+ func NewSmma[T helper.Number]() *Smma[T]

+ func (s *Smma[T]) Compute(c <-chan T) <-chan T

+ func (s *Smma[T]) IdlePeriod() int

+ func (s *Smma[T]) String() string

Oct 12, 2024

Changes in this version

+ const DefaultEnvelopePercentage

+ const DefaultEnvelopePeriod

+ type Envelope struct

+ Ma Ma[T]

+ Percentage T

+ func NewEnvelopeWithEma[T helper.Number]() *Envelope[T]

+ func NewEnvelopeWithSma[T helper.Number]() *Envelope[T]

+ func NewEnvelope[T helper.Number](ma Ma[T], percentage T) *Envelope[T]

+ func (e *Envelope[T]) Compute(closings <-chan T) (<-chan T, <-chan T, <-chan T)

+ func (e *Envelope[T]) IdlePeriod() int

+ func (e *Envelope[T]) String() string

Jun 11, 2024

Changes in this version

+ const DefaultTsiFirstSmoothingPeriod

+ const DefaultTsiSecondSmoothingPeriod

type Kama

+ func NewKamaWith[T helper.Number](erPeriod, fastScPeriod, slowScPeriod int) *Kama[T]

+ type Tsi struct

+ FirstSmoothing Ma[T]

+ SecondSmoothing Ma[T]

+ func NewTsiWith[T helper.Number](firstSmoothingPeriod, secondSmoothingPeriod int) *Tsi[T]

+ func NewTsi[T helper.Number]() *Tsi[T]

+ func (t *Tsi[T]) Compute(closings <-chan T) <-chan T

+ func (t *Tsi[T]) IdlePeriod() int

+ func (t *Tsi[T]) String() string

Jun 10, 2024

Changes in this version

+ const DefaultKamaErPeriod

+ const DefaultKamaFastScPeriod

+ const DefaultKamaSlowScPeriod

+ type Kama struct

+ ErPeriod int

+ FastScPeriod int

+ SlowScPeriod int

+ func NewKama[T helper.Number]() *Kama[T]

+ func (k *Kama[T]) Compute(closings <-chan T) <-chan T

+ func (k *Kama[T]) IdlePeriod() int

+ func (k *Kama[T]) String() string

Jun 2, 2024

Changes in this version

+ const DefaultApoFastPeriod

+ const DefaultApoFastSmoothing

+ const DefaultApoSlowPeriod

+ const DefaultApoSlowSmoothing

+ const DefaultAroonPeriod

+ const DefaultCciPeriod

+ const DefaultEmaPeriod

+ const DefaultEmaSmoothing

+ const DefaultKdjMinMaxPeriod

+ const DefaultKdjSma1Period

+ const DefaultKdjSma2Period

+ const DefaultMacdPeriod1

+ const DefaultMacdPeriod2

+ const DefaultMacdPeriod3

+ const DefaultMassIndexPeriod1

+ const DefaultMassIndexPeriod2

+ const DefaultMassIndexPeriod3

+ const DefaultRmaPeriod

+ const DefaultSmaPeriod

+ const DefaultTrimaPeriod

+ const DefaultTrixPeriod

+ const DefaultVwmaPeriod

+ type Apo struct

+ FastPeriod int

+ FastSmoothing T

+ SlowPeriod int

+ SlowSmoothing T

+ func NewApo[T helper.Number]() *Apo[T]

+ func (apo *Apo[T]) Compute(c <-chan T) <-chan T

+ type Aroon struct

+ Period int

+ func NewAroon[T helper.Number]() *Aroon[T]

+ func (a *Aroon[T]) Compute(high, low <-chan T) (<-chan T, <-chan T)

+ type Bop struct

+ func NewBop[T helper.Number]() *Bop[T]

+ func (*Bop[T]) Compute(opening, high, low, closing <-chan T) <-chan T

+ type Cci struct

+ Period int

+ func NewCciWithPeriod[T helper.Number](period int) *Cci[T]

+ func NewCci[T helper.Number]() *Cci[T]

+ func (c *Cci[T]) Compute(highs, lows, closings <-chan T) <-chan T

+ func (c *Cci[T]) IdlePeriod() int

+ type Dema struct

+ Ema1 *Ema[T]

+ Ema2 *Ema[T]

+ func NewDema[T helper.Number]() *Dema[T]

+ func (d *Dema[T]) Compute(c <-chan T) <-chan T

+ func (d *Dema[T]) IdlePeriod() int

+ type Ema struct

+ Period int

+ Smoothing T

+ func NewEmaWithPeriod[T helper.Number](period int) *Ema[T]

+ func NewEma[T helper.Number]() *Ema[T]

+ func (e *Ema[T]) Compute(c <-chan T) <-chan T

+ func (e *Ema[T]) IdlePeriod() int

+ func (e *Ema[T]) String() string

+ type Hma struct

+ func NewHmaWithPeriod[T helper.Number](period int) *Hma[T]

+ func (h *Hma[T]) Compute(values <-chan T) <-chan T

+ func (h *Hma[T]) IdlePeriod() int

+ func (h *Hma[T]) String() string

+ type Kdj struct

+ MovingMax *MovingMax[T]

+ MovingMin *MovingMin[T]

+ Sma1 *Sma[T]

+ Sma2 *Sma[T]

+ func NewKdj[T helper.Number]() *Kdj[T]

+ func (kdj *Kdj[T]) Compute(high, low, closing <-chan T) (<-chan T, <-chan T, <-chan T)

+ func (kdj *Kdj[T]) IdlePeriod() int

+ type Ma interface

+ Compute func(<-chan T) <-chan T

+ IdlePeriod func() int

+ String func() string

+ type Macd struct

+ Ema1 *Ema[T]

+ Ema2 *Ema[T]

+ Ema3 *Ema[T]

+ func NewMacdWithPeriod[T helper.Number](period1, period2, period3 int) *Macd[T]

+ func NewMacd[T helper.Number]() *Macd[T]

+ func (m *Macd[T]) Compute(c <-chan T) (<-chan T, <-chan T)

+ func (m *Macd[T]) IdlePeriod() int

+ type MassIndex struct

+ Ema1 *Ema[T]

+ Ema2 *Ema[T]

+ MovingSum *MovingSum[T]

+ func NewMassIndex[T helper.Number]() *MassIndex[T]

+ func (m *MassIndex[T]) Compute(highs, lows <-chan T) <-chan T

+ func (m *MassIndex[T]) IdlePeriod() int

+ type Mlr struct

+ Mls *Mls[T]

+ func NewMlrWithPeriod[T helper.Number](period int) *Mlr[T]

+ func (m *Mlr[T]) Compute(x, y <-chan T) <-chan T

+ func (m *Mlr[T]) IdlePeriod() int

+ type Mls struct

+ Sum *MovingSum[T]

+ func NewMlsWithPeriod[T helper.Number](period int) *Mls[T]

+ func (m *Mls[T]) Compute(x, y <-chan T) (<-chan T, <-chan T)

+ func (m *Mls[T]) IdlePeriod() int

+ type MovingMax struct

+ Period int

+ func NewMovingMaxWithPeriod[T helper.Number](period int) *MovingMax[T]

+ func NewMovingMax[T helper.Number]() *MovingMax[T]

+ func (m *MovingMax[T]) Compute(c <-chan T) <-chan T

+ func (m *MovingMax[T]) IdlePeriod() int

+ type MovingMin struct

+ Period int

+ func NewMovingMinWithPeriod[T helper.Number](period int) *MovingMin[T]

+ func NewMovingMin[T helper.Number]() *MovingMin[T]

+ func (m *MovingMin[T]) Compute(c <-chan T) <-chan T

+ func (m *MovingMin[T]) IdlePeriod() int

+ type MovingSum struct

+ Period int

+ func NewMovingSumWithPeriod[T helper.Number](period int) *MovingSum[T]

+ func NewMovingSum[T helper.Number]() *MovingSum[T]

+ func (m *MovingSum[T]) Compute(c <-chan T) <-chan T

+ func (m *MovingSum[T]) IdlePeriod() int

+ type Rma struct

+ Period int

+ func NewRmaWithPeriod[T helper.Number](period int) *Rma[T]

+ func NewRma[T helper.Number]() *Rma[T]

+ func (r *Rma[T]) Compute(c <-chan T) <-chan T

+ func (r *Rma[T]) IdlePeriod() int

+ type Sma struct

+ Period int

+ func NewSmaWithPeriod[T helper.Number](period int) *Sma[T]

+ func NewSma[T helper.Number]() *Sma[T]

+ func (s *Sma[T]) Compute(c <-chan T) <-chan T

+ func (s *Sma[T]) IdlePeriod() int

+ func (s *Sma[T]) String() string

+ type Tema struct

+ Ema1 *Ema[T]

+ Ema2 *Ema[T]

+ Ema3 *Ema[T]

+ func NewTema[T helper.Number]() *Tema[T]

+ func (t *Tema[T]) Compute(c <-chan T) <-chan T

+ func (t *Tema[T]) IdlePeriod() int

+ type Trima struct

+ Period int

+ func NewTrima[T helper.Number]() *Trima[T]

+ func (t *Trima[T]) Compute(c <-chan T) <-chan T

+ func (t *Trima[T]) IdlePeriod() int

+ type Trix struct

+ Period int

+ func NewTrix[T helper.Number]() *Trix[T]

+ func (t *Trix[T]) Compute(c <-chan T) <-chan T

+ func (t *Trix[T]) IdlePeriod() int

+ type TypicalPrice struct

+ func NewTypicalPrice[T helper.Number]() *TypicalPrice[T]

+ func (*TypicalPrice[T]) Compute(high, low, closing <-chan T) <-chan T

+ type Vwma struct

+ Period int

+ func NewVwma[T helper.Number]() *Vwma[T]

+ func (v *Vwma[T]) Compute(closing, volume <-chan T) <-chan T

+ func (v *Vwma[T]) IdlePeriod() int

+ type Wma struct

+ Period int

+ func NewWmaWith[T helper.Number](period int) *Wma[T]

+ func (w *Wma[T]) Compute(values <-chan T) <-chan T

+ func (w *Wma[T]) IdlePeriod() int

+ func (w *Wma[T]) String() string