| /* |
| * Copyright 2009 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with this |
| * work for additional information regarding copyright ownership. The ASF |
| * licenses this file to You under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| * |
| * INCLUDES MODIFICATIONS BY RICHARD ZSCHECH AS WELL AS GOOGLE. |
| */ |
| package java.math; |
| |
| /** |
| * Specifies the rounding behavior for operations whose results cannot be |
| * represented exactly. |
| */ |
| public enum RoundingMode { |
| |
| /** |
| * Rounding mode where positive values are rounded towards positive infinity |
| * and negative values towards negative infinity. <br> |
| * Rule: {@code x.round().abs() >= x.abs()} |
| */ |
| UP(BigDecimal.ROUND_UP), |
| |
| /** |
| * Rounding mode where the values are rounded towards zero. <br> |
| * Rule: {@code x.round().abs() <= x.abs()} |
| */ |
| DOWN(BigDecimal.ROUND_DOWN), |
| |
| /** |
| * Rounding mode to round towards positive infinity. For positive values this |
| * rounding mode behaves as {@link #UP}, for negative values as {@link #DOWN}. <br> |
| * Rule: {@code x.round() >= x} |
| */ |
| CEILING(BigDecimal.ROUND_CEILING), |
| |
| /** |
| * Rounding mode to round towards negative infinity. For positive values this |
| * rounding mode behaves as {@link #DOWN}, for negative values as {@link #UP}. <br> |
| * Rule: {@code x.round() <= x} |
| */ |
| FLOOR(BigDecimal.ROUND_FLOOR), |
| |
| /** |
| * Rounding mode where values are rounded towards the nearest neighbor. Ties |
| * are broken by rounding up. |
| */ |
| HALF_UP(BigDecimal.ROUND_HALF_UP), |
| |
| /** |
| * Rounding mode where values are rounded towards the nearest neighbor. Ties |
| * are broken by rounding down. |
| */ |
| HALF_DOWN(BigDecimal.ROUND_HALF_DOWN), |
| |
| /** |
| * Rounding mode where values are rounded towards the nearest neighbor. Ties |
| * are broken by rounding to the even neighbor. |
| */ |
| HALF_EVEN(BigDecimal.ROUND_HALF_EVEN), |
| |
| /** |
| * Rounding mode where the rounding operations throws an ArithmeticException |
| * for the case that rounding is necessary, i.e. for the case that the value |
| * cannot be represented exactly. |
| */ |
| UNNECESSARY(BigDecimal.ROUND_UNNECESSARY); |
| |
| /** |
| * Some constant char arrays for optimized comparisons |
| */ |
| private static final char[] chCEILING = {'C','E','I','L','I','N','G'}; |
| private static final char[] chDOWN = {'D','O','W','N'}; |
| private static final char[] chFLOOR = {'F','L','O','O','R'}; |
| private static final char[] chHALF_DOWN = {'H','A','L','F','_','D','O','W','N'}; |
| private static final char[] chHALF_EVEN = {'H','A','L','F','_','E','V','E','N'}; |
| private static final char[] chHALF_UP = {'H','A','L','F','_','U','P'}; |
| private static final char[] chUNNECESSARY = {'U','N','N','E','C','E','S','S','A','R','Y'}; |
| private static final char[] chUP = {'U','P'}; |
| |
| /** |
| * Converts rounding mode constants from class {@code BigDecimal} into {@code |
| * RoundingMode} values. |
| * |
| * @param mode rounding mode constant as defined in class {@code BigDecimal} |
| * @return corresponding rounding mode object |
| */ |
| public static RoundingMode valueOf(int mode) { |
| switch (mode) { |
| case BigDecimal.ROUND_CEILING: |
| return CEILING; |
| case BigDecimal.ROUND_DOWN: |
| return DOWN; |
| case BigDecimal.ROUND_FLOOR: |
| return FLOOR; |
| case BigDecimal.ROUND_HALF_DOWN: |
| return HALF_DOWN; |
| case BigDecimal.ROUND_HALF_EVEN: |
| return HALF_EVEN; |
| case BigDecimal.ROUND_HALF_UP: |
| return HALF_UP; |
| case BigDecimal.ROUND_UNNECESSARY: |
| return UNNECESSARY; |
| case BigDecimal.ROUND_UP: |
| return UP; |
| default: |
| // math.00=Invalid rounding mode |
| throw new IllegalArgumentException("Invalid rounding mode"); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Bypasses calls to the implicit valueOf(String) method, which will break |
| * if enum name obfuscation is enabled. This should be package visible only. |
| * |
| * @param mode rounding mode string as defined in class {@code BigDecimal} |
| * @return corresponding rounding mode object |
| */ |
| static RoundingMode valueOfExplicit(String mode) { |
| /* |
| * Note this is optimized to avoid multiple String compares, |
| * using specific knowledge of the set of allowed enum constants. |
| */ |
| |
| if (mode == null) { |
| throw new NullPointerException(); |
| } |
| |
| char[] modeChars = mode.toCharArray(); |
| int len = modeChars.length; |
| if (len < chUP.length || len > chUNNECESSARY.length) { |
| throw new IllegalArgumentException(); |
| } |
| |
| char[] targetChars = null; |
| RoundingMode target = null; |
| if (modeChars[0] == 'C') { |
| target = RoundingMode.CEILING; |
| targetChars = chCEILING; |
| } else if (modeChars[0] == 'D') { |
| target = RoundingMode.DOWN; |
| targetChars = chDOWN; |
| } else if (modeChars[0] == 'F') { |
| target = RoundingMode.FLOOR; |
| targetChars = chFLOOR; |
| } else if (modeChars[0] == 'H') { |
| if (len > 6) { |
| if (modeChars[5] == 'D') { |
| target = RoundingMode.HALF_DOWN; |
| targetChars = chHALF_DOWN; |
| } else if (modeChars[5] == 'E') { |
| target = RoundingMode.HALF_EVEN; |
| targetChars = chHALF_EVEN; |
| } else if (modeChars[5] == 'U') { |
| target = RoundingMode.HALF_UP; |
| targetChars = chHALF_UP; |
| } |
| } |
| } else if (modeChars[0] == 'U') { |
| if (modeChars[1] == 'P') { |
| target = RoundingMode.UP; |
| targetChars = chUP; |
| } else if (modeChars[1] == 'N') { |
| target = RoundingMode.UNNECESSARY; |
| targetChars = chUNNECESSARY; |
| } |
| } |
| |
| if (target != null && len == targetChars.length) { |
| int i; |
| for (i = 1; i < len && modeChars[i] == targetChars[i]; i++) { |
| } |
| if (i == len) { |
| return target; |
| } |
| } |
| |
| throw new IllegalArgumentException(); |
| } |
| |
| /** |
| * Set the old constant. |
| * @param rm unused |
| */ |
| RoundingMode(int rm) { |
| // Note that we do not need the old-style rounding mode, so we ignore it. |
| } |
| } |
