Python cross.cross_below函数代码示例

 def onBars(self, bars):
     if self.__position != None and self.__position.getReturn() < -0.05:
         self.__position.exitMarket()
         
     # If a position was not opened, check if we should enter a long position.
     if self.__position is None:
         ds = self.getFeed().getDataSeries(self.__instrument).getCloseDataSeries()
         if self.touchBottom(): # and LINEARREG(ds, 20)[1] > 0:
             shares = int(self.getBroker().getCash() * 0.9 / bars[self.__instrument].getPrice())
             # Enter a buy market order. The order is good till canceled.
             self.__position = self.enterShort(self.__instrument, shares, True)
             self.__pos_kind = "Short"
             print str(bars[self.__instrument].getDateTime()) + " " + "buy Short"
         elif self.touchTop(): # and LINEARREG(ds, 20)[1] < 0:
             shares = int(self.getBroker().getCash() * 0.9 / bars[self.__instrument].getPrice())
             # Enter a buy market order. The order is good till canceled.
             self.__position = self.enterLong(self.__instrument, shares, True)
             self.__pos_kind = "Long"
             print str(bars[self.__instrument].getDateTime()) + " " + "buy Long"
         return
     # Check if we have to exit the position.
     elif (not self.__position.exitActive()):
         if self.__pos_kind == "Long" and (cross.cross_below(self.__prices, self.__sma, -2) > 0 or self.touchBottom()):
             self.__position.exitMarket() #Long exit
             print str(bars[self.__instrument].getDateTime()) + " " + "exit " + self.__pos_kind
         elif self.__pos_kind == "Short" and (cross.cross_above(self.__prices, self.__sma, -2) > 0 or self.touchTop()):
             self.__position.exitMarket() #Short exit
             print str(bars[self.__instrument].getDateTime()) + " " + "exit " + self.__pos_kind

    def onBars(self, bars):
        for instrument, bar in bars.items():
            infoout = None
            if cross.cross_below(self.__shorttrix[instrument],
                                 self.__longtrix[instrument]) > 0:
                # If the derivative crosses above zero (deriv - -> +),
                # buy the instrument.
                now_cash, now_shares = self.inventory(instrument)
                buyqty = self.buyamount(
                    instrument, bar.getClose(), bar.getVolume(), now_cash, .2)
                self.marketOrder(instrument, buyqty)
                infoout = 'Order %d shares of %s @$%.2f. COH $%.2f' % (
                    buyqty, instrument, bar.getClose(), now_cash)

            elif cross.cross_above(self.__shorttrix[instrument],
                                   self.__longtrix[instrument]) > 0:
                # If the derivative crosses below zero (deriv + -> -),
                # sell the instrument.
                now_cash, now_shares = self.inventory(instrument)
                if now_shares > 0:
                    # Sell all shares
                    self.marketOrder(instrument, -now_shares)
                    infoout = 'Sell %d shares of %s @$%.2f. COH $%.2f' % (
                        now_shares, instrument, bar.getClose(), now_cash)
            if infoout and self.printinfo:
                self.info(infoout)

	def onBars(self, bars):
		if bars.getBar(self.__lead):
			if cross.cross_above(self.__adjClose, self.__slowSMA) == 1 and self.__pos == None:
				shares = self.__calculatePosSize()
				if shares:
					self.__pos = self.enterLong(self.__lag, shares)
			elif cross.cross_below(self.__adjClose, self.__fastSMA) == 1 and self.__pos != None:
				self.exitPosition(self.__pos)

	def onBars(self, bars):
		if self.__position is None:
			if cross.cross_above(self.__prices, self.__sma) >0:
				shares = int(self.getBroker().getCash() * 0.9 / bars[self.__instrument].getPrice())
				self.__position = self.enterLong(self.__instrument, shares, True)
		
		elif not self.__position.exitActive() and cross.cross_below(self.__prices,self.__sma) >0:
			self.__position.exitMarket()

 def onBars(self, bars):
     # If a position was not opened, check if we should enter a long position.
     if self.__position == None:
         if cross.cross_above(self.__adjClose, self.__sma) > 0:
             # Enter a buy market order for 10 shares. The order is good till canceled.
             self.__position = self.enterLong(self.__instrument, 10, True)
     # Check if we have to exit the position.
     elif cross.cross_below(self.__adjClose, self.__sma) > 0:
         self.__position.exit()

 def onBars(self, bars):
     # If a position was not opened, check if we should enter a long position.
     if self.__position is None:
         if cross.cross_above(self.__prices, self.__sma) > 0:
             shares = int(self.getBroker().getCash() * 0.9 / bars[self.__instrument].getPrice())
             # Enter a buy market order. The order is good till canceled.
             self.__position = self.enterLong(self.__instrument, shares, True)
     # Check if we have to exit the position.
     elif not self.__position.exitActive() and cross.cross_below(self.__prices, self.__exit_sma) > 0:
         self.__position.exitMarket()

 def enterShortSignal(self) :
     if self.__UpperBand[-1-self.__circ] is None:
         return False
     m1 = 0
     for i in range(self.__circ):
         if self.__macd[-i-1] >= self.__UpperBand[-i-2]:
             m1 += 1
     if m1 >= self.__circ-1 and cross.cross_below(self.__macd,self.__UpperBand)>0:
         return True
     else:
         return False

 def handle_data(self,bars):
     for instrument in bars.getInstruments():
         # If a position was not opened, check if we should enter a long position.
         if self.__position[instrument] is None:
             if cross.cross_above(self.__prices[instrument], self.__sma[instrument]) > 0:
                 shares = int(self.getBroker().getCash() * 0.9 / bars[instrument].getPrice())
                 # Enter a buy market order. The order is good till canceled.
                 self.__position[instrument] = self.enterLong(instrument, shares, True)
         # Check if we have to exit the position.
         elif not self.__position[instrument].exitActive() and cross.cross_below(self.__prices[instrument], self.__sma[instrument]) > 0:
             self.__position[instrument].exitMarket()

 def exitLongSignal(self) :
     if self.__UpperBand[-1-self.__circ] is None:
         return False
     m1 = 0
     for i in range(self.__circ):
         if self.__close[-i-1] >= self.__UpperBand[-i-2]:
             m1 += 1
     if m1 >= self.__circ-1 and cross.cross_below(self.__close,self.__UpperBand)>0:
         return True
     else:
         return False

    def testCrossBelowMany(self):
        count = 100
        values1 = [0 for i in range(count)]
        values2 = [-1 if i % 2 == 0 else 1 for i in range(count)]

        # Check first value
        self.assertEqual(cross.cross_below(values1, values2, 0, 0), 0)

        # Check every 2 values.
        period = 2
        for i in range(1, count):
            if i % 2 == 0:
                self.assertEqual(cross.cross_below(values1, values2, i - period + 1, i + 1), 0)
            else:
                self.assertEqual(cross.cross_below(values1, values2, i - period + 1, i + 1), 1)

        # Check every 4 values.
        period = 4
        for i in range(3, count):
            if i % 2 == 0:
                self.assertEqual(cross.cross_below(values1, values2, i - period + 1, i + 1), 1)
            else:
                self.assertEqual(cross.cross_below(values1, values2, i - period + 1, i + 1), 2)

        # Check for all values.
        self.assertEqual(cross.cross_below(values1, values2, 0, count), count / 2)

 def sellSignal(self, bars):
     #         a> 价格下穿20日均线 并且 价格<SMA价格的97%
     #         b> 亏损超10%
     #         c> RSI>80
     #         c> 价格小于买入后最高价的90%
     if self.__buy_pos is None or self.__sell_pos is None:
         high_period = 0
     else:
         high_period = self.__buy_pos - self.__sell_pos
     return (cross.cross_below(self.__prices, self.__sma20) and self.__prices[-1] < self.__sma[-1] * 0.97) \
            or (self.__last_buy * 0.9 > self.getResult()) \
            or (self.__rsi > 80) \
            or (self.__prices < highlow.High(self.__prices, high_period) * 0.9)

 def onBars(self, bars):        
     if self.__position is None:            
         if cross.cross_above(self.__Close, self.__sma) > 0:
             self.buyPrice = bars.getBar("btc").getClose()
             
             quantity = self.getBroker().getCash() / bars.getBar("btc").getClose() * 0.99
             self.__position = self.enterLong(self.__instrument, quantity)
             
             self.numOrder += 1
     elif cross.cross_below(self.__Close, self.__sma) > 0:
         # if (abs(self.buyPrice - bars.getBar("btc").getClose()) > 0.002 * (bars.getBar("btc").getClose())):
         if (abs(self.buyPrice - bars.getBar("btc").getClose()) > 10):            
             self.__position.exitMarket()

 def calcSignal(self):
     self.buySignal,self.sellSignal = {},{}
     for instrument in self.instruments:
         self.buySignal[instrument],self.sellSignal[instrument] = False,False
         #if(self.longAllowed):
         if self.longPosition[instrument] is None:
             #mid 无多仓，检查是否需要开多仓
             if cross.cross_above(self.__sma[instrument], self.__lma[instrument]) > 0:
                 self.buySignal[instrument] = True   
         #if(self.shortAllowed ):
         if self.shortPosition[instrument] is None:
             if cross.cross_below(self.__sma[instrument], self.__lma[instrument]) > 0:
                 self.sellSignal[instrument] = True 

    def onBars(self, bars):
        bar = bars.getBar("orcl")
        self.printDebug("%s: O=%s H=%s L=%s C=%s" % (bar.getDateTime(), bar.getOpen(), bar.getHigh(), bar.getLow(), bar.getClose()))

        if cross.cross_above(self.__fastSMADS, self.__slowSMADS) == 1:
            if self.__shortPos:
                self.exitShortPosition(bars, self.__shortPos)
            assert(self.__longPos is None)
            self.__longPos = self.enterLongPosition(bars)
        elif cross.cross_below(self.__fastSMADS, self.__slowSMADS) == 1:
            if self.__longPos:
                self.exitLongPosition(bars, self.__longPos)
            assert(self.__shortPos is None)
            self.__shortPos = self.enterShortPosition(bars)

 def enterShortSignal(self) :
     if self.__lastShortPos is not None:
         if self.__barNum-self.__lastShortPos<60:
             return 0
     if self.__UpperBand[-1-self.__circ] is None:
         return 0
     m1 = 0
     for i in range(self.__circ):
         if self.__close[-i-1] >= self.__UpperBand[-i-2]:
             m1 += 1
     if m1 >= self.__circ-1 and cross.cross_below(self.__close,self.__UpperBand)>0:
         return 1
     else:
         return 0