Examples with RoundingMode java.math.RoundingMode used on opensource projects

Example 31 with RoundingMode

use of java.math.RoundingMode in project jdk8u_jdk by JetBrains.

the class TieRoundingTest method formatOutputTestDouble.

static void formatOutputTestDouble(NumberFormat nf, double doubleToTest, String tiePosition, String inputDigits, String expectedOutput) {
    int mfd = nf.getMaximumFractionDigits();
    RoundingMode rm = nf.getRoundingMode();
    String result = nf.format(doubleToTest);
    if (!result.equals(expectedOutput)) {
        System.out.println();
        System.out.println("========================================");
        System.out.println("***Failure : error formatting value from string : " + inputDigits);
        System.out.println("NumberFormat pattern is  : " + ((DecimalFormat) nf).toPattern());
        System.out.println("Maximum number of fractional digits : " + mfd);
        System.out.println("Fractional rounding digit : " + (mfd + 1));
        System.out.println("Position of value relative to tie : " + tiePosition);
        System.out.println("Rounding Mode : " + rm);
        System.out.println("BigDecimal output : " + new BigDecimal(doubleToTest).toString());
        System.out.println("FloatingDecimal output : " + doubleToTest);
        System.out.println("Error. Formatted result different from expected." + "\nExpected output is : \"" + expectedOutput + "\"" + "\nFormated output is : \"" + result + "\"");
        System.out.println("========================================");
        System.out.println();
        errorCounter++;
        allPassed = false;
    } else {
        testCounter++;
        System.out.println("\nSuccess for double value : " + doubleToTest + " :");
        System.out.println(" Input digits :" + inputDigits + ", BigDecimal value : " + new BigDecimal(doubleToTest).toString());
        System.out.print(" Rounding mode: " + rm);
        System.out.print(", fract digits : " + mfd);
        System.out.print(", position : " + tiePosition + " tie");
        System.out.print(", result : " + result);
        System.out.println(", expected : " + expectedOutput);
    }
}

Example 32 with RoundingMode

use of java.math.RoundingMode in project jdk8u_jdk by JetBrains.

the class RoundingAndPropertyTest method testSettersAndFastPath.

/* This methods checks the behaviour of the management of properties
     * of a DecimalFormat instance that satisfies fast-path constraints.
     *
     * It does this by comparing the results of the format(double) output
     * obtained from initial fast-path state with the output provided by
     * the same instance that has been pushed and exercised outside
     * fast-path rules and finally "reverted" to its initial fast-path state.
     *
     * The schema of actions is this :
     *  - Call format(double) on a known DecimalFormat fast-path instance,
     *    and store this result.
     *  - Record the current state of a given property.
     *  - Change the property to invalidate the fast-path state.
     *  - Call again format(double) on the instance.
     *  - Revert state of property to validate again fast-path context.
     *  - Call format(double) again.
     *  - Check that first and last call to format(double) provide same result
     *  - Record failure if any.
     *  - Do the same for another property with the same instance.
     * So all the property changes are chained one after the other on only the
     * same instance.
     *
     * Some properties that currently do not influence the fast-path state
     * are also tested. This is not useful with current fast-path source
     * but is here for testing the whole set of properties. This is the case
     * for prefixes and suffixes, and parseBigDecimal properties.
     */
private static int testSettersAndFastPath(DecimalFormat df, boolean isCurrency) {
    final double d1 = GoldenDoubleValues.PROPERTY_CHECK_POSITIVE_VALUE;
    final double d2 = GoldenDoubleValues.PROPERTY_CHECK_NEGATIVE_VALUE;
    int errors = 0;
    boolean testSucceeded = false;
    String firstFormatResult;
    String secondFormatResult;
    String propertyName;
    // ---- positivePrefix property test ----
    testSucceeded = false;
    propertyName = "positivePrefix";
    System.out.print("Checking " + propertyName + " property.");
    String initialPrefix = df.getPositivePrefix();
    firstFormatResult = df.format(d1);
    df.setPositivePrefix("positivePrefix:");
    df.format(d1);
    df.setPositivePrefix(initialPrefix);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- positiveSuffix property test ----
    testSucceeded = false;
    propertyName = "positiveSuffix";
    System.out.print("Checking " + propertyName + " property.");
    String initialSuffix = df.getPositiveSuffix();
    firstFormatResult = df.format(d1);
    df.setPositiveSuffix("positiveSuffix:");
    df.format(d1);
    df.setPositiveSuffix(initialSuffix);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- negativePrefix property test ----
    testSucceeded = false;
    propertyName = "negativePrefix";
    System.out.print("Checking " + propertyName + " property.");
    initialPrefix = df.getNegativePrefix();
    firstFormatResult = df.format(d1);
    df.setNegativePrefix("negativePrefix:");
    df.format(d1);
    df.setNegativePrefix(initialPrefix);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- negativeSuffix property test ----
    testSucceeded = false;
    propertyName = "negativeSuffix";
    System.out.print("Checking " + propertyName + " property.");
    initialSuffix = df.getNegativeSuffix();
    firstFormatResult = df.format(d1);
    df.setNegativeSuffix("negativeSuffix:");
    df.format(d1);
    df.setNegativeSuffix(initialSuffix);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- multiplier property test ----
    testSucceeded = false;
    propertyName = "multiplier";
    System.out.print("Checking " + propertyName + " property.");
    int initialMultiplier = df.getMultiplier();
    firstFormatResult = df.format(d1);
    df.setMultiplier(10);
    df.format(d1);
    df.setMultiplier(initialMultiplier);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- groupingUsed property test ----
    testSucceeded = false;
    propertyName = "groupingUsed";
    System.out.print("Checking " + propertyName + " property.");
    boolean initialGroupingUsed = df.isGroupingUsed();
    firstFormatResult = df.format(d1);
    df.setGroupingUsed(!initialGroupingUsed);
    df.format(d1);
    df.setGroupingUsed(initialGroupingUsed);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- groupingSize property test ----
    testSucceeded = false;
    propertyName = "groupingSize";
    System.out.print("Checking " + propertyName + " property.");
    int initialGroupingSize = df.getGroupingSize();
    firstFormatResult = df.format(d1);
    df.setGroupingSize(initialGroupingSize + 1);
    df.format(d1);
    df.setGroupingSize(initialGroupingSize);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- decimalSeparatorAlwaysShown property test ----
    testSucceeded = false;
    propertyName = "decimalSeparatorAlwaysShown";
    System.out.print("Checking " + propertyName + " property.");
    boolean initialDSShown = df.isDecimalSeparatorAlwaysShown();
    firstFormatResult = df.format(d1);
    df.setDecimalSeparatorAlwaysShown(!initialDSShown);
    df.format(d1);
    df.setDecimalSeparatorAlwaysShown(initialDSShown);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- parseBigDecimal property test ----
    testSucceeded = false;
    propertyName = "parseBigDecimal";
    System.out.print("Checking " + propertyName + " property.");
    boolean initialParseBigdecimal = df.isParseBigDecimal();
    firstFormatResult = df.format(d1);
    df.setParseBigDecimal(!initialParseBigdecimal);
    df.format(d1);
    df.setParseBigDecimal(initialParseBigdecimal);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- maximumIntegerDigits property test ----
    testSucceeded = false;
    propertyName = "maximumIntegerDigits";
    System.out.print("Checking " + propertyName + " property.");
    int initialMaxIDs = df.getMaximumIntegerDigits();
    firstFormatResult = df.format(d1);
    df.setMaximumIntegerDigits(8);
    df.format(d1);
    df.setMaximumIntegerDigits(initialMaxIDs);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- minimumIntegerDigits property test ----
    testSucceeded = false;
    propertyName = "minimumIntegerDigits";
    System.out.print("Checking " + propertyName + " property.");
    int initialMinIDs = df.getMinimumIntegerDigits();
    firstFormatResult = df.format(d1);
    df.setMinimumIntegerDigits(2);
    df.format(d1);
    df.setMinimumIntegerDigits(initialMinIDs);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- maximumFractionDigits property test ----
    testSucceeded = false;
    propertyName = "maximumFractionDigits";
    System.out.print("Checking " + propertyName + " property.");
    firstFormatResult = df.format(d1);
    df.setMaximumFractionDigits(8);
    df.format(d1);
    if (isCurrency) {
        df.setMinimumFractionDigits(2);
        df.setMaximumFractionDigits(2);
    } else {
        df.setMinimumFractionDigits(0);
        df.setMaximumFractionDigits(3);
    }
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- minimumFractionDigits property test ----
    testSucceeded = false;
    propertyName = "minimumFractionDigits";
    System.out.print("Checking " + propertyName + " property.");
    firstFormatResult = df.format(d1);
    df.setMinimumFractionDigits(1);
    df.format(d1);
    if (isCurrency) {
        df.setMinimumFractionDigits(2);
        df.setMaximumFractionDigits(2);
    } else {
        df.setMinimumFractionDigits(0);
        df.setMaximumFractionDigits(3);
    }
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- currency property test ----
    testSucceeded = false;
    propertyName = "currency";
    System.out.print("Checking " + propertyName + " property.");
    Currency initialCurrency = df.getCurrency();
    Currency japanCur = java.util.Currency.getInstance(Locale.JAPAN);
    firstFormatResult = df.format(d1);
    df.setCurrency(japanCur);
    df.format(d1);
    df.setCurrency(initialCurrency);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- roundingMode property test ----
    testSucceeded = false;
    propertyName = "roundingMode";
    System.out.print("Checking " + propertyName + " property.");
    RoundingMode initialRMode = df.getRoundingMode();
    firstFormatResult = df.format(d1);
    df.setRoundingMode(RoundingMode.HALF_UP);
    df.format(d1);
    df.setRoundingMode(RoundingMode.HALF_EVEN);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    // ---- decimalFormatSymbols property test ----
    testSucceeded = false;
    propertyName = "decimalFormatSymbols";
    System.out.print("Checking " + propertyName + " property.");
    DecimalFormatSymbols initialDecimalFormatSymbols = df.getDecimalFormatSymbols();
    firstFormatResult = df.format(d1);
    Locale bizarreLocale = new Locale("fr", "FR");
    DecimalFormatSymbols unusualSymbols = new DecimalFormatSymbols(bizarreLocale);
    unusualSymbols.setDecimalSeparator('@');
    unusualSymbols.setGroupingSeparator('|');
    df.setDecimalFormatSymbols(unusualSymbols);
    df.format(d1);
    df.setDecimalFormatSymbols(initialDecimalFormatSymbols);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    testSucceeded = false;
    System.out.print("Checking " + propertyName + " property.");
    initialDecimalFormatSymbols = df.getDecimalFormatSymbols();
    firstFormatResult = df.format(d1);
    Locale japanLocale = Locale.JAPAN;
    unusualSymbols = new DecimalFormatSymbols(japanLocale);
    unusualSymbols.setDecimalSeparator('9');
    unusualSymbols.setGroupingSeparator('0');
    df.setDecimalFormatSymbols(unusualSymbols);
    df.format(d1);
    df.setDecimalFormatSymbols(initialDecimalFormatSymbols);
    secondFormatResult = df.format(d1);
    testSucceeded = resultsEqual(propertyName, firstFormatResult, secondFormatResult);
    if (!testSucceeded)
        errors++;
    return errors;
}

Example 33 with RoundingMode

use of java.math.RoundingMode in project knime-core by knime.

the class AutoBinnerLearnNodeDialogPane method createNumberFormatSettingsTab.

private JPanel createNumberFormatSettingsTab() {
    JPanel p = new JPanel(new GridBagLayout());
    m_defaultFormatting = new JRadioButton("Default formatting");
    m_advancedFormatting = new JRadioButton("Advanced formatting");
    ButtonGroup formatting = new ButtonGroup();
    formatting.add(m_defaultFormatting);
    formatting.add(m_advancedFormatting);
    m_outputFormat = new JComboBox<OutputFormat>(OutputFormat.values());
    m_precision = new JSpinner(new SpinnerNumberModel(3, 0, Integer.MAX_VALUE, 1));
    m_precisionMode = new JComboBox<PrecisionMode>(PrecisionMode.values());
    m_roundingMode = new JComboBox<RoundingMode>(getRoundingModes());
    ActionListener formattingListener = new ActionListener() {

        @Override
        public void actionPerformed(final ActionEvent e) {
            m_outputFormat.setEnabled(m_advancedFormatting.isSelected());
            m_precision.setEnabled(m_advancedFormatting.isSelected());
            m_precisionMode.setEnabled(m_advancedFormatting.isSelected());
            m_roundingMode.setEnabled(m_advancedFormatting.isSelected());
        }
    };
    m_defaultFormatting.addActionListener(formattingListener);
    m_advancedFormatting.addActionListener(formattingListener);
    GridBagConstraints gbc = new GridBagConstraints();
    Insets indentedInsets = new Insets(5, 15, 5, 5);
    Insets normalInsets = new Insets(5, 5, 5, 5);
    gbc.insets = normalInsets;
    gbc.anchor = GridBagConstraints.NORTHWEST;
    gbc.fill = GridBagConstraints.BOTH;
    gbc.weightx = 0;
    gbc.weighty = 0;
    gbc.gridx = 0;
    gbc.gridy = 0;
    gbc.gridwidth = 2;
    p.add(m_defaultFormatting, gbc);
    gbc.gridy++;
    p.add(m_advancedFormatting, gbc);
    gbc.gridwidth = 1;
    gbc.gridy++;
    gbc.insets = indentedInsets;
    p.add(new JLabel("Output format"), gbc);
    gbc.gridx++;
    gbc.insets = normalInsets;
    p.add(m_outputFormat, gbc);
    gbc.gridx = 0;
    gbc.gridy++;
    gbc.insets = indentedInsets;
    p.add(new JLabel("Precision"), gbc);
    gbc.gridx++;
    gbc.insets = normalInsets;
    p.add(m_precision, gbc);
    gbc.gridx = 0;
    gbc.gridy++;
    gbc.insets = indentedInsets;
    p.add(new JLabel("Precision mode"), gbc);
    gbc.gridx++;
    gbc.insets = normalInsets;
    p.add(m_precisionMode, gbc);
    gbc.gridx = 0;
    gbc.gridy++;
    gbc.insets = indentedInsets;
    p.add(new JLabel("Rounding mode"), gbc);
    gbc.gridx++;
    gbc.insets = normalInsets;
    p.add(m_roundingMode, gbc);
    gbc.gridx++;
    gbc.gridy++;
    gbc.weightx = 1;
    gbc.weighty = 1;
    gbc.insets = new Insets(0, 0, 0, 0);
    p.add(new JLabel(), gbc);
    return p;
}

Example 34 with RoundingMode

use of java.math.RoundingMode in project ojAlgo by optimatika.

the class NumberContext method getPercent.

public static NumberContext getPercent(final int scale, final Locale locale) {
    final NumberFormat tmpFormat = NumberStyle.PERCENT.getFormat(locale);
    final int tmpPrecision = MathContext.DECIMAL32.getPrecision();
    final int tmpScale = scale;
    final RoundingMode tmpRoundingMode = MathContext.DECIMAL32.getRoundingMode();
    return new NumberContext(tmpFormat, tmpPrecision, tmpScale, tmpRoundingMode);
}

Example 35 with RoundingMode

use of java.math.RoundingMode in project ojAlgo by optimatika.

the class NumberContext method getGeneral.

public static NumberContext getGeneral(final int scale, final RoundingMode roundingMode) {
    final NumberFormat tmpFormat = NumberStyle.GENERAL.getFormat();
    final int tmpPrecision = DEFAULT_MATH.getPrecision();
    final int tmpScale = scale;
    final RoundingMode tmpRoundingMode = roundingMode;
    return new NumberContext(tmpFormat, tmpPrecision, tmpScale, tmpRoundingMode);
}