コード例 #1
0
 protected String getMathContextValue(
     String value, ItemFormMetadataBean ifm, ItemDataType idt, StringBuffer errorMessage) {
   ResponseOptionBean rob = (ResponseOptionBean) ifm.getResponseSet().getOptions().get(0);
   String widthDecimal = ifm.getWidthDecimal();
   int width = Validator.parseWidth(widthDecimal);
   int decimal = Validator.parseDecimal(widthDecimal);
   NumberFormat nf = NumberFormat.getInstance();
   if (idt.equals(ItemDataType.INTEGER)) {
     try {
       Double d = nf.parse(value).doubleValue();
       int p = 0;
       if (width > 0) {
         p = d >= 0 ? width : width - 1;
       } else {
         p = BigDecimal.valueOf(d).precision();
       }
       MathContext mc = new MathContext(p, RoundingMode.valueOf(BigDecimal.ROUND_HALF_UP));
       value = (new BigDecimal(d, mc)).setScale(0, BigDecimal.ROUND_HALF_UP).toPlainString();
     } catch (ParseException e) {
       logger.error("Number was expected in " + rob.getValue() + " : " + value);
       String exp = rob.getValue();
       exp = exp.replace("##", ",");
       errorMessage.append("Number was expected in" + " " + exp + " : " + value + "; ");
       // errors.append(resexception.getString("number_expected_in")
       // + " " + exp + ": " + value + "; ");
       value = "";
     }
   } else if (idt.equals(ItemDataType.REAL)) {
     try {
       Double d = nf.parse(value).doubleValue();
       // there should be no width specify for calculation item
       int p = BigDecimal.valueOf(d).precision();
       // set default scale as 4
       int scale = decimal > 0 ? decimal : DEFAULT_DECIMAL;
       MathContext mc = new MathContext(p, RoundingMode.valueOf(BigDecimal.ROUND_HALF_UP));
       value = (new BigDecimal(d, mc)).setScale(scale, BigDecimal.ROUND_HALF_UP).toPlainString();
     } catch (Exception ee) {
       String exp = rob.getValue();
       exp = exp.replace("##", ",");
       logger.error("Number was expected in " + exp + " : " + value);
       errorMessage.append("Number was expected in" + " " + exp + " : " + value + "; ");
       // errors.append(resexception.getString("number_expected_in")
       // + " " + exp + ": " + value + "; ");
       value = "";
     }
   }
   return value;
 }
コード例 #2
0
ファイル: IntMath$1.java プロジェクト: pankajk87/CompSecurity
 static 
 {
     $SwitchMap$java$math$RoundingMode = new int[RoundingMode.values().length];
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.UNNECESSARY.ordinal()] = 1;
     }
     catch (NoSuchFieldError nosuchfielderror7) { }
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.DOWN.ordinal()] = 2;
     }
     catch (NoSuchFieldError nosuchfielderror6) { }
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.FLOOR.ordinal()] = 3;
     }
     catch (NoSuchFieldError nosuchfielderror5) { }
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.UP.ordinal()] = 4;
     }
     catch (NoSuchFieldError nosuchfielderror4) { }
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.CEILING.ordinal()] = 5;
     }
     catch (NoSuchFieldError nosuchfielderror3) { }
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.HALF_DOWN.ordinal()] = 6;
     }
     catch (NoSuchFieldError nosuchfielderror2) { }
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.HALF_UP.ordinal()] = 7;
     }
     catch (NoSuchFieldError nosuchfielderror1) { }
     try
     {
         $SwitchMap$java$math$RoundingMode[RoundingMode.HALF_EVEN.ordinal()] = 8;
     }
     catch (NoSuchFieldError nosuchfielderror)
     {
         return;
     }
 }
コード例 #3
0
ファイル: RegressionSuite.java プロジェクト: Volotov/voltdb
  protected static void validateTableColumnOfScalarDecimal(
      VoltTable vt, int col, BigDecimal[] expected) {
    assertNotNull(expected);
    assertEquals(expected.length, vt.getRowCount());
    int len = expected.length;
    for (int i = 0; i < len; i++) {
      assertTrue(vt.advanceRow());
      BigDecimal actual = vt.getDecimalAsBigDecimal(col);

      if (expected[i] == null) {
        assertTrue(vt.wasNull());
        assertEquals(null, actual);
      } else {
        BigDecimal rounded =
            expected[i].setScale(m_defaultScale, RoundingMode.valueOf(m_defaultRoundingMode));
        assertEquals(rounded, actual);
      }
    }
  }
コード例 #4
0
 public static NumberFormatValue getInstance(String numberFormat) {
   if (numberFormat != null) {
     NumberFormatValue value = new NumberFormatValue();
     Matcher matcher = pattern.matcher(numberFormat);
     if (matcher.matches()) {
       String f = matcher.group(1);
       if (f != null && f.length() > 0) {
         value.format = f;
         int index = f.lastIndexOf('.');
         if (index > 0) {
           int end = f.length();
           for (int i = index + 1; i < f.length(); i++) {
             if (f.charAt(i) != '0') {
               end = i;
               break;
             }
           }
           value.fractionDigits = end - 1 - index;
         }
         char lastChar = f.charAt(f.length() - 1);
         switch (lastChar) {
           case '%':
             value.fractionDigits += 2;
             break;
           case '‰':
             value.fractionDigits += 3;
             break;
           case '‱':
             value.fractionDigits += 4;
             break;
         }
       }
       String m = matcher.group(2);
       if (m != null) {
         value.roundingMode = RoundingMode.valueOf(m);
       }
     } else {
       value.format = numberFormat;
     }
     return value;
   }
   return null;
 }
コード例 #5
0
/**
 * Exhaustive input sets for every integral type.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
public class MathTesting {
  static final ImmutableSet<RoundingMode> ALL_ROUNDING_MODES =
      ImmutableSet.copyOf(RoundingMode.values());

  static final ImmutableList<RoundingMode> ALL_SAFE_ROUNDING_MODES =
      ImmutableList.of(DOWN, UP, FLOOR, CEILING, HALF_EVEN, HALF_UP, HALF_DOWN);

  // Exponents to test for the pow() function.
  static final ImmutableList<Integer> EXPONENTS =
      ImmutableList.of(0, 1, 2, 3, 4, 7, 10, 15, 20, 25, 40, 70);

  /* Helper function to make a Long value from an Integer. */
  private static final Function<Integer, Long> TO_LONG =
      new Function<Integer, Long>() {
        @Override
        public Long apply(Integer n) {
          return Long.valueOf(n);
        }
      };

  /* Helper function to make a BigInteger value from a Long. */
  private static final Function<Long, BigInteger> TO_BIGINTEGER =
      new Function<Long, BigInteger>() {
        @Override
        public BigInteger apply(Long n) {
          return BigInteger.valueOf(n);
        }
      };

  private static final Function<Integer, Integer> NEGATE_INT =
      new Function<Integer, Integer>() {
        @Override
        public Integer apply(Integer x) {
          return -x;
        }
      };

  private static final Function<Long, Long> NEGATE_LONG =
      new Function<Long, Long>() {
        @Override
        public Long apply(Long x) {
          return -x;
        }
      };

  private static final Function<BigInteger, BigInteger> NEGATE_BIGINT =
      new Function<BigInteger, BigInteger>() {
        @Override
        public BigInteger apply(BigInteger x) {
          return x.negate();
        }
      };

  /*
   * This list contains values that attempt to provoke overflow in integer operations. It contains
   * positive values on or near 2^N for N near multiples of 8 (near byte boundaries).
   */
  static final ImmutableSet<Integer> POSITIVE_INTEGER_CANDIDATES;

  static final Iterable<Integer> NEGATIVE_INTEGER_CANDIDATES;

  static final Iterable<Integer> NONZERO_INTEGER_CANDIDATES;

  static final Iterable<Integer> ALL_INTEGER_CANDIDATES;

  static {
    ImmutableSet.Builder<Integer> intValues = ImmutableSet.builder();
    // Add boundary values manually to avoid over/under flow (this covers 2^N for 0 and 31).
    intValues.add(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
    // Add values up to 40. This covers cases like "square of a prime" and such.
    for (int i = 1; i <= 40; i++) {
      intValues.add(i);
    }
    // Now add values near 2^N for lots of values of N.
    for (int exponent : asList(2, 3, 4, 9, 15, 16, 17, 24, 25, 30)) {
      int x = 1 << exponent;
      intValues.add(x, x + 1, x - 1);
    }
    intValues.add(9999).add(10000).add(10001).add(1000000); // near powers of 10
    intValues.add(5792).add(5793); // sqrt(2^25) rounded up and down
    POSITIVE_INTEGER_CANDIDATES = intValues.build();
    NEGATIVE_INTEGER_CANDIDATES =
        ImmutableList.copyOf(
            Iterables.concat(
                Iterables.transform(POSITIVE_INTEGER_CANDIDATES, NEGATE_INT),
                ImmutableList.of(Integer.MIN_VALUE)));
    NONZERO_INTEGER_CANDIDATES =
        ImmutableList.copyOf(
            Iterables.concat(POSITIVE_INTEGER_CANDIDATES, NEGATIVE_INTEGER_CANDIDATES));
    ALL_INTEGER_CANDIDATES = Iterables.concat(NONZERO_INTEGER_CANDIDATES, ImmutableList.of(0));
  }

  /*
   * This list contains values that attempt to provoke overflow in long operations. It contains
   * positive values on or near 2^N for N near multiples of 8 (near byte boundaries). This list is
   * a superset of POSITIVE_INTEGER_CANDIDATES.
   */
  static final ImmutableSet<Long> POSITIVE_LONG_CANDIDATES;

  static final Iterable<Long> NEGATIVE_LONG_CANDIDATES;

  static final Iterable<Long> NONZERO_LONG_CANDIDATES;

  static final Iterable<Long> ALL_LONG_CANDIDATES;

  static {
    ImmutableSet.Builder<Long> longValues = ImmutableSet.builder();
    // First of all add all the integer candidate values.
    longValues.addAll(Iterables.transform(POSITIVE_INTEGER_CANDIDATES, TO_LONG));
    // Add boundary values manually to avoid over/under flow (this covers 2^N for 31 and 63).
    longValues.add(Integer.MAX_VALUE + 1L, Long.MAX_VALUE - 1L, Long.MAX_VALUE);
    // Now add values near 2^N for lots of values of N.
    for (int exponent : asList(32, 33, 39, 40, 41, 47, 48, 49, 55, 56, 57)) {
      long x = 1L << exponent;
      longValues.add(x, x + 1, x - 1);
    }
    longValues.add(194368031998L).add(194368031999L); // sqrt(2^75) rounded up and down
    POSITIVE_LONG_CANDIDATES = longValues.build();
    NEGATIVE_LONG_CANDIDATES =
        Iterables.concat(
            Iterables.transform(POSITIVE_LONG_CANDIDATES, NEGATE_LONG),
            ImmutableList.of(Long.MIN_VALUE));
    NONZERO_LONG_CANDIDATES = Iterables.concat(POSITIVE_LONG_CANDIDATES, NEGATIVE_LONG_CANDIDATES);
    ALL_LONG_CANDIDATES = Iterables.concat(NONZERO_LONG_CANDIDATES, ImmutableList.of(0L));
  }

  /*
   * This list contains values that attempt to provoke overflow in big integer operations. It
   * contains positive values on or near 2^N for N near multiples of 8 (near byte boundaries). This
   * list is a superset of POSITIVE_LONG_CANDIDATES.
   */
  static final ImmutableSet<BigInteger> POSITIVE_BIGINTEGER_CANDIDATES;

  static final Iterable<BigInteger> NEGATIVE_BIGINTEGER_CANDIDATES;

  static final Iterable<BigInteger> NONZERO_BIGINTEGER_CANDIDATES;

  static final Iterable<BigInteger> ALL_BIGINTEGER_CANDIDATES;

  static {
    ImmutableSet.Builder<BigInteger> bigValues = ImmutableSet.builder();
    // First of all add all the long candidate values.
    bigValues.addAll(Iterables.transform(POSITIVE_LONG_CANDIDATES, TO_BIGINTEGER));
    // Add boundary values manually to avoid over/under flow.
    bigValues.add(BigInteger.valueOf(Long.MAX_VALUE).add(ONE));
    // Now add values near 2^N for lots of values of N.
    for (int exponent :
        asList(
            64,
            65,
            71,
            72,
            73,
            79,
            80,
            81,
            255,
            256,
            257,
            511,
            512,
            513,
            Double.MAX_EXPONENT - 1,
            Double.MAX_EXPONENT,
            Double.MAX_EXPONENT + 1)) {
      BigInteger x = ONE.shiftLeft(exponent);
      bigValues.add(x, x.add(ONE), x.subtract(ONE));
    }
    bigValues.add(new BigInteger("218838949120258359057546633")); // sqrt(2^175) rounded up and
    // down
    bigValues.add(new BigInteger("218838949120258359057546634"));
    POSITIVE_BIGINTEGER_CANDIDATES = bigValues.build();
    NEGATIVE_BIGINTEGER_CANDIDATES =
        Iterables.transform(POSITIVE_BIGINTEGER_CANDIDATES, NEGATE_BIGINT);
    NONZERO_BIGINTEGER_CANDIDATES =
        Iterables.concat(POSITIVE_BIGINTEGER_CANDIDATES, NEGATIVE_BIGINTEGER_CANDIDATES);
    ALL_BIGINTEGER_CANDIDATES =
        Iterables.concat(NONZERO_BIGINTEGER_CANDIDATES, ImmutableList.of(ZERO));
  }

  static final ImmutableSet<Double> INTEGRAL_DOUBLE_CANDIDATES;
  static final ImmutableSet<Double> FRACTIONAL_DOUBLE_CANDIDATES;
  static final Iterable<Double> INFINITIES =
      Doubles.asList(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY);
  static final Iterable<Double> FINITE_DOUBLE_CANDIDATES;
  static final Iterable<Double> POSITIVE_FINITE_DOUBLE_CANDIDATES;
  static final Iterable<Double> ALL_DOUBLE_CANDIDATES;
  static final Iterable<Double> DOUBLE_CANDIDATES_EXCEPT_NAN;

  static {
    ImmutableSet.Builder<Double> integralBuilder = ImmutableSet.builder();
    ImmutableSet.Builder<Double> fractionalBuilder = ImmutableSet.builder();
    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL
    for (int scale = 1; scale <= 4; scale++) {
      for (double d : Doubles.asList(Double.MIN_VALUE, Double.MIN_NORMAL)) {
        fractionalBuilder.add(d * scale).add(-d * scale);
      }
    }
    for (double d :
        Doubles.asList(
            0,
            1,
            2,
            7,
            51,
            102,
            Math.scalb(1.0, 53),
            Integer.MIN_VALUE,
            Integer.MAX_VALUE,
            Long.MIN_VALUE,
            Long.MAX_VALUE)) {
      for (double delta : Doubles.asList(0.0, 1.0, 2.0)) {
        integralBuilder.addAll(Doubles.asList(d + delta, d - delta, -d - delta, -d + delta));
      }
      for (double delta : Doubles.asList(0.01, 0.1, 0.25, 0.499, 0.5, 0.501, 0.7, 0.8)) {
        double x = d + delta;
        if (x != Math.round(x)) {
          fractionalBuilder.add(x);
        }
      }
    }
    INTEGRAL_DOUBLE_CANDIDATES = integralBuilder.build();
    fractionalBuilder.add(1.414).add(1.415).add(Math.sqrt(2));
    fractionalBuilder.add(5.656).add(5.657).add(4 * Math.sqrt(2));
    for (double d : INTEGRAL_DOUBLE_CANDIDATES) {
      double x = 1 / d;
      if (x != Math.rint(x)) {
        fractionalBuilder.add(x);
      }
    }
    FRACTIONAL_DOUBLE_CANDIDATES = fractionalBuilder.build();
    FINITE_DOUBLE_CANDIDATES =
        Iterables.concat(FRACTIONAL_DOUBLE_CANDIDATES, INTEGRAL_DOUBLE_CANDIDATES);
    POSITIVE_FINITE_DOUBLE_CANDIDATES =
        Iterables.filter(
            FINITE_DOUBLE_CANDIDATES,
            new Predicate<Double>() {
              @Override
              public boolean apply(Double input) {
                return input.doubleValue() > 0.0;
              }
            });
    DOUBLE_CANDIDATES_EXCEPT_NAN = Iterables.concat(FINITE_DOUBLE_CANDIDATES, INFINITIES);
    ALL_DOUBLE_CANDIDATES = Iterables.concat(DOUBLE_CANDIDATES_EXCEPT_NAN, asList(Double.NaN));
  }
}
コード例 #6
0
ファイル: AccountingRules.java プロジェクト: neeturawat/head
 public static void setFinalRoundingMode(RoundingMode finalRoundingMode) {
   MifosConfigurationManager.getInstance()
       .setProperty(AccountingRulesConstants.FINAL_ROUNDING_MODE, finalRoundingMode.name());
 }
コード例 #7
0
ファイル: AccountingRules.java プロジェクト: neeturawat/head
 public static void setInitialRoundingMode(RoundingMode intialRoundingMode) {
   MifosConfigurationManager.getInstance()
       .setProperty(AccountingRulesConstants.INITIAL_ROUNDING_MODE, intialRoundingMode.name());
 }
コード例 #8
0
ファイル: AccountingRules.java プロジェクト: neeturawat/head
 public static void setCurrencyRoundingMode(RoundingMode currencyRoundingMode) {
   MifosConfigurationManager.getInstance()
       .setProperty(AccountingRulesConstants.CURRENCY_ROUNDING_MODE, currencyRoundingMode.name());
 }
コード例 #9
0
ファイル: AccountingRules.java プロジェクト: neeturawat/head
 public static void setRoundingRule(RoundingMode mode) {
   MifosConfigurationManager.getInstance()
       .setProperty(AccountingRulesConstants.ROUNDING_RULE, mode.name());
 }
コード例 #10
0
ファイル: ServiceRepository.java プロジェクト: ciukstar/eupp
 public RoundingMode[] findAllRoundingModes() {
   return RoundingMode.values();
 }