Exemplo n.º 1
0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(
            stocks
        ) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst  # get candlestick data
        DataTimeAxis = cst['1Day'].index

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]

        # buy with half capital at the first day
        ticker = TimeAxis[0]
        price = cst['1Day'].at[ticker, 'close']
        _, shares, cash = buy(code, price, str(ticker), ratio=0.5)
        share = shares[code]
        # start trading
        for ticker in TimeAxis[1:]:
            price = cst['1Day'].at[ticker, 'close']
            oneboardlot = 100 * price  # One board lot is 100 shares in Chinese market
            stock_equity = share * oneboardlot
            if (stock_equity <= cash * (1 - self.fall_ratio)):
                # make even: make the stock equity approximate to current cash
                _, shares, cash = buy(code,
                                      price,
                                      str(ticker),
                                      cash=(cash - stock_equity) / 2.0)
                share = shares[code]
            if (stock_equity >= cash * (1 + self.rise_ratio)):
                quantity_to_sell = int(
                    (stock_equity - cash) / 2.0 / oneboardlot)
                # make even: make the stock equity approximate to current cash
                shares, cash = sell(code, price, str(ticker), quantity_to_sell)
                share = shares[code]
Exemplo n.º 2
0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(stocks) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst # get candlestick data
        DataTimeAxis = cst['1Day'].index

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]

        # buy with half capital at the first day
        ticker = TimeAxis[0]
        price = cst['1Day'].at[ticker,'close']
        _, shares, cash = buy(code, price, str(ticker), ratio = 0.5) 
        share = shares[code]
        # start trading
        for ticker in TimeAxis[1:]:
            price = cst['1Day'].at[ticker,'close']
            oneboardlot = 100 * price # One board lot is 100 shares in Chinese market 
            stock_equity = share * oneboardlot
            if (stock_equity <= cash*(1-self.fall_ratio)): 
                # make even: make the stock equity approximate to current cash
                _, shares, cash = buy(code, price, str(ticker), cash = (cash-stock_equity)/2.0) 
                share = shares[code]
            if (stock_equity >= cash*(1+self.rise_ratio)):
                quantity_to_sell = int((stock_equity-cash)/2.0/oneboardlot)
                # make even: make the stock equity approximate to current cash
                shares, cash = sell(code, price, str(ticker), quantity_to_sell)
                share = shares[code]
Exemplo n.º 3
0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(stocks) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst # get candlestick data
        DataTimeAxis = cst['1Day'].index

        # MACD
        dif, dea, _ = self.MACD(cst['1Day']['close'].values)

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]
        df_macd = pd.DataFrame({'dif': dif[n_ahead:], 'dea': dea[n_ahead:]}, 
                    index = TimeAxis)

        # start trading
        start_flag, state_flag = 0, 0
        for ticker in TimeAxis:
            # skip null value at the beginning
            if np.isnan(df_macd.at[ticker, 'dif']) or np.isnan(df_macd.at[ticker, 'dea']):
                continue 
            # Skip the days of 'dif'>='dea' at the beginning. Those should be the days waiting for \
            # selling, not buying, thus not suitable for a start
            if (start_flag == 0) and (df_macd.at[ticker, 'dif'] >= df_macd.at[ticker, 'dea']):
                continue
            else:
                start_flag = 1
                
            # start trading
            if (start_flag == 1):
                price = cst['1Day'].at[ticker,'close']
                oneboardlot = 100 * price # One board lot is 100 shares in Chinese market 
                # the first buying
                if (state_flag == 0) and (price <= self.level) and\
                                         (df_macd.at[ticker, 'dif'] > df_macd.at[ticker, 'dea']): 
                    quantity, shares, cash = buy(code, price, str(ticker), ratio=0.5)
                    stock_equity = shares[code] * oneboardlot  
                    cost = quantity * oneboardlot
                    state_flag = 1
                    continue
                # the second buying if price falls
                if (state_flag == 1) and (stock_equity < cost*(1-self.fall_ratio)):
                    quantity, shares, cash = buy(code, price, str(ticker), ratio=1)
                    cost += quantity * oneboardlot
                    state_flag = 2
                    continue
                # sell                                        
                if (state_flag >= 1) and (df_macd.at[ticker, 'dif'] <= df_macd.at[ticker, 'dea']):
                    if (shares[code]*oneboardlot > cost*(1+self.rise_ratio)): 
                        shares, cash = sell(code, price, str(ticker), shares[code])
                        state_flag = 0
                        continue
Exemplo n.º 4
0
 def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
     assert len(stocks) >= self.N, \
         "This strategy requires at least N daily candlestick data of different stocks."
     self.init_stock_status(stocks, n_ahead)
     # start
     for ticker in szTimeAxis:
         # try to plant saplings
         if self.check_ready_to_buy(
                 stocks
         ):  # are we planting a sapling now? do the following if not
             ready_saplings = self.get_ready_saplings(stocks, ticker)
             if len(ready_saplings) > 0:
                 planting_sapling = ready_saplings.pop(0)
                 price = stocks[planting_sapling].cst['1Day'].at[ticker,
                                                                 'close']
                 stocks[planting_sapling].quantity, _, _ = buy(planting_sapling, price, str(ticker), \
                             ratio = self.ratios[self.n_saplings])
                 stocks[planting_sapling].buy_price = price
                 self.state_flags[planting_sapling] = 1
                 self.n_saplings += 1
         else:  # we are planting a sapling
             try:
                 price = stocks[planting_sapling].cst['1Day'].at[ticker,
                                                                 'close']
                 buy_price = stocks[planting_sapling].buy_price
                 status = self.check_planting_sapling_status(
                     planting_sapling, price, buy_price, ticker)
                 # remove dead sapling
                 if status == self.DEAD:
                     sell(planting_sapling, price, str(ticker),
                          stocks[planting_sapling].quantity)
                     self.state_flags[planting_sapling] = 0
                     self.n_saplings -= 1
                 # record alive sapling
                 if status == self.ALIVE:
                     self.state_flags[planting_sapling] = 2
             except KeyError:  # candlestick data is not available at this datetime
                 pass
         # try to harvest
         for code in stocks.keys():
             if (self.start_flags[code] == 1) and stocks[code].quantity > 0:
                 try:
                     if (self.state_flags[code] == 2) and (self.macd[code].at[ticker, 'dif'] \
                                     < self.macd[code].at[ticker, 'dea']):
                         price = stocks[code].cst['1Day'].at[ticker,
                                                             'close']
                         sell(code, price, str(ticker),
                              stocks[code].quantity)
                         self.state_flags[code] = 0
                         self.n_saplings -= 1
                 except KeyError:  # candlestick data is not available at this datetime
                     pass
Exemplo n.º 5
0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(
            stocks
        ) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst  # get candlestick data
        DataTimeAxis = cst['1Day'].index

        # Moving average
        maf = MA(cst['1Day']['close'].values, self.nfast)
        mas = MA(cst['1Day']['close'].values, self.nslow)

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]
        df_ma = pd.DataFrame(
            {
                'ma_fast': maf[n_ahead:],
                'ma_slow': mas[n_ahead:]
            },
            index=TimeAxis)

        #df_ma.plot()
        #plt.show()
        start_flag = 0
        hold_flag = 0
        for ticker in TimeAxis:
            # skip null value at the beginning
            if np.isnan(df_ma.at[ticker, 'ma_fast']) or np.isnan(
                    df_ma.at[ticker, 'ma_slow']):
                continue
            # skip the days of 'ma_fast'>='ma_slow' at the beginning
            # those should be the days waiting fo selling, not buying, thus not suitable for a start
            if (start_flag == 0) and (df_ma.at[ticker, 'ma_fast'] <=
                                      df_ma.at[ticker, 'ma_slow']):
                continue
            else:
                start_flag = 1
            # start trading
            if (start_flag == 1):
                price = cst['1Day'].at[ticker, 'close']
                if (hold_flag == 0) and (df_ma.at[ticker, 'ma_fast'] >
                                         df_ma.at[ticker, 'ma_slow']):
                    # quantity is the number of shares (unit: boardlot) you buy this time
                    quantity, _, _ = buy(code, price, str(ticker), ratio=1)
                    hold_flag = 1
                if (hold_flag == 1) and (df_ma.at[ticker, 'ma_fast'] <
                                         df_ma.at[ticker, 'ma_slow']):
                    # sell all the shares bought last time
                    sell(code, price, str(ticker), quantity)
                    hold_flag = 0
Exemplo n.º 6
0
 def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
     assert len(stocks) >= self.N, \
         "This strategy requires at least N daily candlestick data of different stocks."
     self.init_stock_status(stocks, n_ahead)
     # start
     for ticker in szTimeAxis:
         # try to plant saplings
         if self.check_ready_to_buy(stocks): # are we planting a sapling now? do the following if not
             ready_saplings = self.get_ready_saplings(stocks, ticker)
             if len(ready_saplings) > 0: 
                 planting_sapling = ready_saplings.pop(0)
                 price = stocks[planting_sapling].cst['1Day'].at[ticker,'close']
                 stocks[planting_sapling].quantity, _, _ = buy(planting_sapling, price, str(ticker), \
                             ratio = self.ratios[self.n_saplings])
                 stocks[planting_sapling].buy_price = price
                 self.state_flags[planting_sapling] = 1
                 self.n_saplings += 1
         else: # we are planting a sapling
             try:
                 price = stocks[planting_sapling].cst['1Day'].at[ticker,'close']
                 buy_price = stocks[planting_sapling].buy_price
                 status = self.check_planting_sapling_status(planting_sapling, price, buy_price, ticker)
                 # remove dead sapling   
                 if status == self.DEAD:
                     sell(planting_sapling, price, str(ticker), stocks[planting_sapling].quantity) 
                     self.state_flags[planting_sapling] = 0
                     self.n_saplings -= 1
                 # record alive sapling
                 if status == self.ALIVE:
                     self.state_flags[planting_sapling] = 2
             except KeyError: # candlestick data is not available at this datetime
                 pass
         # try to harvest
         for code in stocks.keys():
             if (self.start_flags[code] == 1) and stocks[code].quantity > 0:
                 try:
                     if (self.state_flags[code] == 2) and (self.macd[code].at[ticker, 'dif'] \
                                     < self.macd[code].at[ticker, 'dea']): 
                         price = stocks[code].cst['1Day'].at[ticker,'close']
                         sell(code, price, str(ticker), stocks[code].quantity) 
                         self.state_flags[code] = 0
                         self.n_saplings -= 1
                 except KeyError: # candlestick data is not available at this datetime
                     pass
Exemplo n.º 7
0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(stocks) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst # get candlestick data
        DataTimeAxis = cst['1Day'].index

        # Moving average
        maf = MA(cst['1Day']['close'].values, self.nfast)
        mas = MA(cst['1Day']['close'].values, self.nslow)

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]
        df_ma = pd.DataFrame({'ma_fast': maf[n_ahead:], 'ma_slow': mas[n_ahead:]}, 
                    index = TimeAxis)

        #df_ma.plot()
        #plt.show()
        start_flag = 0
        hold_flag = 0
        for ticker in TimeAxis:
            # skip null value at the beginning
            if np.isnan(df_ma.at[ticker, 'ma_fast']) or np.isnan(df_ma.at[ticker, 'ma_slow']):
                continue 
            # skip the days of 'ma_fast'>='ma_slow' at the beginning
            # those should be the days waiting fo selling, not buying, thus not suitable for a start
            if (start_flag == 0) and (df_ma.at[ticker, 'ma_fast'] <= df_ma.at[ticker, 'ma_slow']):
                continue
            else:
                start_flag = 1
            # start trading
            if (start_flag == 1):
                price = cst['1Day'].at[ticker,'close']
                if (hold_flag == 0) and (df_ma.at[ticker, 'ma_fast'] > df_ma.at[ticker, 'ma_slow']): 
                    # quantity is the number of shares (unit: boardlot) you buy this time 
                    quantity, _, _ = buy(code, price, str(ticker), ratio = 1) 
                    hold_flag = 1
                if (hold_flag == 1) and (df_ma.at[ticker, 'ma_fast'] < df_ma.at[ticker, 'ma_slow']): 
                    # sell all the shares bought last time
                    sell(code, price, str(ticker), quantity) 
                    hold_flag = 0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(
            stocks
        ) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst  # get candlestick data
        DataTimeAxis = cst['1Day'].index
        close = cst['1Day']['close'].values

        # ExtremePrice
        highest, lowest = self.ExtremePrice(close, self.m)

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]
        df_extreme = pd.DataFrame({'close': close[n_ahead:], 'highest': highest[n_ahead:], \
                                'lowest': lowest[n_ahead:]}, index = TimeAxis)

        #df_extreme.plot()
        #plt.show()
        hold_flag = 0
        for ticker in TimeAxis:
            # skip null value at the beginning
            if np.isnan(df_extreme.at[ticker, 'highest']) or np.isnan(
                    df_extreme.at[ticker, 'lowest']):
                continue
            # start trading
            price = cst['1Day'].at[ticker, 'close']
            if (hold_flag == 0) and (df_extreme.at[ticker, 'close'] >
                                     df_extreme.at[ticker, 'highest']):
                # quantity is the number of shares (unit: boardlot) you buy this time
                quantity, _, _ = buy(code, price, str(ticker), ratio=1)
                hold_flag = 1
            if (hold_flag == 1) and (df_extreme.at[ticker, 'close'] <
                                     df_extreme.at[ticker, 'lowest']):
                # sell all the shares bought last time
                sell(code, price, str(ticker), quantity)
                hold_flag = 0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(stocks) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst # get candlestick data
        DataTimeAxis = cst['1Day'].index
        close = cst['1Day']['close'].values

        # ExtremePrice
        highest, lowest = self.ExtremePrice(close, self.m)

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]
        df_extreme = pd.DataFrame({'close': close[n_ahead:], 'highest': highest[n_ahead:], \
                                    'lowest': lowest[n_ahead:]}, index = TimeAxis)

        #df_extreme.plot()
        #plt.show()

        # set position management and Risk control parameters
        # the proportion of your current cash for the first investment (if you earn
        # some profits, you would invest the rest of the cash).
        first_position = 0.25
        # stop_loss: stop out when your loss of 1th position reach this proportion 
        stop_loss = 0.04
        # lock_profit: if your floating earn of 1th position reach this proportion,
        #              enter state 2: sell all at a proper time that before you 
        #              lose the profits.
        lock_profit = 0.03

        # start
        start_flag = 0
        state_flag = 0
        for ticker in TimeAxis:
            # skip null value at the beginning
            if np.isnan(df_extreme.at[ticker, 'highest']) or np.isnan(df_extreme.at[ticker, 'lowest']):
                continue 
            # start trading
            price = cst['1Day'].at[ticker,'close']
            if (state_flag == 0) and (df_extreme.at[ticker, 'close'] > df_extreme.at[ticker, 'highest']): 
                # quantity is the number of shares (unit: boardlot) you buy this time 
                # record quantity1
                quantity1, _, _ = buy(code, price, str(ticker), ratio = first_position) 
                price1 = price # record the first buying price
                state_flag = 1
            if state_flag ==1:
                floating_earn_rate = (price - price1)/price1
                if floating_earn_rate <= -stop_loss:
                    # stop out
                    sell(code, price, str(ticker), quantity1)
                    state_flag = 0
                elif floating_earn_rate >= lock_profit:
                    # enter state 2: lock in profits
                    # record quantity2
                    quantity2, _, _ = buy(code, price, str(ticker), ratio = 1) 
                    price2 = first_position * price1 + (1-first_position) * price
                    state_flag = 2
                else: # just wait
                    pass
            if state_flag == 2:
                if (price < price2) or (df_extreme.at[ticker, 'close'] < df_extreme.at[ticker, 'lowest']): 
                    # sell all the shares bought last time
                    sell(code, price, str(ticker), quantity1 + quantity2) 
                    state_flag = 0
Exemplo n.º 10
0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(
            stocks
        ) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst  # get candlestick data
        DataTimeAxis = cst['1Day'].index

        # MACD
        dif, dea, _ = self.MACD(cst['1Day']['close'].values)

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]
        df_macd = pd.DataFrame({
            'dif': dif[n_ahead:],
            'dea': dea[n_ahead:]
        },
                               index=TimeAxis)

        # start trading
        start_flag, state_flag = 0, 0
        for ticker in TimeAxis:
            # skip null value at the beginning
            if np.isnan(df_macd.at[ticker, 'dif']) or np.isnan(
                    df_macd.at[ticker, 'dea']):
                continue
            # Skip the days of 'dif'>='dea' at the beginning. Those should be the days waiting for \
            # selling, not buying, thus not suitable for a start
            if (start_flag == 0) and (df_macd.at[ticker, 'dif'] >=
                                      df_macd.at[ticker, 'dea']):
                continue
            else:
                start_flag = 1

            # start trading
            if (start_flag == 1):
                price = cst['1Day'].at[ticker, 'close']
                oneboardlot = 100 * price  # One board lot is 100 shares in Chinese market
                # the first buying
                if (state_flag == 0) and (price <= self.level) and\
                                         (df_macd.at[ticker, 'dif'] > df_macd.at[ticker, 'dea']):
                    quantity, shares, cash = buy(code,
                                                 price,
                                                 str(ticker),
                                                 ratio=0.5)
                    stock_equity = shares[code] * oneboardlot
                    cost = quantity * oneboardlot
                    state_flag = 1
                    continue
                # the second buying if price falls
                if (state_flag == 1) and (stock_equity < cost *
                                          (1 - self.fall_ratio)):
                    quantity, shares, cash = buy(code,
                                                 price,
                                                 str(ticker),
                                                 ratio=1)
                    cost += quantity * oneboardlot
                    state_flag = 2
                    continue
                # sell
                if (state_flag >= 1) and (df_macd.at[ticker, 'dif'] <=
                                          df_macd.at[ticker, 'dea']):
                    if (shares[code] * oneboardlot > cost *
                        (1 + self.rise_ratio)):
                        shares, cash = sell(code, price, str(ticker),
                                            shares[code])
                        state_flag = 0
                        continue
Exemplo n.º 11
0
    def compute_trading_points(self, stocks, szTimeAxis, n_ahead):
        assert len(
            stocks
        ) == 1, "This strategy allows only a daily candlestick data of one stock."
        code = next(iter(stocks))
        cst = stocks[code].cst  # get candlestick data
        DataTimeAxis = cst['1Day'].index
        close = cst['1Day']['close'].values

        # ExtremePrice
        highest, lowest = self.ExtremePrice(close, self.m)

        # skip extra data
        TimeAxis = DataTimeAxis[n_ahead:]
        df_extreme = pd.DataFrame({'close': close[n_ahead:], 'highest': highest[n_ahead:], \
                                    'lowest': lowest[n_ahead:]}, index = TimeAxis)

        #df_extreme.plot()
        #plt.show()

        # set position management and Risk control parameters
        # the proportion of your current cash for the first investment (if you earn
        # some profits, you would invest the rest of the cash).
        first_position = 0.25
        # stop_loss: stop out when your loss of 1th position reach this proportion
        stop_loss = 0.04
        # lock_profit: if your floating earn of 1th position reach this proportion,
        #              enter state 2: sell all at a proper time that before you
        #              lose the profits.
        lock_profit = 0.03

        # start
        start_flag = 0
        state_flag = 0
        for ticker in TimeAxis:
            # skip null value at the beginning
            if np.isnan(df_extreme.at[ticker, 'highest']) or np.isnan(
                    df_extreme.at[ticker, 'lowest']):
                continue
            # start trading
            price = cst['1Day'].at[ticker, 'close']
            if (state_flag == 0) and (df_extreme.at[ticker, 'close'] >
                                      df_extreme.at[ticker, 'highest']):
                # quantity is the number of shares (unit: boardlot) you buy this time
                # record quantity1
                quantity1, _, _ = buy(code,
                                      price,
                                      str(ticker),
                                      ratio=first_position)
                price1 = price  # record the first buying price
                state_flag = 1
            if state_flag == 1:
                floating_earn_rate = (price - price1) / price1
                if floating_earn_rate <= -stop_loss:
                    # stop out
                    sell(code, price, str(ticker), quantity1)
                    state_flag = 0
                elif floating_earn_rate >= lock_profit:
                    # enter state 2: lock in profits
                    # record quantity2
                    quantity2, _, _ = buy(code, price, str(ticker), ratio=1)
                    price2 = first_position * price1 + (1 -
                                                        first_position) * price
                    state_flag = 2
                else:  # just wait
                    pass
            if state_flag == 2:
                if (price < price2) or (df_extreme.at[ticker, 'close'] <
                                        df_extreme.at[ticker, 'lowest']):
                    # sell all the shares bought last time
                    sell(code, price, str(ticker), quantity1 + quantity2)
                    state_flag = 0