Example usage for java.util Arrays binarySearch

List of usage examples for java.util Arrays binarySearch

  1. HOME
  2. Java
  3. java
  4. java.util.*
  5. Arrays
  6. binarySearch

Introduction

In this page you can find the example usage for java.util Arrays binarySearch.

Prototype

public static int binarySearch(Object[] a, Object key)

Source Link

Document

Searches the specified array for the specified object using the binary search algorithm.

Usage

From source file:org.apache.myfaces.tomahawk.util.ErrorPageWriter.java

private static void writeAttributes(Writer writer, UIComponent c) {
    try {//from   ww w  . j a  v  a 2  s.c  o m
        BeanInfo info = Introspector.getBeanInfo(c.getClass());
        PropertyDescriptor[] pd = info.getPropertyDescriptors();
        Method m = null;
        Object v = null;
        String str = null;
        for (int i = 0; i < pd.length; i++) {
            if (pd[i].getWriteMethod() != null && Arrays.binarySearch(IGNORE, pd[i].getName()) < 0) {
                m = pd[i].getReadMethod();
                try {
                    v = m.invoke(c, null);
                    if (v != null) {
                        if (v instanceof Collection || v instanceof Map || v instanceof Iterator) {
                            continue;
                        }
                        writer.write(" ");
                        writer.write(pd[i].getName());
                        writer.write("=\"");
                        if (v instanceof Expression) {
                            str = ((Expression) v).getExpressionString();
                        }
                        writer.write(str.replaceAll("<", TS));
                        writer.write("\"");
                    }
                } catch (Exception e) {
                    // do nothing
                }
            }
        }

        ValueExpression binding = c.getValueExpression("binding");
        if (binding != null) {
            writer.write(" binding=\"");
            writer.write(binding.getExpressionString().replaceAll("<", TS));
            writer.write("\"");
        }
    } catch (Exception e) {
        // do nothing
    }
}

From source file:com.opengamma.analytics.financial.credit.creditdefaultswap.pricing.vanilla.isdanew.ISDACompliantCurve.java

/**
 * The sensitivity of the discount factor at some time, t, to the value of the zero rate at a given node (knot). For a
 * given index, i, this is zero unless $$t_{i-1} < t < t_{i+1}$$ since the interpolation is highly local.
 * @param t time value of the discount factor
 * @param nodeIndex node index//from  w w w  . j a v a 2  s .  co m
 * @return sensitivity of a discount factor to a single node
 */
public double getSingleNodeDiscountFactorSensitivity(final double t, final int nodeIndex) {
    ArgumentChecker.isTrue(t >= 0, "require t >= 0.0");
    ArgumentChecker.isTrue(nodeIndex >= 0 && nodeIndex < _n, "index out of range");

    if (t == 0.0) {
        return 0.0;
    }
    if (t <= _t[0]) {
        return nodeIndex == 0 ? -t * Math.exp(-t * _r[0]) : 0.0;
    }
    //    if (t >= _t[_n - 1]) {
    //      return nodeIndex == _n - 1 ? -t * Math.exp(-t * _r[_n - 1]) : 0.0;
    //    }

    final int index = Arrays.binarySearch(_t, t);
    if (index >= 0) {
        return nodeIndex == index ? -t * _df[nodeIndex] : 0.0;
    }

    final int insertionPoint = Math.min(_n - 1, -(1 + index));
    if (nodeIndex != insertionPoint && nodeIndex != insertionPoint - 1) {
        return 0.0;
    }

    final double t1 = _t[insertionPoint - 1];
    final double t2 = _t[insertionPoint];
    final double dt = t2 - t1;
    final double rt = ((t2 - t) * _rt[insertionPoint - 1] + (t - t1) * _rt[insertionPoint]) / dt;
    final double p = Math.exp(-rt);
    if (nodeIndex == insertionPoint) {
        return -t2 * (t - t1) * p / dt;
    }

    return -t1 * (t2 - t) * p / dt;
}

From source file:com.opengamma.bloombergexample.loader.DemoEquityOptionCollarPortfolioLoader.java

private void addNodes(ManageablePortfolioNode rootNode, String underlying, boolean includeUnderlying,
        Period[] expiries) {/*ww  w. ja va 2s.c o  m*/
    ExternalId ticker = ExternalSchemes.bloombergTickerSecurityId(underlying);
    ManageableSecurity underlyingSecurity = null;
    if (includeUnderlying) {
        underlyingSecurity = getOrLoadEquity(ticker);
    }

    ExternalIdBundle bundle = underlyingSecurity == null ? ExternalIdBundle.of(ticker)
            : underlyingSecurity.getExternalIdBundle();
    HistoricalTimeSeriesInfoDocument timeSeriesInfo = getOrLoadTimeSeries(ticker, bundle);
    double estimatedCurrentStrike = getOrLoadMostRecentPoint(timeSeriesInfo);
    Set<ExternalId> optionChain = getOptionChain(ticker);

    //TODO: reuse positions/nodes?
    String longName = underlyingSecurity == null ? "" : underlyingSecurity.getName();
    String formattedName = MessageFormatter.format("[{}] {}", underlying, longName);
    ManageablePortfolioNode equityNode = new ManageablePortfolioNode(formattedName);

    BigDecimal underlyingAmount = VALUE_OF_UNDERLYING.divide(BigDecimal.valueOf(estimatedCurrentStrike),
            BigDecimal.ROUND_HALF_EVEN);

    if (includeUnderlying) {
        addPosition(equityNode, underlyingAmount, ticker);
    }

    TreeMap<LocalDate, Set<BloombergTickerParserEQOption>> optionsByExpiry = new TreeMap<LocalDate, Set<BloombergTickerParserEQOption>>();
    for (ExternalId optionTicker : optionChain) {
        s_logger.debug("Got option {}", optionTicker);

        BloombergTickerParserEQOption optionInfo = BloombergTickerParserEQOption.getOptionParser(optionTicker);
        s_logger.debug("Got option info {}", optionInfo);

        LocalDate key = optionInfo.getExpiry();
        Set<BloombergTickerParserEQOption> set = optionsByExpiry.get(key);
        if (set == null) {
            set = new HashSet<BloombergTickerParserEQOption>();
            optionsByExpiry.put(key, set);
        }
        set.add(optionInfo);
    }
    Set<ExternalId> tickersToLoad = new HashSet<ExternalId>();

    BigDecimal expiryCount = BigDecimal.valueOf(expiries.length);
    BigDecimal defaultAmountAtExpiry = underlyingAmount.divide(expiryCount, BigDecimal.ROUND_DOWN);
    BigDecimal spareAmountAtExpiry = defaultAmountAtExpiry.add(BigDecimal.ONE);
    int spareCount = underlyingAmount.subtract(defaultAmountAtExpiry.multiply(expiryCount)).intValue();

    for (int i = 0; i < expiries.length; i++) {
        Period bucketPeriod = expiries[i];

        ManageablePortfolioNode bucketNode = new ManageablePortfolioNode(bucketPeriod.toString().substring(1));

        LocalDate nowish = LocalDate.now().withDayOfMonth(20); //This avoids us picking different options every time this script is run
        LocalDate targetExpiry = nowish.plus(bucketPeriod);
        LocalDate chosenExpiry = optionsByExpiry.floorKey(targetExpiry);
        if (chosenExpiry == null) {
            s_logger.warn("No options for {} on {}", targetExpiry, underlying);
            continue;
        }
        s_logger.info("Using time {} for bucket {} ({})",
                new Object[] { chosenExpiry, bucketPeriod, targetExpiry });

        Set<BloombergTickerParserEQOption> optionsAtExpiry = optionsByExpiry.get(chosenExpiry);
        TreeMap<Double, Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>> optionsByStrike = new TreeMap<Double, Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>>();
        for (BloombergTickerParserEQOption option : optionsAtExpiry) {
            //        s_logger.info("option {}", option);
            double key = option.getStrike();
            Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption> pair = optionsByStrike.get(key);
            if (pair == null) {
                pair = Pair.of(null, null);
            }
            if (option.getOptionType() == OptionType.CALL) {
                pair = Pair.of(option, pair.getSecond());
            } else {
                pair = Pair.of(pair.getFirst(), option);
            }
            optionsByStrike.put(key, pair);
        }

        //cascading collar?
        BigDecimal amountAtExpiry = spareCount-- > 0 ? spareAmountAtExpiry : defaultAmountAtExpiry;

        s_logger.info(" est strike {}", estimatedCurrentStrike);
        Double[] strikes = optionsByStrike.keySet().toArray(new Double[0]);

        int strikeIndex = Arrays.binarySearch(strikes, estimatedCurrentStrike);
        if (strikeIndex < 0) {
            strikeIndex = -(1 + strikeIndex);
        }
        s_logger.info("strikes length {} index {} strike of index {}",
                new Object[] { Integer.valueOf(strikes.length), Integer.valueOf(strikeIndex),
                        Double.valueOf(strikes[strikeIndex]) });

        int minIndex = strikeIndex - _numOptions;
        minIndex = Math.max(0, minIndex);
        int maxIndex = strikeIndex + _numOptions;
        maxIndex = Math.min(strikes.length - 1, maxIndex);

        s_logger.info("min {} max {}", Integer.valueOf(minIndex), Integer.valueOf(maxIndex));
        StringBuffer sb = new StringBuffer("strikes: [");
        for (int j = minIndex; j <= maxIndex; j++) {
            sb.append(" ");
            sb.append(strikes[j]);
        }
        sb.append(" ]");
        s_logger.info(sb.toString());

        //Short Calls
        ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>> calls = new ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>>();
        for (int j = minIndex; j < strikeIndex; j++) {
            Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption> pair = optionsByStrike
                    .get(strikes[j]);
            if (pair == null) {
                throw new OpenGammaRuntimeException("no pair for strike" + strikes[j]);
            }
            calls.add(pair);
        }
        spreadOptions(bucketNode, calls, OptionType.CALL, -1, tickersToLoad, amountAtExpiry, includeUnderlying,
                calls.size());

        // Long Puts
        ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>> puts = new ArrayList<Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption>>();
        for (int j = strikeIndex + 1; j <= maxIndex; j++) {
            Pair<BloombergTickerParserEQOption, BloombergTickerParserEQOption> pair = optionsByStrike
                    .get(strikes[j]);
            if (pair == null) {
                throw new OpenGammaRuntimeException("no pair for strike" + strikes[j]);
            }
            puts.add(pair);
        }
        spreadOptions(bucketNode, puts, OptionType.PUT, 1, tickersToLoad, amountAtExpiry, includeUnderlying,
                puts.size());

        if (bucketNode.getChildNodes().size() + bucketNode.getPositionIds().size() > 0) {
            equityNode.addChildNode(bucketNode); //Avoid generating empty nodes   
        }
    }

    for (ExternalId optionTicker : tickersToLoad) {
        ManageableSecurity loaded = getOrLoadSecurity(optionTicker);
        if (loaded == null) {
            throw new OpenGammaRuntimeException("Unexpected option type " + loaded);
        }

        //TODO [LAPANA-29] Should be able to do this for index options too
        if (includeUnderlying) {
            try {
                HistoricalTimeSeriesInfoDocument loadedTs = getOrLoadTimeSeries(optionTicker,
                        loaded.getExternalIdBundle());
                if (loadedTs == null) {
                    throw new OpenGammaRuntimeException("Failed to get time series for " + loaded);
                }
            } catch (Exception ex) {
                s_logger.error("Failed to get time series for " + loaded, ex);
            }
        }
    }

    if (equityNode.getPositionIds().size() + equityNode.getChildNodes().size() > 0) {
        rootNode.addChildNode(equityNode);
    }
}

From source file:de.vanita5.twittnuker.util.net.ssl.AbstractCheckSignatureVerifier.java

static boolean validCountryWildcard(final String cn) {
    final String parts[] = cn.split("\\.");
    // it's not an attempt to wildcard a 2TLD within a country code
    if (parts.length != 3 || parts[2].length() != 2)
        return true;
    return Arrays.binarySearch(BAD_COUNTRY_2LDS, parts[1]) < 0;
}

From source file:com.rareventure.gps2.reviewer.SettingsActivity.java

private float getPasswordTimeoutFromMS(long passwordTimeoutMS) {
    int res = Arrays.binarySearch(passwordTimeoutValues, passwordTimeoutMS);
    if (res >= 0)
        return res;
    return 0;/*  ww w.ja  v a 2 s.  com*/
}

From source file:com.opengamma.analytics.financial.interestrate.swaption.method.SwaptionPhysicalFixedIborLMMDDMethod.java

/**
 * Computes the present value sensitivity to LMM parameters of the Physical delivery swaption.
 * @param swaption The swaption.//from  w w  w  . ja v a2 s. co  m
 * @param lmmBundle The LMM parameters and the curves.
 * @return The present value.
 */
public double[][] presentValueLMMSensitivity(final SwaptionPhysicalFixedIbor swaption,
        final LiborMarketModelDisplacedDiffusionDataBundle lmmBundle) {
    // 1. Swaption CFE preparation
    AnnuityPaymentFixed cfe = CFEC.visit(swaption.getUnderlyingSwap(), lmmBundle);
    YieldAndDiscountCurve dsc = lmmBundle.getCurve(cfe.getDiscountCurve());
    int nbCFInit = cfe.getNumberOfPayments();
    double multFact = Math.signum(cfe.getNthPayment(0).getAmount());
    boolean isCall = (cfe.getNthPayment(0).getAmount() < 0);
    double[] cftInit = new double[nbCFInit];
    double[] cfaInit = new double[nbCFInit];
    for (int loopcf = 0; loopcf < nbCFInit; loopcf++) {
        cftInit[loopcf] = cfe.getNthPayment(loopcf).getPaymentTime();
        cfaInit[loopcf] = cfe.getNthPayment(loopcf).getAmount() * -multFact;
    }
    double timeToExpiry = swaption.getTimeToExpiry();
    // 2. Model data
    int nbFactor = lmmBundle.getLmmParameter().getNbFactor();
    double[][] volLMM = lmmBundle.getLmmParameter().getVolatility();
    double[] timeLMM = lmmBundle.getLmmParameter().getIborTime();
    // 3. Link cfe dates to lmm
    int[] indCFDate = new int[nbCFInit];
    int indStart = nbCFInit - 1;
    int indEnd = 0;
    for (int loopcf = 0; loopcf < nbCFInit; loopcf++) {
        indCFDate[loopcf] = Arrays.binarySearch(timeLMM, cftInit[loopcf]);
        if (indCFDate[loopcf] < 0) {
            if (timeLMM[-indCFDate[loopcf] - 1] - cftInit[loopcf] < TIME_TOLERANCE) {
                indCFDate[loopcf] = -indCFDate[loopcf] - 1;
            } else {
                if (cftInit[loopcf] - timeLMM[-indCFDate[loopcf] - 2] < TIME_TOLERANCE) {
                    indCFDate[loopcf] = -indCFDate[loopcf] - 2;
                } else {
                    Validate.isTrue(true, "Instrument time incompatible with LMM");
                }
            }
        }
        if (indCFDate[loopcf] < indStart) {
            indStart = indCFDate[loopcf];
        }
        if (indCFDate[loopcf] > indEnd) {
            indEnd = indCFDate[loopcf];
        }
    }
    int nbCF = indEnd - indStart + 1;
    double[] cfa = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCFInit; loopcf++) {
        cfa[indCFDate[loopcf] - indStart] = cfaInit[loopcf];
    }
    double[] cft = new double[nbCF];
    System.arraycopy(timeLMM, indStart, cft, 0, nbCF);

    double[] dfLMM = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        dfLMM[loopcf] = dsc.getDiscountFactor(cft[loopcf]);
    }
    double[][] gammaLMM = new double[nbCF - 1][nbFactor];
    double[] deltaLMM = new double[nbCF - 1];
    System.arraycopy(lmmBundle.getLmmParameter().getAccrualFactor(), indStart, deltaLMM, 0, nbCF - 1);
    double[] aLMM = new double[nbCF - 1];
    System.arraycopy(lmmBundle.getLmmParameter().getDisplacement(), indStart, aLMM, 0, nbCF - 1);
    double[] liborLMM = new double[nbCF - 1];
    double amr = lmmBundle.getLmmParameter().getMeanReversion();
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        gammaLMM[loopcf] = volLMM[indStart + loopcf];
        liborLMM[loopcf] = (dfLMM[loopcf] / dfLMM[loopcf + 1] - 1.0d) / deltaLMM[loopcf];
    }
    // TODO: 4. cfe modification (for roller coasters)
    double[] cfaMod = new double[nbCF + 1];
    double cfaMod0 = cfa[0];
    cfaMod[0] = cfaMod0; // modified strike
    cfaMod[1] = 0.0;
    System.arraycopy(cfa, 1, cfaMod, 2, nbCF - 1);
    // 5. Pricing algorithm
    double[] p0 = new double[nbCF];
    double[] dP = new double[nbCF];
    double b0 = 0;
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        p0[loopcf] = dfLMM[loopcf] / dfLMM[0];
        dP[loopcf] = cfaMod[loopcf + 1] * p0[loopcf];
        b0 += dP[loopcf];
    }
    double bK = -cfaMod0;
    double bM = (b0 + bK) / 2.0d;
    double[] rate0Ratio = new double[nbCF - 1];
    double[][] mu0 = new double[nbCF - 1][nbFactor];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        rate0Ratio[loopcf] = (liborLMM[loopcf] + aLMM[loopcf]) / (liborLMM[loopcf] + 1 / deltaLMM[loopcf]);
    }
    for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
        mu0[0][loopfact] = rate0Ratio[0] * gammaLMM[0][loopfact];
    }
    for (int loopcf = 1; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            mu0[loopcf][loopfact] = mu0[loopcf - 1][loopfact] + rate0Ratio[loopcf] * gammaLMM[loopcf][loopfact];
        }
    }
    double meanReversionImpact = (Math.exp(2.0d * amr * timeToExpiry) - 1.0d) / (2.0d * amr);
    double[] tau = new double[nbCF];
    double[] tau2 = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            tau2[loopcf + 1] += mu0[loopcf][loopfact] * mu0[loopcf][loopfact];
        }
        tau2[loopcf + 1] = tau2[loopcf + 1] * meanReversionImpact;
        tau[loopcf + 1] = Math.sqrt(tau2[loopcf + 1]);
    }
    double sumNum = -bM;
    double sumDen = 0;
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        sumNum += dP[loopcf] - dP[loopcf] * tau2[loopcf] / 2.0;
        sumDen += dP[loopcf] * tau[loopcf];
    }
    double xBar = sumNum / sumDen;
    double[] pM = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        pM[loopcf] = p0[loopcf] * (1 - xBar * tau[loopcf] - tau2[loopcf] / 2.0);
    }
    double[] liborM = new double[nbCF - 1];
    double[] alphaM = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        liborM[loopcf] = (pM[loopcf] / pM[loopcf + 1] - 1.0d) / deltaLMM[loopcf];
    }
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        alphaM[loopcf] = cfaMod[loopcf + 1] * pM[loopcf] / bM;
    }
    double[] rateMRatio = new double[nbCF - 1];
    double[][] muM = new double[nbCF - 1][nbFactor];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        rateMRatio[loopcf] = (liborM[loopcf] + aLMM[loopcf]) / (liborM[loopcf] + 1 / deltaLMM[loopcf]);
    }
    for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
        muM[0][loopfact] = rateMRatio[0] * gammaLMM[0][loopfact];
    }
    for (int loopcf = 1; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            muM[loopcf][loopfact] = muM[loopcf - 1][loopfact] + rateMRatio[loopcf] * gammaLMM[loopcf][loopfact];
        }
    }
    double normSigmaM = 0;
    double[] sigmaM = new double[nbFactor];
    for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
        for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
            sigmaM[loopfact] += alphaM[loopcf + 1] * muM[loopcf][loopfact];
        }
        normSigmaM += sigmaM[loopfact] * sigmaM[loopfact];
    }
    double impliedBlackVol = Math.sqrt(normSigmaM * meanReversionImpact);
    EuropeanVanillaOption option = new EuropeanVanillaOption(bK, 1, isCall);
    final BlackPriceFunction blackFunction = new BlackPriceFunction();
    final BlackFunctionData dataBlack = new BlackFunctionData(b0, 1.0, impliedBlackVol);
    double[] blkAdjoint = blackFunction.getPriceAdjoint(option, dataBlack);
    // Backward sweep
    double pvBar = 1.0;
    double impliedBlackVolBar = dfLMM[0] * blkAdjoint[2] * pvBar;
    double normSigmaMBar = meanReversionImpact / (2.0 * impliedBlackVol) * impliedBlackVolBar;
    double[] sigmaMBar = new double[nbFactor];
    for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
        sigmaMBar[loopfact] = 2 * sigmaM[loopfact] * normSigmaMBar;
    }

    double[][] muMBar = new double[nbCF - 1][nbFactor];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            muMBar[loopcf][loopfact] = alphaM[loopcf + 1] * sigmaMBar[loopfact];
        }
    }
    for (int loopcf = nbCF - 3; loopcf >= 0; loopcf--) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            muMBar[loopcf][loopfact] += muMBar[loopcf + 1][loopfact];
        }
    }

    double[] rateMRatioBar = new double[nbCF - 1];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            rateMRatioBar[loopcf] += gammaLMM[loopcf][loopfact] * muMBar[loopcf][loopfact];
        }
    }

    double[] alphaMBar = new double[nbCF];
    for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
        for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
            alphaMBar[loopcf + 1] += muM[loopcf][loopfact] * sigmaMBar[loopfact];
        }
    }

    double[] liborMBar = new double[nbCF - 1];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        liborMBar[loopcf] = ((liborM[loopcf] + 1 / deltaLMM[loopcf]) - (liborM[loopcf] + aLMM[loopcf]))
                / ((liborM[loopcf] + 1 / deltaLMM[loopcf]) * (liborM[loopcf] + 1 / deltaLMM[loopcf]))
                * rateMRatioBar[loopcf];
    }

    double[] pMBar = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        pMBar[loopcf] += 1.0 / pM[loopcf + 1] / deltaLMM[loopcf] * liborMBar[loopcf];
        pMBar[loopcf + 1] += -pM[loopcf] / (pM[loopcf + 1] * pM[loopcf + 1]) / deltaLMM[loopcf]
                * liborMBar[loopcf];
    }
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        pMBar[loopcf] += cfaMod[loopcf + 1] / bM * alphaMBar[loopcf];
    }

    double xBarBar = 0.0;
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        xBarBar += -p0[loopcf] * tau[loopcf] * pMBar[loopcf];
    }
    double sumNumBar = 1.0 / sumDen * xBarBar;
    double sumDenBar = -sumNum / (sumDen * sumDen) * xBarBar;
    double[] tauBar = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        tauBar[loopcf] = -p0[loopcf] * xBar * pMBar[loopcf];
    }
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        tauBar[loopcf] += dP[loopcf] * sumDenBar;
    }
    double[] tau2Bar = new double[nbCF];
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        tau2Bar[loopcf] = -p0[loopcf] / 2.0 * pMBar[loopcf];
    }
    for (int loopcf = 0; loopcf < nbCF; loopcf++) {
        tau2Bar[loopcf] += -dP[loopcf] / 2.0 * sumNumBar;
    }
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        tau2Bar[loopcf + 1] += 1 / 2.0 / tau[loopcf + 1] * tauBar[loopcf + 1];
    }
    double[][] mu0Bar = new double[nbCF - 1][nbFactor];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            mu0Bar[loopcf][loopfact] = 2.0 * mu0[loopcf][loopfact] * meanReversionImpact * tau2Bar[loopcf + 1];
        }
    }
    for (int loopcf = nbCF - 3; loopcf >= 0; loopcf--) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            mu0Bar[loopcf][loopfact] += mu0Bar[loopcf + 1][loopfact];
        }
    }
    double[][] gammaLMMBar = new double[nbCF - 1][nbFactor];
    for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
        gammaLMMBar[0][loopfact] = rateMRatio[0] * muMBar[0][loopfact];
    }
    for (int loopcf = 1; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            gammaLMMBar[loopcf][loopfact] += rateMRatio[loopcf] * muMBar[loopcf][loopfact];
        }
    }
    for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
        gammaLMMBar[0][loopfact] += rate0Ratio[0] * mu0Bar[0][loopfact];
    }
    for (int loopcf = 1; loopcf < nbCF - 1; loopcf++) {
        for (int loopfact = 0; loopfact < nbFactor; loopfact++) {
            gammaLMMBar[loopcf][loopfact] += rate0Ratio[loopcf] * mu0Bar[loopcf][loopfact];
        }
    }
    double[][] volLMMBar = new double[volLMM.length][nbFactor];
    for (int loopcf = 0; loopcf < nbCF - 1; loopcf++) {
        volLMMBar[indStart + loopcf] = gammaLMMBar[loopcf];
    }

    return volLMMBar;
}

From source file:aldenjava.opticalmapping.data.data.DataNode.java

/**
 * Check if there is a signal at the specified position
 * //from w w w.java  2  s .c om
 * @param pos
 *            Specified position
 * @return <code>true</code> if the signal exists
 */
public boolean hasSignal(long pos) {
    return (Arrays.binarySearch(refp, pos) >= 0);
}

From source file:com.radiohitwave.ftpsync.API.java

public void DeleteNonExistingFiles(String localBasePath) {
    Log.info("Searching for non-existing Files");
    String[] remoteFiles = this.GetRemoteFileList();
    final String finalLocalPath = this.RemoveTrailingSlash(localBasePath);
    AtomicInteger logDeletedFiles = new AtomicInteger();

    try {/* w w  w.  j  ava  2  s.c  o m*/
        Files.walk(Paths.get(localBasePath)).forEach(filePath -> {
            if (Files.isRegularFile(filePath)) {
                String file = filePath.toString().replace(finalLocalPath, "");
                file = file.substring(1);
                file = file.replace("\\", "/");
                if (Arrays.binarySearch(remoteFiles, file) < 0) {
                    try {
                        Log.info("Deleting <" + file + ">");
                        Files.delete(filePath);
                        logDeletedFiles.incrementAndGet();
                    } catch (IOException ex) {
                        Log.error("Cant delete File:" + ex.toString());
                        Log.remoteError(ex);
                    }
                }
            }
        });
        Files.walk(Paths.get(localBasePath)).forEach(filePath -> {
            if (Files.isDirectory(filePath)) {
                String file = filePath.toString().replace(finalLocalPath + "/", "");
                try {
                    Files.delete(filePath);
                    Log.info("Deleting empty Directory <" + file + ">");
                } catch (IOException e) {

                }
            }
        });
    } catch (IOException ex) {
        Log.error(ex.toString());
    }
    Log.info("Disk-Cleanup finished, deleted " + logDeletedFiles.get() + " Files");
    if (logDeletedFiles.get() > this.nonExistingFilesThreesholdBeforeAlert) {
        Log.remoteInfo("Deleted " + logDeletedFiles.get() + " non-existing Files");
    }

}

From source file:org.jfree.data.contour.DefaultContourDataset.java

/**
 * Given index k, returns the column index containing k.
 *
 * @param k index of interest.//from   w ww.j  a  va  2  s .co  m
 *
 * @return The column index.
 */
public int indexX(int k) {
    int i = Arrays.binarySearch(this.xIndex, k);
    if (i >= 0) {
        return i;
    } else {
        return -1 * i - 2;
    }
}

From source file:eu.eidas.node.utils.EidasNodeErrorUtil.java

private static boolean isErrorCodeAllowedForSamlGeneration(final String errorCode) {
    for (int i = 0; i < EIDAS_SUB_STATUS_CODES.length; i++) {
        if (EIDAS_ERRORS_CODES_WITH_SAML_GENERATION[i] != null
                && EIDAS_ERRORS_CODES_WITH_SAML_GENERATION[i].length > 0
                && Arrays.binarySearch(EIDAS_ERRORS_CODES_WITH_SAML_GENERATION[i], errorCode) >= 0) {
            return true;
        }/*from  w w w .  j  a  v  a  2s.c o m*/
    }
    return false;
}