// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *PlusDiWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
// forward to the true range indicator first using previous data
ind.trueRange.ReceiveDOHLCVTick(tickData, streamBarIndex)
ind.periodCounter += 1
high := tickData.H()
low := tickData.L()
diffP := high - ind.previousHigh
diffM := ind.previousLow - low
if ind.lookbackPeriod == 1 {
if ind.periodCounter > 0 {
// forward to the true range indicator first using previous data
ind.trueRange.ReceiveDOHLCVTick(tickData, streamBarIndex)
var result float64
if (diffP > 0) && (diffP > diffM) && ind.currentTrueRange != 0.0 {
result = diffP / ind.currentTrueRange
} else {
result = 0
}
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
}
} else {
if ind.periodCounter > 0 {
if ind.periodCounter < ind.timePeriod {
if (diffP > 0) && (diffP > diffM) {
ind.previousPlusDM += diffP
}
ind.previousTrueRange += ind.currentTrueRange
} else {
var result float64
ind.previousTrueRange = ind.previousTrueRange - (ind.previousTrueRange / float64(ind.timePeriod)) + ind.currentTrueRange
if (diffP > 0) && (diffP > diffM) {
ind.previousPlusDM = ind.previousPlusDM - (ind.previousPlusDM / float64(ind.timePeriod)) + diffP
} else {
ind.previousPlusDM = ind.previousPlusDM - (ind.previousPlusDM / float64(ind.timePeriod))
}
if ind.previousTrueRange != 0.0 {
result = float64(100.0) * ind.previousPlusDM / ind.previousTrueRange
} else {
result = 0.0
}
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
}
}
}
ind.previousHigh = high
ind.previousLow = low
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *AdlWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
moneyFlowMultiplier := ((tickData.C() - tickData.L()) - (tickData.H() - tickData.C())) / (tickData.H() - tickData.L())
moneyFlowVolume := moneyFlowMultiplier * tickData.V()
result := ind.previousAdl + moneyFlowVolume
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
ind.previousAdl = result
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *PlusDmWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.periodCounter += 1
high := tickData.H()
low := tickData.L()
diffP := high - ind.previousHigh
diffM := ind.previousLow - low
if ind.lookbackPeriod == 1 {
if ind.periodCounter > 0 {
var result float64
if (diffP > 0) && (diffP > diffM) {
result = diffP
} else {
result = 0
}
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
}
} else {
if ind.periodCounter > 0 {
if ind.periodCounter < ind.timePeriod {
if (diffP > 0) && (diffP > diffM) {
ind.previousPlusDm += diffP
}
if ind.periodCounter == ind.timePeriod-1 {
result := ind.previousPlusDm
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
}
} else {
var result float64
if (diffP > 0) && (diffP > diffM) {
result = ind.previousPlusDm - (ind.previousPlusDm / float64(ind.timePeriod)) + diffP
} else {
result = ind.previousPlusDm - (ind.previousPlusDm / float64(ind.timePeriod))
}
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
ind.previousPlusDm = result
}
}
}
ind.previousHigh = high
ind.previousLow = low
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *AroonWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.periodCounter += 1
ind.periodHighHistory.PushBack(tickData.H())
ind.periodLowHistory.PushBack(tickData.L())
if ind.periodHighHistory.Len() > (1 + ind.GetLookbackPeriod()) {
var first = ind.periodHighHistory.Front()
ind.periodHighHistory.Remove(first)
first = ind.periodLowHistory.Front()
ind.periodLowHistory.Remove(first)
}
if ind.periodCounter >= 0 {
var aroonUp float64
var aroonDwn float64
var highValue float64 = math.SmallestNonzeroFloat64
var highIdx int = -1
var i int = (1 + ind.GetLookbackPeriod())
for e := ind.periodHighHistory.Front(); e != nil; e = e.Next() {
i--
var value float64 = e.Value.(float64)
if highValue <= value {
highValue = value
highIdx = i
}
}
var daysSinceHigh = highIdx
var lowValue float64 = math.MaxFloat64
var lowIdx int = -1
i = (1 + ind.GetLookbackPeriod())
for e := ind.periodLowHistory.Front(); e != nil; e = e.Next() {
i--
var value float64 = e.Value.(float64)
if lowValue >= value {
lowValue = value
lowIdx = i
}
}
var daysSinceLow = lowIdx
aroonUp = ind.aroonFactor * float64(ind.GetLookbackPeriod()-daysSinceHigh)
aroonDwn = ind.aroonFactor * float64(ind.GetLookbackPeriod()-daysSinceLow)
ind.UpdateIndicatorWithNewValue(aroonUp, aroonDwn, streamBarIndex)
}
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *StochOscWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.periodCounter += 1
ind.hhv.ReceiveTick(tickData.H(), streamBarIndex)
ind.llv.ReceiveTick(tickData.L(), streamBarIndex)
if ind.periodCounter >= 0 {
ind.currentFastK = 100.0 * ((tickData.C() - ind.currentPeriodLow) / (ind.currentPeriodHigh - ind.currentPeriodLow))
ind.slowKMA.ReceiveTick(ind.currentFastK, streamBarIndex)
}
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *TrueRangeWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.periodCounter += 1
if ind.periodCounter > 0 {
high := math.Max(tickData.H(), ind.previousClose)
low := math.Min(tickData.L(), ind.previousClose)
result := high - low
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
}
ind.previousClose = tickData.C()
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *Cci) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.periodCounter += 1
// calculate the typical price
typicalPrice := (tickData.H() + tickData.L() + tickData.C()) / 3.0
ind.currentTypicalPrice = typicalPrice
// push it to the history
ind.typicalPriceHistory.PushBack(typicalPrice)
// trim the history
if ind.typicalPriceHistory.Len() > ind.timePeriod {
var first = ind.typicalPriceHistory.Front()
ind.typicalPriceHistory.Remove(first)
}
// add it to the average
ind.typicalPriceAvg.ReceiveTick(typicalPrice, streamBarIndex)
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *SarWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.periodCounter += 1
if ind.hasInitialDirection == false {
ind.minusDM.ReceiveDOHLCVTick(tickData, streamBarIndex)
}
if ind.hasInitialDirection == true {
if ind.periodCounter == 0 {
if ind.isLong {
ind.extremePoint = tickData.H()
ind.previousSar = ind.previousLow
} else {
ind.extremePoint = tickData.L()
ind.previousSar = ind.previousHigh
}
// this is a trick for the first iteration only,
// the high low of the first bar will be used as the sar for the
// second bar. According tyo TALib this is the closest to Wilders
// originla idea of having the first entry day use the previous
// extreme, except now that extreme is solely derived from the first
// bar, supposedly Meta stock uses the same method.
ind.previousHigh = tickData.H()
ind.previousLow = tickData.L()
}
if ind.periodCounter >= 0 {
var result float64 = 0.0
if ind.isLong {
if tickData.L() <= ind.previousSar {
// switch to short if the low penetrates the Sar value
ind.isLong = false
ind.previousSar = ind.extremePoint
// make sure the overridden Sar is within yesterdays and todays range
if ind.previousSar < ind.previousHigh {
ind.previousSar = ind.previousHigh
}
if ind.previousSar < tickData.H() {
ind.previousSar = tickData.H()
}
result = ind.previousSar
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
// adjust af and extremePoint
ind.acceleration = ind.accelerationFactor
ind.extremePoint = tickData.L()
// calculate the new Sar
var diff float64 = ind.extremePoint - ind.previousSar
ind.previousSar = ind.previousSar + ind.acceleration*(diff)
// make sure the overridden Sar is within yesterdays and todays range
if ind.previousSar < ind.previousHigh {
ind.previousSar = ind.previousHigh
}
if ind.previousSar < tickData.H() {
ind.previousSar = tickData.H()
}
} else {
// no switch
// just output the current Sar
result = ind.previousSar
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
if tickData.H() > ind.extremePoint {
// adjust af and extremePoint
ind.extremePoint = tickData.H()
ind.acceleration += ind.accelerationFactor
if ind.acceleration > ind.accelerationFactorMax {
ind.acceleration = ind.accelerationFactorMax
}
}
// calculate the new Sar
var diff float64 = ind.extremePoint - ind.previousSar
ind.previousSar = ind.previousSar + ind.acceleration*(diff)
// make sure the overridden Sar is within yesterdays and todays range
if ind.previousSar > ind.previousLow {
ind.previousSar = ind.previousLow
}
if ind.previousSar > tickData.L() {
ind.previousSar = tickData.L()
}
}
} else {
// short
// switch to long if the high penetrates the Sar value
if tickData.H() >= ind.previousSar {
ind.isLong = true
ind.previousSar = ind.extremePoint
// make sure the overridden Sar is within yesterdays and todays range
if ind.previousSar > ind.previousLow {
ind.previousSar = ind.previousLow
}
if ind.previousSar > tickData.L() {
ind.previousSar = tickData.L()
}
result = ind.previousSar
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
// adjust af and extremePoint
ind.acceleration = ind.accelerationFactor
ind.extremePoint = tickData.H()
// calculate the new Sar
var diff float64 = ind.extremePoint - ind.previousSar
ind.previousSar = ind.previousSar + ind.acceleration*(diff)
// make sure the overridden Sar is within yesterdays and todays range
if ind.previousSar > ind.previousLow {
ind.previousSar = ind.previousLow
}
if ind.previousSar > tickData.L() {
ind.previousSar = tickData.L()
}
} else {
// no switch
// just output the current Sar
result = ind.previousSar
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
if tickData.L() < ind.extremePoint {
// adjust af and extremePoint
ind.extremePoint = tickData.L()
ind.acceleration += ind.accelerationFactor
if ind.acceleration > ind.accelerationFactorMax {
ind.acceleration = ind.accelerationFactorMax
}
}
// calculate the new Sar
var diff float64 = ind.extremePoint - ind.previousSar
ind.previousSar = ind.previousSar + ind.acceleration*(diff)
// make sure the overridden Sar is within yesterdays and todays range
if ind.previousSar < ind.previousHigh {
ind.previousSar = ind.previousHigh
}
if ind.previousSar < tickData.H() {
ind.previousSar = tickData.H()
}
}
}
}
}
ind.previousHigh = tickData.H()
ind.previousLow = tickData.L()
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *MedPriceWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
result := (tickData.H() + tickData.L()) / float64(2.0)
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *MfiWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.currentVolume = tickData.V()
ind.typicalPrice.ReceiveDOHLCVTick(tickData, streamBarIndex)
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *ObvWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.periodCounter += 1
if ind.periodCounter <= 0 {
ind.previousObv = tickData.V()
ind.previousClose = tickData.C()
result := ind.previousObv
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
}
if ind.periodCounter > 0 {
closePrice := tickData.C()
if closePrice > ind.previousClose {
ind.previousObv += tickData.V()
} else if closePrice < ind.previousClose {
ind.previousObv -= tickData.V()
}
result := ind.previousObv
ind.UpdateIndicatorWithNewValue(result, streamBarIndex)
ind.previousClose = tickData.C()
}
}
// ReceiveDOHLCVTick consumes a source data DOHLCV price tick
func (ind *StochRsiWithoutStorage) ReceiveDOHLCVTick(tickData gotrade.DOHLCV, streamBarIndex int) {
ind.rsi.ReceiveTick(tickData.C(), streamBarIndex)
}
