Examples with IntFltPair suite.primitive.adt.pair.IntFltPair used on opensource projects

Example 1 with IntFltPair

use of suite.primitive.adt.pair.IntFltPair in project suite by stupidsing.

the class AnalyzeTimeSeriesTest method analyze.

private void analyze(float[] prices) {
    int length = prices.length;
    int log2 = Quant.log2trunc(length);
    double nYears = length * Trade_.invTradeDaysPerYear;
    float[] fds = dct.dct(Arrays.copyOfRange(prices, length - log2, length));
    float[] returns = ts.returns(prices);
    float[] logPrices = To.vector(prices, Math::log);
    float[] logReturns = ts.differences(1, logPrices);
    MeanVariance rmv = stat.meanVariance(returns);
    double variance = rmv.variance;
    double kelly = rmv.mean / variance;
    IntFltPair max = IntFltPair.of(Integer.MIN_VALUE, Float.MIN_VALUE);
    for (int i = 4; i < fds.length; i++) {
        float f = Math.abs(fds[i]);
        if (max.t1 < f)
            max.update(i, f);
    }
    IntFunction<BuySell> momFun = n -> {
        int d0 = 1 + n;
        int d1 = 1;
        return buySell(d -> Quant.sign(prices[d - d0], prices[d - d1])).start(d0);
    };
    IntFunction<BuySell> revert = d -> momFun.apply(d).scale(0f, -1f);
    IntFunction<BuySell> trend_ = d -> momFun.apply(d).scale(0f, +1f);
    BuySell[] reverts = To.array(8, BuySell.class, revert);
    BuySell[] trends_ = To.array(8, BuySell.class, trend_);
    BuySell tanh = buySell(d -> Tanh.tanh(3.2d * reverts[1].apply(d)));
    float[] holds = mt.hold(prices, 1f, 1f, 1f);
    float[] ma200 = ma.movingAvg(prices, 200);
    BuySell mat = buySell(d -> {
        int last = d - 1;
        return Quant.sign(ma200[last], prices[last]);
    }).start(1).longOnly();
    BuySell mt_ = buySell(d -> holds[d]);
    Pair<float[], float[]> bbmv = bb.meanVariances(VirtualVector.of(logReturns), 9, 0);
    float[] bbmean = bbmv.t0;
    float[] bbvariances = bbmv.t1;
    BuySell ms2 = buySell(d -> {
        int last = d - 1;
        int ref = last - 250;
        float mean = bbmean[last];
        return Quant.sign(logPrices[last], logPrices[ref] - bbvariances[last] / (2d * mean * mean));
    }).start(1 + 250);
    LogUtil.info(// 
    "" + "\nsymbol = " + // 
    symbol + "\nlength = " + // 
    length + "\nnYears = " + // 
    nYears + "\nups = " + // 
    Floats_.of(returns).filter(return_ -> 0f <= return_).size() + "\ndct period = " + // 
    max.t0 + // 
    Ints_.range(// 
    10).map(// 
    d -> "\ndct component [" + d + "d] = " + fds[d]).collect(// 
    As::joined) + "\nreturn yearly sharpe = " + // 
    rmv.mean / Math.sqrt(variance / nYears) + "\nreturn kelly = " + // 
    kelly + "\nreturn skew = " + // 
    stat.skewness(returns) + "\nreturn kurt = " + // 
    stat.kurtosis(returns) + // 
    Ints_.of(1, 2, 4, 8, 16, // 
    32).map(// 
    d -> "\nmean reversion ols [" + d + "d] = " + ts.meanReversion(prices, d).coefficients[0]).collect(// 
    As::joined) + // 
    Ints_.of(4, // 
    16).map(// 
    d -> "\nvariance ratio [" + d + "d over 1d] = " + ts.varianceRatio(prices, d)).collect(// 
    As::joined) + "\nreturn hurst = " + // 
    ts.hurst(prices, prices.length / 2) + "\nhold " + // 
    buySell(d -> 1d).invest(prices) + "\nkelly " + // 
    buySell(d -> kelly).invest(prices) + "\nma200 trend " + // 
    mat.invest(prices) + // 
    Ints_.range(1, // 
    8).map(// 
    d -> "\nrevert [" + d + "d] " + reverts[d].invest(prices)).collect(// 
    As::joined) + // 
    Ints_.range(1, // 
    8).map(// 
    d -> "\ntrend_ [" + d + "d] " + trends_[d].invest(prices)).collect(// 
    As::joined) + // 
    Ints_.range(1, // 
    8).map(// 
    d -> "\nrevert [" + d + "d] long-only " + reverts[d].longOnly().invest(prices)).collect(// 
    As::joined) + // 
    Ints_.range(1, // 
    8).map(// 
    d -> "\ntrend_ [" + d + "d] long-only " + trends_[d].longOnly().invest(prices)).collect(// 
    As::joined) + "\nms2 " + // 
    ms2.invest(prices) + "\nms2 long-only " + // 
    ms2.longOnly().invest(prices) + "\ntanh " + // 
    tanh.invest(prices) + "\ntimed " + // 
    mt_.invest(prices) + "\ntimed long-only " + mt_.longOnly().invest(prices));
}

Example 2 with IntFltPair

use of suite.primitive.adt.pair.IntFltPair in project suite by stupidsing.

the class IntFltMap method forEach.

public void forEach(IntFltSink sink) {
    IntFltPair pair = IntFltPair.of((int) 0, (float) 0);
    IntFltSource source = source_();
    while (source.source2(pair)) sink.sink2(pair.t0, pair.t1);
}

Example 3 with IntFltPair

use of suite.primitive.adt.pair.IntFltPair in project suite by stupidsing.

the class Trade_ method collectAcquiredPrices.

public static Map<String, Float> collectAcquiredPrices(Outlet<Trade> outlet) {
    Map<String, List<IntFltPair>> acquireBySymbol = new HashMap<>();
    for (Trade trade : outlet) {
        String symbol = trade.symbol;
        int buySell = trade.buySell;
        float price = trade.price;
        List<IntFltPair> acquires0 = acquireBySymbol.getOrDefault(symbol, List.of());
        List<IntFltPair> acquires1 = new ArrayList<>();
        for (IntFltPair acquire : acquires0) {
            int n0 = acquire.t0;
            int diff = buySell < 0 ? max(0, min(-buySell, n0)) : min(0, max(-buySell, n0));
            int n1 = n0 - diff;
            buySell += diff;
            if (n1 != 0)
                acquires1.add(IntFltPair.of(n1, acquire.t1));
        }
        if (buySell != 0)
            acquires1.add(IntFltPair.of(buySell, price));
        acquireBySymbol.put(symbol, acquires1);
    }
    return // 
    Read.from2(// 
    acquireBySymbol).mapValue(acquires -> {
        IntFltPair sum = IntFltPair.of(0, 0f);
        for (IntFltPair acquire : acquires) sum.update(sum.t0 + acquire.t0, sum.t1 + acquire.t0 * acquire.t1);
        return sum.t1 / sum.t0;
    }).toMap();
}

Example 4 with IntFltPair

use of suite.primitive.adt.pair.IntFltPair in project suite by stupidsing.

the class StatisticalArbitrageTest method testPeriod.

// find the period of various stocks using FFT
@Test
public void testPeriod() {
    int minPeriod = 4;
    DctDataSource dctDataSources = dctDataSources();
    for (Pair<String, float[]> e : dctDataSources.dctByKey) {
        float[] dct = e.t1;
        IntFltPair max = IntFltPair.of(Integer.MIN_VALUE, Float.MIN_VALUE);
        for (int i = minPeriod; i < dct.length; i++) {
            float f = Math.abs(dct[i]);
            if (max.t1 < f)
                max = IntFltPair.of(i, f);
        }
        LogUtil.info(e.t0 + " has period " + max.t0);
    }
}