Example usage for org.apache.commons.math3.fraction BigFraction BigFraction

Introduction

In this page you can find the example usage for org.apache.commons.math3.fraction BigFraction BigFraction.

Prototype

public BigFraction(final long num)

Source Link

Document

Create a BigFraction equivalent to the passed long, ie "num / 1".

Usage

From source file:com.netflix.imfutility.cpl._2013.Cpl2013ContextBuilderStrategy.java

@Override
public BigFraction getCompositionTimecodeRate() {
    if (cpl2013.getCompositionTimecode() == null) {
        return null;
    }//from   w  w w.  j  a v a 2s .co  m
    BigInteger rate = cpl2013.getCompositionTimecode().getTimecodeRate();
    boolean isDropFrame = cpl2013.getCompositionTimecode().isTimecodeDropFrame();
    if (rate == null || BigInteger.ZERO.equals(rate)) {
        return null;
    }

    // return as-is if non-drop
    if (!isDropFrame) {
        return new BigFraction(rate);
    }

    // return as 30000/1001 for 30 if drop frame
    return new BigFraction(rate.multiply(BigInteger.valueOf(1000)), BigInteger.valueOf(1001));
}

From source file:cc.redberry.core.number.Rational.java

/**
 * @see BigFraction#BigFraction(long)
 */
public Rational(long num) {
    fraction = new BigFraction(num);
}

From source file:com.netflix.imfutility.util.ConversionHelper.java

/**
 * Converts the edit untis to milliseconds according to the given edit rate.
 *
 * @param eu         edit units number//  ww w.j  a  v  a2 s .co  m
 * @param unitsInSec edit rate
 * @return milliseconds
 */
public static long editUnitToMilliSeconds(BigInteger eu, BigFraction unitsInSec) {
    BigFraction editUnits = new BigFraction(eu);
    return editUnits.divide(unitsInSec).multiply(1000).longValue();
}

From source file:com.netflix.imfutility.util.ConversionHelper.java

/**
 * Converts the edit untis to seconds according to the given edit rate.
 *
 * @param eu         edit units number//from w  w w.  j a  v  a  2 s .  co  m
 * @param unitsInSec edit rate
 * @return seconds
 */
public static long toSeconds(BigInteger eu, BigFraction unitsInSec) {
    BigFraction editUnits = new BigFraction(eu);
    return editUnits.divide(unitsInSec).longValue();
}

From source file:controller.CLI.java

private String parseReplace(String[] args) {
    String syntax = Data.SYNTAX.get(Data.replace);

    LP lp;/*from w  w  w  .j  a  v  a  2s. co  m*/
    int size = lps.get(p - 1).getNoBasic();

    if (args.length == 1) {
        lp = lps.get(p - 1).phaseOneObj();
    } else if (args.length == (size + 1)) {
        BigFraction[] coeff = new BigFraction[size];

        for (int i = 0; i < size; i++) {
            try {
                coeff[i] = new BigFraction(Double.parseDouble(args[i + 1]));
            } catch (NumberFormatException err) {
                return Data.SYNTAX.get(Data.replace);
            }
        }
        lp = lps.get(p - 1).replaceObj(coeff);
    } else {
        return syntax;
    }
    lps.add(p++, lp);
    return Output.primal(lp, stdPrec);
}

From source file:org.matheclipse.commons.parser.client.eval.bigfraction.BigFractionEvaluator.java

public void setValue(FieldElementVariable<BigFraction> variable, double value) {
    variable.setValue(new BigFraction(value));
}

From source file:org.matheclipse.commons.parser.client.eval.bigfraction.BigFractionEvaluator.java

@Override
public BigFraction visit(DoubleNode node) {
    return new BigFraction(node.doubleValue());
}

From source file:org.matheclipse.commons.parser.client.eval.bigfraction.BigFractionEvaluator.java

@Override
public BigFraction visit(FloatNode node) {
    return new BigFraction(node.doubleValue());
}

From source file:org.matheclipse.commons.parser.client.eval.bigfraction.BigFractionVariable.java

public void setValue(int value) {
    this.value = new BigFraction(value);
}

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   w w w .  j a  va 2  s. 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;
}