def bid_exceeds_offer_before_drop(data, max_drop = .00001, min_profit=0.00005, max_time = 10000, network_delay=30):
    ts = data.get_col('t')
    
    bids = data.get_col('bid/100ms')
    offers = data.get_col('offer/100ms')
    
    signal = np.zeros(len(ts))
    max_per_millisecond = analysis.density_per_millisecond(max_time-network_delay)
    find_index = analysis.find_future_index
    for idx in xrange(len(ts)):
        t = ts[idx]
        start_bid = bids[idx] 
        
        # average prices over the time window in which a buy message may reach 
        # the server
        find_index(ts, idx, t+network_delay, max_per_millisecond=max_per_millisecond)
        delayed_offers = offers[idx:last_delay_index] 
        avg_delayed_offer = np.mean(delayed_offers) 
        
        last_future_index = find_index(ts, idx, max_time, max_per_millisecond=max_per_millisecond)
        future_bids = bids[last_delay_index:last_future_index]
        
        sale_price_prct = (future_bids - avg_delayed_offer) / avg_delayed_offer
        profit_index = find_first (sale_price_prct >= min_profit)
        if profit_index:
            neg_bid_prct = (future_bids - start_bid) / start_bid 
            quit_index = find_first( neg_bid_prct <=  -max_drop)
            if quit_index is None or quit_index > profit_index: 
                signal[idx] = 1
        
    return signal
示例#2
0
def min_bid_exceeds_offer_single_timeframe(data,
                                           wait_time=1500,
                                           hold_time=250,
                                           target_prct=1.0001):
    ts = data['t']
    bids = data['bid/100ms']
    offers = data['offer/100ms']

    signal = np.zeros(len(ts))
    max_per_millisecond = analysis.density_per_millisecond(hold_time)
    last_time = wait_time + hold_time
    find_index = analysis.find_future_index
    for idx in xrange(len(ts)):
        t = ts[idx]
        start_offer = offers[idx]
        start_hold_idx = find_index(ts,
                                    idx,
                                    t + wait_time,
                                    max_per_millisecond=max_per_millisecond)
        # prefilter
        if bids[start_hold_idx - 1] > start_offer:
            target_price = target_prct * start_offer
            end_hold_idx = find_index(ts,
                                      idx,
                                      t + last_time,
                                      max_per_millisecond=max_per_millisecond)
            future_bids = bids[start_hold_idx:end_hold_idx]
            if len(future_bids) > 0 and np.min(future_bids) > target_price:
                signal[idx] = 1
    return signal
示例#3
0
def bid_exceeds_offer_before_drop(data,
                                  max_drop=.00001,
                                  min_profit=0.00005,
                                  max_time=10000,
                                  network_delay=30):
    ts = data.get_col('t')

    bids = data.get_col('bid/100ms')
    offers = data.get_col('offer/100ms')

    signal = np.zeros(len(ts))
    max_per_millisecond = analysis.density_per_millisecond(max_time -
                                                           network_delay)
    find_index = analysis.find_future_index
    for idx in xrange(len(ts)):
        t = ts[idx]
        start_bid = bids[idx]

        # average prices over the time window in which a buy message may reach
        # the server
        find_index(ts,
                   idx,
                   t + network_delay,
                   max_per_millisecond=max_per_millisecond)
        delayed_offers = offers[idx:last_delay_index]
        avg_delayed_offer = np.mean(delayed_offers)

        last_future_index = find_index(ts,
                                       idx,
                                       max_time,
                                       max_per_millisecond=max_per_millisecond)
        future_bids = bids[last_delay_index:last_future_index]

        sale_price_prct = (future_bids - avg_delayed_offer) / avg_delayed_offer
        profit_index = find_first(sale_price_prct >= min_profit)
        if profit_index:
            neg_bid_prct = (future_bids - start_bid) / start_bid
            quit_index = find_first(neg_bid_prct <= -max_drop)
            if quit_index is None or quit_index > profit_index:
                signal[idx] = 1

    return signal
def min_bid_exceeds_offer_single_timeframe(data, wait_time=1500, hold_time=250, target_prct=1.0001):
    ts = data['t']
    bids = data['bid/100ms']
    offers = data['offer/100ms']
    
    signal = np.zeros(len(ts))
    max_per_millisecond = analysis.density_per_millisecond(hold_time)
    last_time = wait_time+hold_time
    find_index = analysis.find_future_index 
    for idx in xrange(len(ts)):
        t = ts[idx]
        start_offer = offers[idx]
        start_hold_idx = find_index(ts, idx, t+wait_time, max_per_millisecond=max_per_millisecond)
        # prefilter 
        if bids[start_hold_idx-1] > start_offer:
            target_price = target_prct * start_offer
            end_hold_idx = find_index(ts, idx, t+last_time, max_per_millisecond=max_per_millisecond)
            future_bids = bids[start_hold_idx:end_hold_idx]
            if len(future_bids) > 0 and np.min(future_bids) > target_price: 
                signal[idx] = 1
    return signal