Esempio n. 1
0
class EMAVolume(Indicator):
    def __init__(self, period, cache_size=None):
        self._ema = EMA(period)

        super().__init__({
            'args': [period],
            'id': 'emavol',
            'name': 'EMA Vol(%f)' % period,
            'seed_period': period,
            'data_type': 'candle',
            'data_key': '*',
            'cache_size': cache_size
        })

    def reset(self):
        super().reset()
        self._ema.reset()

    def update(self, candle):
        self._ema.update(candle['vol'])
        ema = self._ema.v()

        if isfinite(ema):
            super().update(ema)

        return self.v()

    def add(self, candle):
        self._ema.add(candle['vol'])
        ema = self._ema.v()

        if isfinite(ema):
            super().add(ema)

        return self.v()
Esempio n. 2
0
class ChaikinOsc(Indicator):
    def __init__(self, short, long, cache_size=None):
        self._shortEMA = EMA(short, cache_size)
        self._longEMA = EMA(long, cache_size)
        self._adl = AccumulationDistribution()

        super().__init__({
            'args': [short, long, cache_size],
            'id': 'chaikinosc',
            'name': 'ChaikinOsc(%f, %f)' % (short, long),
            'seed_period': max([short, long]),
            'data_type': 'candle',
            'data_key': '*',
            'cache_size': cache_size
        })

    def reset(self):
        super().reset()
        self._shortEMA.reset()
        self._longEMA.reset()
        self._adl.reset()

    def update(self, candle):
        self._adl.update(candle)
        adl = self._adl.v()

        if not isfinite(adl):
            return

        self._shortEMA.update(adl)
        self._longEMA.update(adl)

        short = self._shortEMA.v()
        long = self._longEMA.v()

        if (isfinite(short) and isfinite(long)):
            super().update(short - long)

        return self.v()

    def add(self, candle):
        self._adl.add(candle)
        adl = self._adl.v()

        if not isfinite(adl):
            return

        self._shortEMA.add(adl)
        self._longEMA.add(adl)

        short = self._shortEMA.v()
        long = self._longEMA.v()

        if (isfinite(short) and isfinite(long)):
            super().add(short - long)

        return self.v()
class MassIndex(Indicator):
    def __init__(self, args=[]):
        [period] = args

        self._smoothing = period
        self._singleEMA = EMA([9])
        self._doubleEMA = EMA([9])
        self._buffer = []

        super().__init__({
            'args': args,
            'id': 'mi',
            'name': 'Mass Index(%f)' % period,
            'seed_period': 9 + period,
            'data_type': 'candle',
            'data_key': '*'
        })

    def reset(self):
        super().reset()
        self._singleEMA.reset()
        self._doubleEMA.reset()
        self._buffer = []

    def update(self, candle):
        high = candle['high']
        low = candle['low']

        self._singleEMA.update(high - low)
        self._doubleEMA.update(self._singleEMA.v())

        if len(self._buffer) == 0:
            self._buffer.append(self._singleEMA.v() / self._doubleEMA.v())
        else:
            self._buffer[-1] = self._singleEMA.v() / self._doubleEMA.v()

        if len(self._buffer) < self._smoothing:
            return self.v()

        return super().update(sum(self._buffer))

    def add(self, candle):
        high = candle['high']
        low = candle['low']

        self._singleEMA.add(high - low)
        self._doubleEMA.add(self._singleEMA.v())

        self._buffer.append(self._singleEMA.v() / self._doubleEMA.v())

        if len(self._buffer) > self._smoothing:
            del self._buffer[0]
        elif len(self._buffer) < self._smoothing:
            return self.v()

        return super().add(sum(self._buffer))
Esempio n. 4
0
class VO(Indicator):
    def __init__(self, args=[]):
        [shortPeriod, longPeriod] = args

        self._shortEMA = EMA([shortPeriod])
        self._longEMA = EMA([longPeriod])

        super().__init__({
            'args': args,
            'id': 'vo',
            'name': 'VO(%f, %f)' % (shortPeriod, longPeriod),
            'seed_period': longPeriod,
            'data_type': 'candle',
            'data_key': '*'
        })

    def reset(self):
        super().reset()
        self._shortEMA.reset()
        self._longEMA.reset()

    def update(self, candle):
        vol = candle['vol']

        self._shortEMA.update(vol)
        self._longEMA.update(vol)

        short = self._shortEMA.v()
        long = self._longEMA.v()

        if long == 0:
            return super().update(0)

        return super().update(((short - long) / long) * 100)

    def add(self, candle):
        vol = candle['vol']

        self._shortEMA.add(vol)
        self._longEMA.add(vol)

        short = self._shortEMA.v()
        long = self._longEMA.v()

        if long == 0:
            return super().add(0)

        return super().add(((short - long) / long) * 100)
Esempio n. 5
0
class TRIX(Indicator):
  def __init__(self, args = []):
    [ period ] = args

    self._emaFirst = EMA([period])
    self._emaSecond = EMA([period])
    self._emaThird = EMA([period])

    super().__init__({
      'args': args,
      'id': 'trix',
      'name': 'TRIX(%f)' % (period),
      'seed_period': (period * 3) + 1
    })
  
  def reset(self):
    super().reset()
    self._emaFirst.reset()
    self._emaSecond.reset()
    self._emaThird.reset()

  def update(self, v):
    self._emaFirst.update(v)
    self._emaSecond.update(self._emaFirst.v())
    self._emaThird.update(self._emaSecond.v())

    curr = self._emaThird.v()

    if not isfinite(curr) or self._emaThird.l() < 2:
      return self.v()

    prev = self._emaThird.prev()
   
    return super().update(((curr / prev) - 1) * 10000)

  def add(self, v):
    self._emaFirst.add(v)
    self._emaSecond.add(self._emaFirst.v())
    self._emaThird.add(self._emaSecond.v())

    curr = self._emaThird.v()

    if not isfinite(curr) or self._emaThird.l() < 2:
      return self.v()

    prev = self._emaThird.prev()
   
    return super().add(((curr / prev) - 1) * 10000)
Esempio n. 6
0
class PPO(Indicator):
    def __init__(self, args=[]):
        [shortPeriod, longPeriod] = args

        self._shortEMA = EMA([shortPeriod])
        self._longEMA = EMA([longPeriod])
        self._signalEMA = EMA([9])

        super().__init__({
            'args': args,
            'id': 'ppo',
            'name': 'PPO(%f, %f)' % (shortPeriod, longPeriod),
            'seed_period': longPeriod
        })

    def reset(self):
        super().reset()
        self._shortEMA.reset()
        self._longEMA.reset()
        self._signalEMA.reset()

    def update(self, v):
        self._shortEMA.update(v)
        self._longEMA.update(v)

        short = self._shortEMA.v()
        long = self._longEMA.v()
        ppo = 0 if long == 0 else ((short - long) / long) * 100

        self._signalEMA.update(ppo)

        return super().update(self._signalEMA.v())

    def add(self, v):
        self._shortEMA.add(v)
        self._longEMA.add(v)

        short = self._shortEMA.v()
        long = self._longEMA.v()
        ppo = 0 if long == 0 else ((short - long) / long) * 100

        self._signalEMA.add(ppo)

        return super().add(self._signalEMA.v())
class PPO(Indicator):
    def __init__(self, shortPeriod, longPeriod, cache_size=None):

        self._shortEMA = EMA(shortPeriod, cache_size)
        self._longEMA = EMA(longPeriod, cache_size)
        self._signalEMA = EMA(9, cache_size)

        super().__init__({
            'args': [shortPeriod, longPeriod, cache_size],
            'id': 'ppo',
            'name': 'PPO(%f, %f)' % (shortPeriod, longPeriod),
            'seed_period': longPeriod,
            'cache_size': cache_size
        })

    def reset(self):
        super().reset()
        self._shortEMA.reset()
        self._longEMA.reset()
        self._signalEMA.reset()

    def update(self, v):
        self._shortEMA.update(v)
        self._longEMA.update(v)

        short = self._shortEMA.v()
        long = self._longEMA.v()
        ppo = 0 if long == 0 else ((short - long) / long) * 100

        self._signalEMA.update(ppo)

        return super().update(self._signalEMA.v())

    def add(self, v):
        self._shortEMA.add(v)
        self._longEMA.add(v)

        short = self._shortEMA.v()
        long = self._longEMA.v()
        ppo = 0 if long == 0 else ((short - long) / long) * 100

        self._signalEMA.add(ppo)

        return super().add(self._signalEMA.v())
Esempio n. 8
0
class RSI(Indicator):
    def __init__(self, period, cache_size=None):
        self._p = period
        self._uEMA = EMA(period, cache_size)
        self._dEMA = EMA(period, cache_size)
        self._prevInputValue = None

        super().__init__({
            'args': [period, cache_size],
            'id': 'rsi',
            'name': 'RSI(%f)' % (period),
            'seed_period': period,
            'cache_size': cache_size
        })

    def reset(self):
        super().reset()

        self._prevInputValue = None
        self._uEMA.reset()
        self._dEMA.reset()

    def _ud(self, v):
        delta = 0

        if self._prevInputValue is None:
            delta = v - self._prevInputValue

        return {
            'u': delta if delta > 0 else 0,
            'd': -delta if delta < 0 else 0
        }

    def _rs(self):
        uAvg = self._uEMA.v()
        dAvg = self._dEMA.v()

        if not isfinite(uAvg) or not isfinite(dAvg) or dAvg == 0:
            return None
        else:
            return uAvg / dAvg

    def update(self, v):
        if self._prevInputValue is None:
            return

        ud = self._ud(v)
        self._uEMA.update(ud['u'])
        self._dEMA.update(ud['d'])
        rs = self._rs()

        if rs is not None:
            super().update(100 - (100 / (1 + rs)))

        return self.v()

    def add(self, v):
        if self._prevInputValue is None:
            self._prevInputValue = v

        ud = self._ud(v)
        self._uEMA.add(ud['u'])
        self._dEMA.add(ud['d'])
        rs = self._rs()

        if rs is not None:
            super().add(100 - (100 / (1 + rs)))
            self._prevInputValue = v

        return self.v()
Esempio n. 9
0
class MACD(Indicator):
    def __init__(self, fastMA, slowMA, signalMA, cache_size=None):
        self._slowEMA = EMA([slowMA])
        self._fastEMA = EMA([fastMA])
        self._signalEMA = EMA([signalMA])

        super().__init__({
            'args': [fastMA, slowMA, signalMA, cache_size],
            'id':
            'macd',
            'name':
            'MACD(%f, %f, %f)' % (fastMA, slowMA, signalMA),
            'seed_period':
            max([fastMA, slowMA]) + signalMA,
            'cache_size':
            cache_size
        })

    def reset(self):
        super().reset()

        self._slowEMA.reset()
        self._fastEMA.reset()
        self._signalEMA.reset()

    def update(self, v):
        slowEMA = self._slowEMA.update(v)
        fastEMA = self._fastEMA.update(v)

        if not isfinite(slowEMA) or not isfinite(fastEMA):
            return

        macd = fastEMA - slowEMA
        signalEMA = self._signalEMA.update(macd)

        if not isfinite(signalEMA):
            return

        histogram = macd - signalEMA

        super().update({
            'macd': macd,
            'signal': signalEMA,
            'histogram': histogram
        })

        return self.v()

    def add(self, v):
        slowEMA = self._slowEMA.add(v)
        fastEMA = self._fastEMA.add(v)

        if not isfinite(slowEMA) or not isfinite(fastEMA):
            return

        macd = fastEMA - slowEMA
        signalEMA = self._signalEMA.add(macd)

        if not isfinite(signalEMA):
            return

        histogram = macd - signalEMA

        super().add({
            'macd': macd,
            'signal': signalEMA,
            'histogram': histogram
        })

        return self.v()
class RVI(Indicator):
    def __init__(self, period, cache_size=None):
        self._stddev = StdDeviation(period, cache_size)
        self._uEMA = EMA(period, cache_size)
        self._dEMA = EMA(period, cache_size)
        self._prevInputValue = None

        super().__init__({
            'args': [period, cache_size],
            'id': 'rvi',
            'name': 'RVI(%f)' % period,
            'seed_period': period,
            'cache_size': cache_size
        })

    def reset(self):
        super().reset()
        self._prevInputValue = None
        self._stddev.reset()
        self._uEMA.reset()
        self._dEMA.reset()

    def ud(candlePrice, prevCandlePrice, stddev):
        if prevCandlePrice is None:
            return [0, 0]
        elif candlePrice > prevCandlePrice:
            return [stddev, 0]
        elif candlePrice < prevCandlePrice:
            return [0, stddev]
        else:
            return [0, 0]

    def update(self, v):
        if self._prevInputValue is None:
            return self.v()

        self._stddev.update(v)
        stddev = self._stddev.v()

        if not isfinite(stddev):
            return self.v()

        [u, d] = RVI.ud(v, self._prevInputValue, stddev)

        self._uEMA.update(u)
        self._dEMA.update(d)

        uSum = self._uEMA.v()
        dSum = self._dEMA.v()

        if uSum == dSum:
            return super().update(0)
        else:
            return super().update(100 * (uSum / (uSum + dSum)))

    def add(self, v):
        if self._prevInputValue is None:
            self._prevInputValue = v
            return self.v()

        self._stddev.add(v)
        stddev = self._stddev.v()

        if not isfinite(stddev):
            return self.v()

        [u, d] = RVI.ud(v, self._prevInputValue, stddev)

        self._uEMA.add(u)
        self._dEMA.add(d)

        uSum = self._uEMA.v()
        dSum = self._dEMA.v()

        if uSum == dSum:
            super().add(0)
        else:
            super().add(100 * (uSum / (uSum + dSum)))

        self._prevInputValue = v

        return self.v()
class TSI(Indicator):
    def __init__(self, long, short, signal, cache_size=None):
        self._pcEMA = EMA(long, cache_size)
        self._pc2EMA = EMA(short, cache_size)
        self._apcEMA = EMA(long, cache_size)
        self._apc2EMA = EMA(short, cache_size)
        self._sEMA = EMA(signal, cache_size)
        self._lastPrice = None

        super().__init__({
            'args': [short, signal, cache_size],
            'id': 'tsi',
            'name': 'TSI(%f, %f, %f)' % (long, short, signal),
            'seed_period': max([long, short, signal]),
            'cache_size': cache_size
        })

    def reset(self):
        super().reset()
        self._pcEMA.reset()
        self._pc2EMA.reset()
        self._apcEMA.reset()
        self._apc2EMA.reset()
        self._sEMA.reset()
        self._lastPrice = None

    def update(self, v):
        if self._lastPrice is None:
            return self.v()

        pc = v - self._lastPrice
        apc = abs(v - self._lastPrice)

        self._pcEMA.update(pc)
        self._apcEMA.update(apc)

        if self._pcEMA.ready():
            self._pc2EMA.update(self._pcEMA.v())
        else:
            return self.v()

        if self._apcEMA.ready():
            self._apc2EMA.update(self._apcEMA.v())
        else:
            return self.v()

        if not self._pc2EMA.ready() or not self._apc2EMA.ready():
            return self.v()

        tsi = 100 * (self._pc2EMA.v() / self._apc2EMA.v())
        self._sEMA.update(tsi)

        return super().update({'v': tsi, 'signal': self._sEMA.v()})

    def add(self, v):
        if self._lastPrice is None:
            self._lastPrice = v
            return self.v()

        pc = v - self._lastPrice
        apc = abs(v - self._lastPrice)

        self._pcEMA.add(pc)
        self._apcEMA.add(apc)

        if self._pcEMA.ready():
            self._pc2EMA.add(self._pcEMA.v())
        else:
            return self.v()

        if self._apcEMA.ready():
            self._apc2EMA.add(self._apcEMA.v())
        else:
            return self.v()

        if not self._pc2EMA.ready() or not self._apc2EMA.ready():
            return self.v()

        tsi = 100 * (self._pc2EMA.v() / self._apc2EMA.v())
        self._sEMA.add(tsi)

        super().add({'v': tsi, 'signal': self._sEMA.v()})

        self._lastPrice = v
        return self.v()