def get_alt_price_daily():
    univ_ib_op = cr_cret.retrieve(univ_ib_eqidx_ext + "Open")
    univ_ib_cl = cr_cret.retrieve(univ_ib_eqidx_ext + "Close")
    tick_cols = univ_ib_cl.tick_cols()
    univ_ib_gd = cr_cret.retrieve(univ_ib_eqidx_ext + "ExchOpen")
    univ_ib_ap1 = univ_ib_cl.copy()
    univ_ib_ap2 = univ_ib_cl.copy()
    univ_ib_ap3 = univ_ib_cl.copy()
    for i in tick_cols:
        z = np.where(univ_ib_gd[i].values.astype("int") == 1)[0]
        if z.shape[0] > 0:
            univ_ib_cl_ = univ_ib_cl[i].values[z]
            univ_ib_op_ = univ_ib_op[i].values[z]
            univ_ib_ap1_ = filt.smth_price(univ_ib_op_, univ_ib_cl_, 120, 10, 10, 6, 1, 13)  # eats up 159 data points
            univ_ib_ap2_ = filt.smth_price(univ_ib_op_, univ_ib_cl_, 180, 15, 10, 8, 1, 13)  # eats up 226 data points
            univ_ib_ap3_ = filt.smth_price(univ_ib_op_, univ_ib_cl_, 140, 30, 10, 8, 1, 16)  # eats up 204 data points
            univ_ib_ap1[i] = np.nan
            univ_ib_ap2[i] = np.nan
            univ_ib_ap3[i] = np.nan
            univ_ib_ap1[list(z), i] = univ_ib_ap1_
            univ_ib_ap2[list(z), i] = univ_ib_ap2_
            univ_ib_ap3[list(z), i] = univ_ib_ap3_
            univ_ib_ap1[i] = filt.fill(univ_ib_ap1[i].values)
            univ_ib_ap2[i] = filt.fill(univ_ib_ap2[i].values)
            univ_ib_ap3[i] = filt.fill(univ_ib_ap3[i].values)
        else:
            univ_ib_ap1[i] = np.nan
            univ_ib_ap2[i] = np.nan
            univ_ib_ap3[i] = np.nan
    cr_cret.store(univ_ib_eqidx_ext + "AdjSer20D", univ_ib_ap1)
    cr_cret.store(univ_ib_eqidx_ext + "AdjSer30D", univ_ib_ap2)
    cr_cret.store(univ_ib_eqidx_ext + "AdjSer40D", univ_ib_ap3)
    return None
Example #2
0
def _get_alt_price(i):
    print('Calculating alternating prices for %s ' % i)
    univ_ib_ret = mkt_retrieve(i, 'Stats', 'Returns')
    univ_ib_op = univ_ib_ret['Open'].values
    univ_ib_cl = univ_ib_ret['Close'].values

    univ_ib_sprc = univ_ib_ret[['Contract', 'Date']]
    for smth in _smth:  # range(6, _smth + 1, 3)
        _sp = smth_param(smth)
        for days in range(1, _days+1):
            nb = filt.fst_nan(univ_ib_cl)
            ne = len(univ_ib_cl)
            univ_ib_ord = np.ones(ne, dtype=int) * 99
            univ_ib_ap = np.zeros(ne) * np.nan
            for k in range(0, days):
                univ_ib_ord[nb + days + k - 1:ne:days] = k
            for k in range(0, days):
                zk = np.where(univ_ib_ord == k)[0]
                cl_ = univ_ib_cl[list(zk)]
                op_ = univ_ib_op[list(zk - days + 1)]
                univ_ib_ap[list(zk)] = filt.smth_price(op_, cl_, _sp[0], _sp[1], _sp[2], _sp[3], 0, _sp[4])
            univ_ib_ap = filt.sma(univ_ib_ap, days)
            univ_ib_ap = filt.fill(univ_ib_ap)
            if (days < 10) and (smth < 10):
                univ_ib_sprc['D0'+str(days)+'S0'+str(smth)] = univ_ib_ap
            elif (days >= 10) and (smth < 10):
                univ_ib_sprc['D'+str(days)+'S0'+str(smth)] = univ_ib_ap
            elif (days < 10) and (smth >= 10):
                univ_ib_sprc['D0'+str(days)+'S'+str(smth)] = univ_ib_ap
            else:
                univ_ib_sprc['D'+str(days)+'S'+str(smth)] = univ_ib_ap
    del univ_ib_sprc['Contract']
    mkt_store(i, 'Stats', 'AltReturns', univ_ib_sprc)
def get_vol():
    univ_ib_op = cr_cret.retrieve(univ_ib_eqidx_ext + 'Open')
    univ_ib_hi = cr_cret.retrieve(univ_ib_eqidx_ext + 'High')
    univ_ib_lo = cr_cret.retrieve(univ_ib_eqidx_ext + 'Low')
    univ_ib_cl = cr_cret.retrieve(univ_ib_eqidx_ext + 'Close')
    tick_cols = univ_ib_cl.tick_cols()
    univ_ib_gd = cr_cret.retrieve(univ_ib_eqidx_ext + 'ExchOpen')
    for k in range(0, len(vol_list)):
        for j in vol_lookbacks:
            univ_ib_vol = univ_ib_cl.copy()
            if ('_cc' in vol_names[k]) or ('_tr' in vol_names[k]):
                for i in tick_cols:
                    univ_ib_vol[i] = np.nan
                    z = np.where(univ_ib_gd[i].values.astype('int') == 1)[0]
                    if z.shape[0] > 0:
                        univ_ib_vol[list(z), i] = vol_list[k](univ_ib_cl[i].values[z], j)
                        univ_ib_vol[i] = filt.fill(univ_ib_vol[i].values)
            elif '_g3' in vol_names[k]:
                for i in tick_cols:
                    univ_ib_vol[i] = np.nan
                    z = np.where(univ_ib_gd[i].values.astype('int') == 1)[0]
                    if z.shape[0] > 0:
                        univ_ib_vol[list(z), i] = vol_list[k](univ_ib_op[i].values[z], univ_ib_cl[i].values[z], j)
                        univ_ib_vol[i] = filt.fill(univ_ib_vol[i].values)
            else:
                for i in tick_cols:
                    univ_ib_vol[i] = np.nan
                    z = np.where(univ_ib_gd[i].values.astype('int') == 1)[0]
                    if z.shape[0] > 0:
                        univ_ib_vol[list(z), i] = vol_list[k](univ_ib_op[i].values[z], univ_ib_hi[i].values[z],
                                                              univ_ib_lo[i].values[z], univ_ib_cl[i].values[z], j)
                        univ_ib_vol[i] = filt.fill(univ_ib_vol[i].values)
            if j < 100:
                cr_vol_all.store(univ_ib_eqidx_ext + vol_names[k] + '_0' + str(j), univ_ib_vol)
            else:
                cr_vol_all.store(univ_ib_eqidx_ext + vol_names[k] + '_' + str(j), univ_ib_vol)
    return None
def get_vol_combo():
    _eqidx = get_all_equity_index_names()
    for k in range(0, len(vol_names)):
        # k = 0
        for j in vol_lookbacks:
            # j = vol_lookbacks[0]
            for i in _eqidx:
                # i = 'SP500'
                _data_ = mkt_retrieve(i, 'Stats', 'Volatility')[['Date', vol_names[k]+str(j)]]
                _data_.set_columns(['Date', i])
                if i == _eqidx[0]:
                    _data = _data_
                else:
                    _data = DataFrame.merge(_data, _data_, on='Date')
                _data['Date'] = _data['Date'].values.astype('int64')
                _data.sort(['Date'])
            tcl = _data.tick_cols()
            for i in tcl:
                _data[i] = filt.fill(_data[i].values)
            cr_cret.store(univ_ib_eqidx_ext + vol_names[k]+str(j), _data)
    return None
def get_vol_adj():
    univ_ib_cl = cr_cret.retrieve(univ_ib_eqidx_ext + 'Close')
    univ_ib_gd = cr_cret.retrieve(univ_ib_eqidx_ext + 'ExchOpen')
    tick_cols = univ_ib_cl.tick_cols()
    for k in range(0, len(vol_list)):
        print('Processing volatility %s' % vol_names[k])
        for j in vol_lookbacks:
            print('Currently working on lookback %s' % str(j))
            if j < 100:
                univ_ib_vol = cr_vol_all.retrieve(univ_ib_eqidx_ext + vol_names[k] + '_0' + str(j))
            else:
                univ_ib_vol = cr_vol_all.retrieve(univ_ib_eqidx_ext + vol_names[k] + '_' + str(j))
            for i in tick_cols:
                z = np.where(univ_ib_gd[i].values.astype('int') == 1)[0]
                if z.shape[0] > 0:
                    univ_ib_vol_ = univ_ib_vol[i].values[z]
                    univ_ib_cl_ = univ_ib_cl[i].values[z]
                    # find the beta
                    univ_ib_vol__ = filt.lag(univ_ib_vol_)
                    univ_ib_cl_ = np.abs(filt.ret(univ_ib_cl_))
                    regp = qreg4.roll_e_ladreg_1d(univ_ib_cl_, univ_ib_vol__, adj_lookback)
                    # get the beta-adjusted volatility
                    vol__ = univ_ib_vol_ * regp * _lapl_mult
                    # smooth out the volatility
                    vol__1 = filt.lrma(vol__, 61, lg=True)
                    vol__2 = filt.lrma(vol__, 7, lg=True)
                    vol__3 = vol__1 + filt.lrma(vol__2 - vol__1, 16)
                    # push the new volatility back
                    univ_ib_vol[i] = np.nan
                    univ_ib_vol[list(z), i] = vol__3
                    univ_ib_vol[i] = filt.fill(univ_ib_vol[i].values)
                else:
                    univ_ib_vol[i] = np.nan
            if j < 100:
                cr_vol_all_adj.store(univ_ib_eqidx_ext + vol_names[k] + '_0' + str(j), univ_ib_vol)
            else:
                cr_vol_all_adj.store(univ_ib_eqidx_ext + vol_names[k] + '_' + str(j), univ_ib_vol)
    return None
def get_measures():
    univ_ib_gd = cr_cret.retrieve(univ_ib_eqidx_ext + "ExchOpen")

    _prc_measures = [
        "Close",
        "AdjSer20D",
        "AdjSer30D",
        "AdjSer40D",
        "AdjSer20W",
        "AdjSer30W",
        "AdjSer40W",
        "AdjSer20M",
        "AdjSer30M",
        "AdjSer40M",
    ]
    _prc_measures_name = ["CLS", "A2D", "A3D", "A4D", "A2W", "A3W", "A4W", "A2M", "A3M", "A4M"]
    tick_cols = univ_ib_gd.tick_cols()

    for k in range(0, 10):  # for different prices
        univ_ib_pr = cr_cret.retrieve(univ_ib_eqidx_ext + _prc_measures[k])

        for j in range(5, 305, 5):
            univ_ib_lrbeta_lvl = nan_df(univ_ib_pr)
            univ_ib_qrbeta_lvl = nan_df(univ_ib_pr)
            univ_ib_qrgamm_lvl = nan_df(univ_ib_pr)

            univ_ib_lrbeta_ch0 = nan_df(univ_ib_pr)
            univ_ib_qrbeta_ch0 = nan_df(univ_ib_pr)
            univ_ib_qrgamm_ch0 = nan_df(univ_ib_pr)

            univ_ib_lrbeta_ch1 = nan_df(univ_ib_pr)
            univ_ib_qrbeta_ch1 = nan_df(univ_ib_pr)
            univ_ib_qrgamm_ch1 = nan_df(univ_ib_pr)

            univ_ib_lrbeta_ch2 = nan_df(univ_ib_pr)
            univ_ib_qrbeta_ch2 = nan_df(univ_ib_pr)
            univ_ib_qrgamm_ch2 = nan_df(univ_ib_pr)

            for i in tick_cols:
                z = np.where(univ_ib_gd[i].values.astype("int") == 1)[0]
                univ_ib_pr_ = univ_ib_pr[i].values[z]

                univ_ib_lrb_ = filt.lrbeta(univ_ib_pr_, j)
                univ_ib_lrbeta_lvl[list(z), i] = univ_ib_lrb_
                univ_ib_lrbeta_ch0[list(z), i] = filt.chg(univ_ib_lrb_, 1)
                univ_ib_lrbeta_ch1[list(z), i] = filt.chg(univ_ib_lrb_, 3)
                univ_ib_lrbeta_ch2[list(z), i] = filt.chg(univ_ib_lrb_, 5)

                univ_ib_qrb_ = filt.qrbeta(univ_ib_pr_, j)
                univ_ib_qrbeta_lvl[list(z), i] = univ_ib_qrb_
                univ_ib_qrbeta_ch0[list(z), i] = filt.chg(univ_ib_qrb_, 1)
                univ_ib_qrbeta_ch1[list(z), i] = filt.chg(univ_ib_qrb_, 3)
                univ_ib_qrbeta_ch2[list(z), i] = filt.chg(univ_ib_qrb_, 5)

                univ_ib_qrb_ = filt.qrgamma(univ_ib_pr_, j)
                univ_ib_qrgamm_lvl[list(z), i] = univ_ib_qrb_
                univ_ib_qrgamm_ch0[list(z), i] = filt.chg(univ_ib_qrb_, 1)
                univ_ib_qrgamm_ch1[list(z), i] = filt.chg(univ_ib_qrb_, 3)
                univ_ib_qrgamm_ch2[list(z), i] = filt.chg(univ_ib_qrb_, 5)

                univ_ib_lrbeta_lvl[i] = filt.fill(univ_ib_lrbeta_lvl[i].values)
                univ_ib_lrbeta_ch0[i] = filt.fill(univ_ib_lrbeta_ch0[i].values)
                univ_ib_lrbeta_ch1[i] = filt.fill(univ_ib_lrbeta_ch1[i].values)
                univ_ib_lrbeta_ch2[i] = filt.fill(univ_ib_lrbeta_ch2[i].values)

                univ_ib_qrbeta_lvl[i] = filt.fill(univ_ib_qrbeta_lvl[i].values)
                univ_ib_qrbeta_ch0[i] = filt.fill(univ_ib_qrbeta_ch0[i].values)
                univ_ib_qrbeta_ch1[i] = filt.fill(univ_ib_qrbeta_ch1[i].values)
                univ_ib_qrbeta_ch2[i] = filt.fill(univ_ib_qrbeta_ch2[i].values)

                univ_ib_qrgamm_lvl[i] = filt.fill(univ_ib_qrgamm_lvl[i].values)
                univ_ib_qrgamm_ch0[i] = filt.fill(univ_ib_qrgamm_ch0[i].values)
                univ_ib_qrgamm_ch1[i] = filt.fill(univ_ib_qrgamm_ch1[i].values)
                univ_ib_qrgamm_ch2[i] = filt.fill(univ_ib_qrgamm_ch2[i].values)

            if j < 10:
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_LVL_00" + str(j), univ_ib_lrbeta_lvl
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH0_00" + str(j), univ_ib_lrbeta_ch0
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH1_00" + str(j), univ_ib_lrbeta_ch1
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH2_00" + str(j), univ_ib_lrbeta_ch2
                )

                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_LVL_00" + str(j), univ_ib_qrbeta_lvl
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH0_00" + str(j), univ_ib_qrbeta_ch0
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH1_00" + str(j), univ_ib_qrbeta_ch1
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH2_00" + str(j), univ_ib_qrbeta_ch2
                )

                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_LVL_00" + str(j), univ_ib_qrgamm_lvl
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH0_00" + str(j), univ_ib_qrgamm_ch0
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH1_00" + str(j), univ_ib_qrgamm_ch1
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH2_00" + str(j), univ_ib_qrgamm_ch2
                )
            elif j < 100:
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_LVL_0" + str(j), univ_ib_lrbeta_lvl
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH0_0" + str(j), univ_ib_lrbeta_ch0
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH1_0" + str(j), univ_ib_lrbeta_ch1
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH2_0" + str(j), univ_ib_lrbeta_ch2
                )

                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_LVL_0" + str(j), univ_ib_qrbeta_lvl
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH0_0" + str(j), univ_ib_qrbeta_ch0
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH1_0" + str(j), univ_ib_qrbeta_ch1
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH2_0" + str(j), univ_ib_qrbeta_ch2
                )

                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_LVL_0" + str(j), univ_ib_qrgamm_lvl
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH0_0" + str(j), univ_ib_qrgamm_ch0
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH1_0" + str(j), univ_ib_qrgamm_ch1
                )
                cr_sig_mr_sg.store(
                    univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH2_0" + str(j), univ_ib_qrgamm_ch2
                )
            else:
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_LVL_" + str(j), univ_ib_lrbeta_lvl)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH0_" + str(j), univ_ib_lrbeta_ch0)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH1_" + str(j), univ_ib_lrbeta_ch1)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_LRB_CH2_" + str(j), univ_ib_lrbeta_ch2)

                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_LVL_" + str(j), univ_ib_qrbeta_lvl)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH0_" + str(j), univ_ib_qrbeta_ch0)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH1_" + str(j), univ_ib_qrbeta_ch1)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRB_CH2_" + str(j), univ_ib_qrbeta_ch2)

                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_LVL_" + str(j), univ_ib_qrgamm_lvl)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH0_" + str(j), univ_ib_qrgamm_ch0)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH1_" + str(j), univ_ib_qrgamm_ch1)
                cr_sig_mr_sg.store(univ_ib_eqidx_ext + _prc_measures_name[k] + "_QRG_CH2_" + str(j), univ_ib_qrgamm_ch2)
    return None