示例#1
0
    def compute_analytics(self, compute_dict):

        if not self.validate_compute_dict(compute_dict):
            return False

        self.num_datapoints = int(compute_dict['time'].shape[0])
        self.data['time'] = compute_dict['time']
        self.data['data'] = compute_dict['data']

        self.compute['tradeable'] = Analytics.market_hours(
            compute_dict['time'])

        for key, val in compute_dict.items():
            if key == 'sma':
                if isinstance(compute_dict[key], list):
                    self.compute[key] = []
                    for period in compute_dict[key]:
                        self.compute[key].append(
                            Analytics.moving_average(data=compute_dict['data'],
                                                     period=period))
                else:
                    continue

            elif key == 'derivative':
                if isinstance(compute_dict[key], list):
                    self.compute[key] = []
                    for sma_period, deriv_period in compute_dict[key]:
                        local_sma = Analytics.moving_average(
                            data=compute_dict['data'], period=sma_period)
                        self.compute[key].append(
                            Analytics.derivative(data=local_sma,
                                                 period=deriv_period))
                else:
                    continue

            elif key == 'Bollinger':
                if isinstance(compute_dict[key], list):
                    self.compute[key] = []
                    for anchor_period, oscillator_period, bollinger_period in compute_dict[
                            key]:
                        local_anchor = Analytics.moving_average(
                            data=compute_dict['data'], period=anchor_period)
                        local_oscillator = Analytics.moving_average(
                            data=compute_dict['data'],
                            period=oscillator_period)
                        self.compute[key].append(
                            Analytics.bollinger_bands(data=local_oscillator,
                                                      average=local_anchor,
                                                      period=bollinger_period))
                else:
                    continue

        self.analytics_up_to_date = True

        return True
示例#2
0
        print('Data file does not exist!')

    group_choice = np.random.choice(list(datafile.keys()))

    time = datafile[group_choice]['datetime'][...]
    data_open = datafile[group_choice]['open'][...]
    data_high = datafile[group_choice]['high'][...]
    data_low = datafile[group_choice]['low'][...]
    datafile.close()

    data = Analytics.candle_avg(open=data_open, high=data_high, low=data_low)
    candle_low_bollinger, candle_high_bollinger = Analytics.candle_bollinger_bands(
        open=data_open, high=data_high, low=data_low, average=data, period=30)

    sma = Analytics.moving_average(data=data, period=20)
    sma_low_bollinger, sma_high_bollinger = Analytics.bollinger_bands(
        data=data, average=sma)

    call_buy_locs, call_buy_price, \
    call_sell_locs, call_sell_price, \
    put_buy_locs, put_buy_price, \
    put_sell_locs, put_sell_price, \
    local_minimums, local_minimums_loc, \
    local_maximums, local_maximums_loc = SMA_strat(sma=sma,
                                                   bollinger_down=sma_low_bollinger,
                                                   bollinger_up=sma_high_bollinger,
                                                   candle=data,
                                                   candle_down=candle_low_bollinger,
                                                   candle_up=candle_high_bollinger)

    cut = np.min((call_buy_price.shape[0], call_sell_price.shape[0]))
    call_profits = (call_buy_price[:cut] - call_sell_price[:cut])
    def compute_analytics(self, data):

        # if not self.validate_compute_dict(self.compute_dict):
        #    return False

        self.data = data
        self.compute[enums.ComputeKeys.datetime] = np.array(
            data['datetime'].tolist())
        self.num_datapoints = int(
            self.compute[enums.ComputeKeys.datetime].shape[0])

        self.compute[enums.ComputeKeys.candle] = Analytics.candle_avg(
            open=np.array(data['open'].tolist()),
            high=np.array(data['high'].tolist()),
            low=np.array(data['low'].tolist()))

        self.compute[enums.ComputeKeys.tradeable] = Analytics.market_hours(
            self.compute[enums.ComputeKeys.datetime])

        for key, val in self.compute_dict.items():
            if key is enums.ComputeKeys.sma:
                if isinstance(val, list):
                    self.compute[key] = []
                    for period in val:
                        self.compute[key].append(
                            Analytics.moving_average(
                                data=self.compute[enums.ComputeKeys.candle],
                                period=period))
                else:
                    continue

            if key is enums.ComputeKeys.derivative:
                if isinstance(self.compute_dict[key], list):
                    self.compute[key] = []
                    for sma_period, deriv_period in val:
                        local_sma = Analytics.moving_average(
                            data=self.compute[enums.ComputeKeys.candle],
                            period=sma_period)
                        self.compute[key].append(
                            Analytics.derivative(data=local_sma,
                                                 period=deriv_period))
                else:
                    continue

            if key is enums.ComputeKeys.Bollinger:
                if isinstance(val, list):
                    self.compute[key] = []
                    for anchor_period, oscillator_period, Bollinger_period in val:
                        local_anchor = Analytics.moving_average(
                            data=self.compute[enums.ComputeKeys.candle],
                            period=anchor_period)
                        local_oscillator = Analytics.moving_average(
                            data=self.compute[enums.ComputeKeys.candle],
                            period=oscillator_period)
                        self.compute[key].append(
                            Analytics.bollinger_bands(data=local_oscillator,
                                                      average=local_anchor,
                                                      period=Bollinger_period))

        self.analytics_up_to_date = True

        return True
def slinger(ax, datafile, ticker, put_parameters, call_parameters):
    time = datafile[ticker]['datetime'][...]
    data_open = datafile[ticker]['open'][...]
    data_high = datafile[ticker]['high'][...]
    data_low = datafile[ticker]['low'][...]
    data_volume = datafile[ticker]['volume'][...]
    datafile.close()

    tradeable = Analytics.market_hours(t=time)
    print(np.sum(tradeable))
    candle = Analytics.candle_avg(open=data_open, high=data_high, low=data_low)
    candle_low_bollinger, candle_high_bollinger = Analytics.candle_bollinger_bands(
        open=data_open,
        high=data_high,
        low=data_low,
        average=candle,
        period=30)
    period = 30
    sma = Analytics.moving_average(data=candle, period=period)
    sma_short = Analytics.exp_moving_average(data=candle,
                                             alpha=.1,
                                             period=period // 3)
    sma_low_bollinger, sma_high_bollinger = Analytics.bollinger_bands(
        data=sma_short, average=sma)
    sma_d = Analytics.derivative(sma, period=period // 6)
    # sma_d = Analytics.moving_average(sma_d, period=period // 6)
    sma_dd = Analytics.second_derivative(sma, period=period)

    results_list = SMA_chaser.put_chaser_strat(
        time=time,
        sma=sma,
        bollinger_up=sma_high_bollinger,
        bollinger_down=sma_low_bollinger,
        sma_d=sma_d,
        candle=candle,
        candle_high=candle_high_bollinger,
        candle_low=candle_low_bollinger,
        parameters=put_parameters)

    put_buy_locs = results_list[0]
    put_buy_price = results_list[1]
    # print(put_buy_price)
    put_buy_option_price = results_list[2]
    print(put_buy_option_price)

    put_sell_locs = results_list[3]
    put_sell_price = results_list[4]
    # print(put_sell_price)
    put_sell_option_price = results_list[5]
    print(put_sell_option_price)

    put_profits = (put_sell_option_price - put_buy_option_price)

    put_percent = (put_sell_option_price -
                   put_buy_option_price) / put_buy_option_price
    print(put_percent)
    put_percent_avg = np.sum(put_percent) / put_percent.shape[0]
    print(put_percent_avg)

    # return_list.append(put_percent)
    # return_list.append(put_percent_avg)

    focus_top = time.shape[0] - 60 * 48
    focus_bot = time.shape[0] + 1
    focus_top = 0
    focus_bot = time.shape[0] + 1

    candle_rescaled = candle - np.sum(candle) / sma.shape[0]
    candle_rescaled = candle_rescaled / np.abs(candle_rescaled).max()
    sma_rescaled = sma - np.sum(sma) / sma.shape[0]
    sma_rescaled = sma_rescaled / np.abs(sma_rescaled).max()
    Bollinger_oscillator = 2 * (
        sma_short - sma) / np.absolute(sma_high_bollinger - sma_low_bollinger)
    '''
    ax[0].plot(time[focus_top:focus_bot], candle_rescaled, label='candle')
    ax[0].plot(time[focus_top:focus_bot], sma_rescaled, label='sma')
    ax[0].plot(time[focus_top:focus_bot], sma_d[focus_top:focus_bot] / np.abs(sma_d).max(), label='sma_d')
    ax[0].plot(time[focus_top:focus_bot], sma_dd[focus_top:focus_bot] / np.abs(sma_dd).max(), label='sma_dd')
    ax[0].legend()
    '''

    #################################################################################
    # plt.figure(figsize=(20, 10))
    # plt.suptitle('profitable trades')
    # ax[0].plot(time[tradeable], data_volume[tradeable], '.')

    ax_twin = ax[0].twinx()
    ax_twin.plot(time[tradeable], sma_d[tradeable])
    ax[0].plot(time[tradeable],
               candle[tradeable],
               '.',
               label=str(put_percent_avg))
    ax[0].plot(time[tradeable], sma[tradeable])
    ax[0].plot(time[tradeable], sma_low_bollinger[tradeable])
    ax[0].plot(time[tradeable], sma_high_bollinger[tradeable])
    ax[0].plot(time[tradeable], candle_low_bollinger[tradeable])
    ax[0].plot(time[tradeable], candle_high_bollinger[tradeable])

    profit_put_buy_locs = put_buy_locs[put_profits >= 0]
    put_cut = profit_put_buy_locs[profit_put_buy_locs > focus_top]
    ax[0].plot(time[put_cut], candle[put_cut], '>', color='r')

    profit_put_sell_locs = put_sell_locs[put_profits >= 0]
    put_cut = profit_put_sell_locs[profit_put_sell_locs > focus_top]
    ax[0].plot(time[put_cut], candle[put_cut], '<', color='g')

    ax[0].legend()

    #################################################################################
    # plt.figure(figsize=(20, 10))
    # plt.suptitle('loss trades')
    # ax[1].plot(time, data_volume, '.')
    ax[1].plot(time[tradeable],
               candle[tradeable],
               '.',
               label=str(put_percent_avg))
    ax[1].plot(time[tradeable], sma[tradeable])
    ax[1].plot(time[tradeable], sma_low_bollinger[tradeable])
    ax[1].plot(time[tradeable], sma_high_bollinger[tradeable])
    ax[1].plot(time[tradeable], candle_low_bollinger[tradeable])
    ax[1].plot(time[tradeable], candle_high_bollinger[tradeable])

    loss_put_buy_locs = put_buy_locs[put_profits < 0]
    put_cut = loss_put_buy_locs[loss_put_buy_locs > focus_top]
    ax[1].plot(time[put_cut], candle[put_cut], '>', color='r')

    loss_put_sell_locs = put_sell_locs[put_profits < 0]
    put_cut = loss_put_sell_locs[loss_put_sell_locs > focus_top]
    ax[1].plot(time[put_cut], candle[put_cut], '<', color='g')

    ax[1].legend()

    results_list = SMA_chaser.call_chaser_strat(
        time=time,
        sma=sma,
        bollinger_up=sma_high_bollinger,
        bollinger_down=sma_low_bollinger,
        sma_d=sma_d,
        candle=candle,
        candle_high=candle_high_bollinger,
        candle_low=candle_low_bollinger,
        parameters=call_parameters)

    call_buy_option_price = results_list[2]
    print(put_buy_option_price)

    call_sell_option_price = results_list[5]
    print(put_sell_option_price)

    call_percent = (call_sell_option_price -
                    call_buy_option_price) / call_buy_option_price
    print(call_percent)
    call_percent_avg = np.sum(call_percent) / call_percent.shape[0]
    print(call_percent_avg)

    percent_profits = np.concatenate((put_percent, call_percent))
    print(percent_profits)
    average_profit = np.sum(percent_profits) / percent_profits.shape[0]
    print(average_profit)

    return call_percent_avg
def slinger(ax, datafile, ticker, parameters):
    time = datafile[ticker]['datetime'][...]
    data_open = datafile[ticker]['open'][...]
    data_high = datafile[ticker]['high'][...]
    data_low = datafile[ticker]['low'][...]
    data_volume = datafile[ticker]['volume'][...]
    datafile.close()

    tradeable = Analytics.market_hours(t=time)
    print(np.sum(tradeable))
    candle = Analytics.candle_avg(open=data_open, high=data_high, low=data_low)
    candle_low_bollinger, candle_high_bollinger = Analytics.candle_bollinger_bands(
        open=data_open,
        high=data_high,
        low=data_low,
        average=candle,
        period=30)
    period = 30
    sma = Analytics.moving_average(data=candle, period=period)
    sma_short = Analytics.moving_average(data=candle, period=period // 3)
    sma_low_bollinger, sma_high_bollinger = Analytics.bollinger_bands(
        data=sma_short, average=sma)
    sma_d = Analytics.derivative(sma, period=period // 6)
    # sma_d = Analytics.moving_average(sma_d, period=period // 6)
    sma_dd = Analytics.second_derivative(sma, period=period)
    day_volatility = Analytics.day_volatility(data=candle, tradeable=tradeable)
    print('day volatility: {}'.format(day_volatility))

    # find the best strategy of given strategies:

    performance_list = []
    # parameters['option_type'] = position_class.OptionType.PUT
    for parameter in parameters:
        parameter['VIX'] = day_volatility
        results_list = PutSlingerBollinger.Bollinger_strat(
            time=time,
            sma=sma,
            sma_short=sma_short,
            bollinger_up=sma_high_bollinger,
            bollinger_down=sma_low_bollinger,
            sma_d=sma_d,
            candle=candle,
            candle_high=candle_high_bollinger,
            candle_low=candle_low_bollinger,
            parameters=parameter)

        put_buy_option_price = results_list[2]

        put_sell_option_price = results_list[5]

        put_percent = (put_sell_option_price -
                       put_buy_option_price) / put_buy_option_price

        put_percent[
            put_percent > 5] = 5  # put an upper bound on the option returns.

        put_percent_avg = np.sum(put_percent) / put_percent.shape[0]

        performance_list.append(put_percent_avg)

    performance_array = np.array(performance_list)
    print('performance_array: {}'.format(performance_array))
    best_perf_loc = np.where(
        performance_array == performance_array.max())[0][0]

    # hack the parameters to be the best choice for the rest of the function, this keeps recoding to a minimum:
    parameter = parameters[best_perf_loc]
    parameter = parameters[0]

    results_list = PutSlingerBollinger.Bollinger_strat(
        time=time,
        sma=sma,
        sma_short=sma_short,
        bollinger_up=sma_high_bollinger,
        bollinger_down=sma_low_bollinger,
        sma_d=sma_d,
        candle=candle,
        candle_high=candle_high_bollinger,
        candle_low=candle_low_bollinger,
        parameters=parameter)

    put_buy_locs = results_list[0]
    put_buy_price = results_list[1]
    put_buy_option_price = results_list[2]

    put_sell_locs = results_list[3]
    put_sell_price = results_list[4]
    put_sell_option_price = results_list[5]

    position_value = results_list[7]

    print('stock price at open: {}'.format(put_buy_price))
    print('strike price: {}'.format(results_list[6]))
    print('stock price at close: {}'.format(put_sell_price))

    print('option cost at open: {}'.format(put_buy_option_price))
    print('option cost at close: {}'.format(put_sell_option_price))

    put_profits = (put_sell_option_price - put_buy_option_price)

    put_percent = (put_sell_option_price -
                   put_buy_option_price) / put_buy_option_price
    print('option % gain: {}'.format(put_percent))

    put_percent[
        put_percent > 5] = 5  # put an upper bound on the option returns.

    print('position values: {}'.format(position_value))
    account_value = np.sum(position_value)
    print('account value ate EOD: {}'.format(account_value))

    # put_percent_avg = np.sum(put_percent) / put_percent.shape[0]

    put_percent_avg = np.sum(account_value) - 1
    print('average option % gain: {}'.format(put_percent_avg))

    results_list.append(put_percent)
    results_list.append(put_percent_avg)

    focus_top = time.shape[0] - 60 * 48
    focus_bot = time.shape[0] + 1
    focus_top = 0
    focus_bot = time.shape[0] + 1

    candle_rescaled = candle - np.sum(candle) / sma.shape[0]
    candle_rescaled = candle_rescaled / np.abs(candle_rescaled).max()
    sma_rescaled = sma - np.sum(sma) / sma.shape[0]
    sma_rescaled = sma_rescaled / np.abs(sma_rescaled).max()
    Bollinger_oscillator = 2 * (
        sma_short - sma) / np.absolute(sma_high_bollinger - sma_low_bollinger)

    minute_time = Analytics.minute_time(time)
    # print(minute_time)
    '''
    ax[0].plot(time[focus_top:focus_bot], candle_rescaled, label='candle')
    ax[0].plot(time[focus_top:focus_bot], sma_rescaled, label='sma')
    ax[0].plot(time[focus_top:focus_bot], sma_d[focus_top:focus_bot] / np.abs(sma_d).max(), label='sma_d')
    ax[0].plot(time[focus_top:focus_bot], sma_dd[focus_top:focus_bot] / np.abs(sma_dd).max(), label='sma_dd')
    ax[0].legend()
    '''

    #################################################################################
    # plt.figure(figsize=(20, 10))
    # plt.suptitle('profitable trades')
    # ax[0].plot(time[tradeable], data_volume[tradeable], '.')

    ax_twin = ax[0].twinx()
    ax_twin.plot(minute_time[tradeable], Bollinger_oscillator[tradeable])
    ax_twin.plot(minute_time[tradeable],
                 np.ones_like(minute_time[tradeable]) *
                 parameter['Bollinger_top'],
                 color='k')
    ax_twin.plot(minute_time[tradeable],
                 np.ones_like(minute_time[tradeable]) *
                 parameter['Bollinger_bot'],
                 color='k')

    ax[0].plot(minute_time[tradeable],
               candle[tradeable],
               '.',
               label=str(put_percent_avg))
    ax[0].plot(minute_time[tradeable], sma[tradeable])
    ax[0].plot(minute_time[tradeable], sma_low_bollinger[tradeable])
    ax[0].plot(minute_time[tradeable], sma_high_bollinger[tradeable])
    ax[0].plot(minute_time[tradeable], candle_low_bollinger[tradeable])
    ax[0].plot(minute_time[tradeable], candle_high_bollinger[tradeable])

    profit_put_buy_locs = put_buy_locs[put_profits >= 0]
    put_cut = profit_put_buy_locs[profit_put_buy_locs > focus_top]
    ax[0].plot(minute_time[put_cut], candle[put_cut], '>', color='k')

    profit_put_sell_locs = put_sell_locs[put_profits >= 0]
    put_cut = profit_put_sell_locs[profit_put_sell_locs > focus_top]
    ax[0].plot(minute_time[put_cut], candle[put_cut], '<', color='k')

    ax[0].legend()

    #################################################################################
    # plt.figure(figsize=(20, 10))
    # plt.suptitle('loss trades')
    # ax[1].plot(minute_time, data_volume, '.')

    ax_twin = ax[1].twinx()
    ax_twin.plot(minute_time[tradeable], Bollinger_oscillator[tradeable])
    ax_twin.plot(minute_time[tradeable],
                 np.ones_like(minute_time[tradeable]) *
                 parameter['Bollinger_top'],
                 color='k')
    ax_twin.plot(minute_time[tradeable],
                 np.ones_like(minute_time[tradeable]) *
                 parameter['Bollinger_bot'],
                 color='k')

    ax[1].plot(minute_time[tradeable],
               candle[tradeable],
               '.',
               label=str(put_percent_avg))
    ax[1].plot(minute_time[tradeable], sma[tradeable])
    ax[1].plot(minute_time[tradeable], sma_low_bollinger[tradeable])
    ax[1].plot(minute_time[tradeable], sma_high_bollinger[tradeable])
    ax[1].plot(minute_time[tradeable], candle_low_bollinger[tradeable])
    ax[1].plot(minute_time[tradeable], candle_high_bollinger[tradeable])

    loss_put_buy_locs = put_buy_locs[put_profits < 0]
    put_cut = loss_put_buy_locs[loss_put_buy_locs > focus_top]
    ax[1].plot(minute_time[put_cut], candle[put_cut], '>', color='k')

    loss_put_sell_locs = put_sell_locs[put_profits < 0]
    put_cut = loss_put_sell_locs[loss_put_sell_locs > focus_top]
    ax[1].plot(minute_time[put_cut], candle[put_cut], '<', color='k')

    ax[1].legend()

    return put_percent_avg, performance_array