List of usage examples for org.apache.commons.math3.fraction BigFraction equals
@Override public boolean equals(final Object other)
Test for the equality of two fractions.
From source file:controller.VisLP.java
/** * Dictionary form assumes all x-values >= 0. For a geometric * representation we need these constraints explicitly stated * in order to draw the feasible region. * //from w ww. j ava2s.c o m * This method adds the constraints x >= 0 (-x <= 0) * and y >= 0 (-y <= 0) unless more bounding constraints * on the x and y-values already exists. * * It also always adds a line with a negative slope with * a <<high enough>> positive x- and y-intercept needed * to color unbounded feasible regions. * * @param cons * A constraints-matrix * @return * A constraints matrix guaranteed to have lower bounds. */ static FieldMatrix<BigFraction> checkForBounds(FieldMatrix<BigFraction> cons) { boolean lowerx = false; boolean lowery = false; BigFraction valsum = BigFraction.ZERO; /* Does lower bounds already exist? */ for (int i = 0; i < cons.getRowDimension(); i++) { BigFraction x = cons.getEntry(i, 0); BigFraction y = cons.getEntry(i, 1); if (x.compareTo(BigFraction.ZERO) < 0 && y.equals(BigFraction.ZERO)) { lowerx = true; } else if (x.equals(BigFraction.ZERO) && y.compareTo(BigFraction.ZERO) < 0) { lowery = true; } valsum = valsum.add(cons.getEntry(i, 2).abs()); } FieldMatrix<BigFraction> ncons = cons.copy(); BigFraction[] cxdata = new BigFraction[] { BigFraction.MINUS_ONE, BigFraction.ZERO, BigFraction.ZERO }; BigFraction[] cydata = new BigFraction[] { BigFraction.ZERO, BigFraction.MINUS_ONE, BigFraction.ZERO }; /* Add lower bounds if they do not exist */ if (!lowerx) { FieldMatrix<BigFraction> c = new Array2DRowFieldMatrix<BigFraction>(cxdata).transpose(); ncons = LP.addBlock(ncons, c, LP.UNDER); } if (!lowery) { FieldMatrix<BigFraction> c = new Array2DRowFieldMatrix<BigFraction>(cydata).transpose(); ncons = LP.addBlock(ncons, c, LP.UNDER); } valsum = valsum.add(BigFraction.TWO).multiply(valsum); BigFraction[] uc = new BigFraction[] { BigFraction.ONE, BigFraction.ONE, valsum }; FieldMatrix<BigFraction> c = new Array2DRowFieldMatrix<BigFraction>(uc).transpose(); ncons = LP.addBlock(ncons, c, LP.UNDER); return ncons; }
From source file:model.LP.java
/** * Find a leaving variable index that is the most * bounding on the given entering variable index. * * @param entering// ww w. jav a2s. co m * an entering variable index. * @param dual * If true, find a leaving variable index for the dual dictionary. * Otherwise, find one for the primal dictionary. * @return * A leaving variable index. */ private int leaving(int entering, boolean dual) { FieldVector<BigFraction> check; FieldVector<BigFraction> sd; FieldMatrix<BigFraction> bin = new FieldLUDecomposition<BigFraction>(B_).getSolver().getInverse() .multiply(N_); if (dual) { check = c_; FieldVector<BigFraction> unit = new ArrayFieldVector<BigFraction>(bin.getRowDimension(), BigFraction.ZERO); unit.setEntry(entering, BigFraction.ONE); sd = bin.transpose().scalarMultiply(BigFraction.MINUS_ONE).operate(unit); } else { check = b_; FieldVector<BigFraction> unit = new ArrayFieldVector<BigFraction>(bin.getColumnDimension(), BigFraction.ZERO); unit.setEntry(entering, BigFraction.ONE); sd = bin.operate(unit); } boolean unbounded = true; int index = -1; /* Check for unboundedness and find first non-zero element in check */ for (int i = 0; i < sd.getDimension(); i++) { if (!check.getEntry(i).equals(BigFraction.ZERO) && index == -1) { index = i; } if (sd.getEntry(i).compareTo(BigFraction.ZERO) > 0) { unbounded = false; } } String e = "Program is unbounded."; if (unbounded) throw new RuntimeException(e); /* Set temporarily max value as ratio of the first divisible pair. */ BigFraction max = sd.getEntry(index).divide(check.getEntry(index)); for (int i = 0; i < sd.getDimension(); i++) { BigFraction num = sd.getEntry(i); BigFraction denom = check.getEntry(i); if (!denom.equals(BigFraction.ZERO)) { BigFraction val = num.divide(denom); if (val.compareTo(max) > 0) { max = val; index = i; } } else { if (num.compareTo(BigFraction.ZERO) > 0) return i; } } return index; }
From source file:com.netflix.imfutility.dpp.DppFormatBuilder.java
private void resolveSameFpsParameter() { ContextInfo contextInfo = new ContextInfoBuilder().setSequenceType(SequenceType.VIDEO) .setSequenceUuid(getVideoSequenceUUID()).build(); BigFraction seqFrameRate = ConversionHelper.parseEditRate(contextProvider.getSequenceContext() .getParameterValue(SequenceContextParameters.FRAME_RATE, contextInfo)); BigFraction destFrameRate = ConversionHelper.parseEditRate( contextProvider.getDestContext().getParameterValue(DestContextParameters.FRAME_RATE)); DynamicTemplateParameterContext dynamicContext = contextProvider.getDynamicContext(); dynamicContext.addParameter(DYNAMIC_PARAM_SAME_FPS, Boolean.toString(seqFrameRate.equals(destFrameRate))); }
From source file:sadl.models.PDFA.java
protected boolean fixProbability(int state) { List<Transition> outgoingTransitions = getOutTransitions(state, true); final double sum = outgoingTransitions.stream().mapToDouble(t -> t.getProbability()).sum(); // divide every probability by the sum of probabilities s.t. they sum up to 1 if (!Precision.equals(sum, 1)) { logger.debug("Sum of transition probabilities for state {} is {}", state, sum); outgoingTransitions = getOutTransitions(state, true); outgoingTransitions.forEach(t -> changeTransitionProbability(t, t.getProbability() / sum)); outgoingTransitions = getOutTransitions(state, true); final double newSum = outgoingTransitions.stream().mapToDouble(t -> t.getProbability()).sum(); logger.debug("Corrected sum of transition probabilities is {}", newSum); if (!Precision.equals(newSum, 1.0)) { logger.debug("Probabilities do not sum up to one, so doing it again with the Fraction class"); final List<BigFraction> probabilities = new ArrayList<>(outgoingTransitions.size()); for (int i = 0; i < outgoingTransitions.size(); i++) { probabilities.add(i, new BigFraction(outgoingTransitions.get(i).getProbability())); }/*from ww w. j a v a 2s. c o m*/ BigFraction fracSum = BigFraction.ZERO; for (final BigFraction f : probabilities) { try { fracSum = fracSum.add(f); } catch (final MathArithmeticException e) { logger.error("Arithmetic Exception for fracSum={}, FractionToAdd={}", fracSum, f, e); throw e; } } for (int i = 0; i < outgoingTransitions.size(); i++) { changeTransitionProbability(outgoingTransitions.get(i), probabilities.get(i).divide(fracSum).doubleValue()); // outgoingTransitions.get(i).setProbability(probabilities.get(i).divide(fracSum).doubleValue()); } final double tempSum = getOutTransitions(state, true).stream().mapToDouble(t -> t.getProbability()) .sum(); if (!Precision.equals(tempSum, 1.0)) { BigFraction preciseSum = BigFraction.ZERO; for (final BigFraction f : probabilities) { preciseSum = preciseSum.add(f.divide(fracSum)); } if (!preciseSum.equals(BigFraction.ONE)) { throw new IllegalStateException( "Probabilities do not sum up to one, but instead to " + tempSum); } else { logger.warn( "Probabilities do not sum up to one, but instead to {}. This is due to double underflows, but they sum up to one if using BigFraction. This small error will be ignored.", tempSum); } } } } return true; }