Esempio n. 1
0
 /**
  * Returns a BigDecimal from a ValueLink formatted amount String
  *
  * @param amount The ValueLink formatted amount String
  * @return BigDecimal object
  */
 public BigDecimal getAmount(String amount) {
   if (amount == null) {
     return BigDecimal.ZERO;
   }
   BigDecimal amountBd = new BigDecimal(amount);
   return amountBd.movePointLeft(2);
 }
 public static BigDecimal movePointLeft(BigDecimal decimal) {
   if (decimal != null) {
     return decimal.movePointLeft(2);
   } else {
     return BigDecimalUtils.ZERO;
   }
 }
  /** update the balance of the account as displayed at the top of the screen. */
  public void updateBalance() {
    accountInfo.moveToFirst();

    String amountNoDecimal =
        accountInfo.getString(accountInfo.getColumnIndex(AccountData.ACCOUNT_BALANCE));
    BigDecimal accountBalance = new BigDecimal(amountNoDecimal);
    accountBalance = accountBalance.movePointLeft(2);

    mAccountBalance.setTextColor(Color.WHITE);
    mHeader.setBackgroundColor(AccountData.GREEN);
    if (accountBalance.signum() < 0) {
      mHeader.setBackgroundColor(AccountData.RED);
    }

    mAccountName.setText(
        accountInfo.getString(accountInfo.getColumnIndex(AccountData.ACCOUNT_NAME)));
    mAccountBalance.setText(accountBalance.toPlainString());
  }
Esempio n. 4
0
  static void unmarshalIn(
      org.omg.CORBA.portable.InputStream s, TypeCode typeCode, long[] la, Object[] oa) {
    int type = typeCode.kind().value();
    long l = 0;
    Object o = oa[0];

    switch (type) {
      case TCKind._tk_null:
      case TCKind._tk_void:
      case TCKind._tk_native:
        // Nothing to read
        break;

      case TCKind._tk_short:
        l = s.read_short() & 0xFFFFL;
        break;

      case TCKind._tk_ushort:
        l = s.read_ushort() & 0xFFFFL;
        break;

      case TCKind._tk_enum:
      case TCKind._tk_long:
        l = s.read_long() & 0xFFFFFFFFL;
        break;

      case TCKind._tk_ulong:
        l = s.read_ulong() & 0xFFFFFFFFL;
        break;

      case TCKind._tk_float:
        l = Float.floatToIntBits(s.read_float()) & 0xFFFFFFFFL;
        break;

      case TCKind._tk_double:
        l = Double.doubleToLongBits(s.read_double());
        break;

      case TCKind._tk_char:
        l = s.read_char() & 0xFFFFL;
        break;

      case TCKind._tk_octet:
        l = s.read_octet() & 0xFFL;
        break;

      case TCKind._tk_boolean:
        if (s.read_boolean()) l = 1;
        else l = 0;
        break;

      case TCKind._tk_any:
        o = s.read_any();
        break;

      case TCKind._tk_TypeCode:
        o = s.read_TypeCode();
        break;

      case TCKind._tk_Principal:
        o = s.read_Principal();
        break;

      case TCKind._tk_objref:
        if (o instanceof Streamable) ((Streamable) o)._read(s);
        else o = s.read_Object();
        break;

      case TCKind._tk_longlong:
        l = s.read_longlong();
        break;

      case TCKind._tk_ulonglong:
        l = s.read_ulonglong();
        break;

      case TCKind._tk_wchar:
        l = s.read_wchar() & 0xFFFFL;
        break;

      case TCKind._tk_string:
        o = s.read_string();
        break;

      case TCKind._tk_wstring:
        o = s.read_wstring();
        break;

      case TCKind._tk_value:
      case TCKind._tk_value_box:
        o = ((org.omg.CORBA_2_3.portable.InputStream) s).read_value();
        break;

      case TCKind._tk_fixed:
        try {
          // _REVISIT_ As soon as the java-rtf adds digits and scale parameters to
          // InputStream, this check will be unnecessary
          if (s instanceof CDRInputStream) {
            o = ((CDRInputStream) s).read_fixed(typeCode.fixed_digits(), typeCode.fixed_scale());
          } else {
            BigDecimal bigDecimal = s.read_fixed();
            o = bigDecimal.movePointLeft((int) typeCode.fixed_scale());
          }
        } catch (BadKind badKind) { // impossible
        }
        break;

      case TCKind._tk_struct:
      case TCKind._tk_union:
      case TCKind._tk_sequence:
      case TCKind._tk_array:
      case TCKind._tk_alias:
      case TCKind._tk_except:
        ((Streamable) o)._read(s);
        break;

      case TCKind._tk_abstract_interface:
        o = ((org.omg.CORBA_2_3.portable.InputStream) s).read_abstract_interface();
        break;

      case TCKind._tk_longdouble:
        // Unspecified for Java
      default:
        ORBUtilSystemException wrapper =
            ORBUtilSystemException.get(
                (com.sun.corba.se.spi.orb.ORB) s.orb(), CORBALogDomains.RPC_PRESENTATION);
        throw wrapper.typecodeNotSupported();
    }

    oa[0] = o;
    la[0] = l;
  }
Esempio n. 5
0
  @Override
  public void parse(
      CharSequence text,
      ParseLog status,
      AttributeQuery attributes,
      Map<ChronoElement<?>, Object> parsedResult,
      FormatStep step) {

    Leniency leniency = step.getAttribute(Attributes.LENIENCY, attributes, Leniency.SMART);

    int effectiveMin = 0;
    int effectiveMax = 9;

    if (!leniency.isLax() || this.fixedWidth) {
      effectiveMin = this.minDigits;
      effectiveMax = this.maxDigits;
    }

    int len = text.length();

    if (status.getPosition() >= len) {
      if (effectiveMin > 0) {
        status.setError(
            status.getPosition(), "Expected fraction digits not found for: " + this.element.name());
      }
      return;
    }

    if (this.hasDecimalSeparator()) {
      this.decimalSeparator.parse(text, status, attributes, null, step);

      if (status.isError()) {
        if (effectiveMin == 0) {
          status.clearError();
        }
        return;
      }
    }

    int current = status.getPosition();
    int minEndPos = current + effectiveMin;
    int maxEndPos = Math.min(current + effectiveMax, len);

    if (minEndPos > len) {
      status.setError(status.getPosition(), "Expected at least " + effectiveMin + " digits.");
      return;
    }

    char zeroDigit =
        step.getAttribute(Attributes.ZERO_DIGIT, attributes, Character.valueOf('0')).charValue();

    long total = 0;

    while (current < maxEndPos) {
      int digit = text.charAt(current) - zeroDigit;

      if ((digit >= 0) && (digit <= 9)) {
        total = total * 10 + digit;
        current++;
      } else if (current < minEndPos) {
        status.setError(status.getPosition(), "Expected at least " + effectiveMin + " digits.");
        return;
      } else {
        break;
      }
    }

    BigDecimal fraction = new BigDecimal(total);
    fraction = fraction.movePointLeft(current - status.getPosition());

    if (this.element.name().equals("NANO_OF_SECOND")) {
      Integer min = Integer.valueOf(0);
      Integer max = MRD_MINUS_1;
      Integer num = this.getRealValue(fraction, min, max);
      parsedResult.put(this.element, num);
    } else {
      // hier nur prototypischer Wert, später fraktionalen Wert bestimmen
      parsedResult.put(FractionalElement.FRACTION, fraction);
      parsedResult.put(this.element, this.element.getDefaultMinimum());
    }

    status.setPosition(current);
  }
Esempio n. 6
0
 @Override
 public Object parseObject(String source, ParsePosition pos) {
   int ix = pos.getIndex();
   int len = source.length();
   int sign = 1;
   int mod = 0;
   int scale = 0;
   int exp = 0;
   boolean match = false;
   char c = 0;
   BigDecimal n = BigDecimal.ZERO;
   if (ix < len) {
     c = source.charAt(ix);
     if (c == '+' || c == '-') {
       sign = c == '-' ? -1 : 1;
       ix++;
     }
   }
   ix--;
   while (++ix < len) {
     c = source.charAt(ix);
     // System.out.println("c="+c+"; n="+n);
     if (Character.isDigit(c)) {
       int d = Character.digit(c, 10);
       n = n.multiply(BigDecimal.TEN);
       n = n.add(BigDecimal.valueOf(d));
       scale += mod;
       match = true;
       // System.out.println("->"+d+"; n="+n);
     } else if (c == '.' && mod == 0) {
       mod = 1;
     } else {
       if (!match) {
         pos.setErrorIndex(ix);
         return null;
       }
       break;
     }
   }
   if (match && ix < len && (c == 'E' || c == 'e')) {
     match = false;
     if (++ix < len) {
       int esign = 1;
       c = source.charAt(ix);
       if (c == '+' || c == '-') {
         esign = c == '-' ? -1 : 1;
       } else ix--;
       while (++ix < len) {
         c = source.charAt(ix);
         if (Character.isDigit(c)) {
           int d = Character.digit(c, 10);
           exp = exp * 10 + d;
           match = true;
         }
       }
       exp *= esign;
     }
   }
   if (!match) {
     pos.setErrorIndex(ix);
     return null;
   }
   scale -= exp;
   n = n.movePointLeft(scale);
   if (sign < 0) n = n.negate();
   pos.setIndex(ix);
   return n;
 }
Esempio n. 7
0
  private String formatDecimal(String start, SchemaType sType) {
    BigDecimal result = new BigDecimal(start);
    XmlDecimal xmlD;
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_INCLUSIVE);
    BigDecimal min = xmlD != null ? xmlD.getBigDecimalValue() : null;
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_INCLUSIVE);
    BigDecimal max = xmlD != null ? xmlD.getBigDecimalValue() : null;
    boolean minInclusive = true, maxInclusive = true;
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MIN_EXCLUSIVE);
    if (xmlD != null) {
      BigDecimal minExcl = xmlD.getBigDecimalValue();
      if (min == null || min.compareTo(minExcl) < 0) {
        min = minExcl;
        minInclusive = false;
      }
    }
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_MAX_EXCLUSIVE);
    if (xmlD != null) {
      BigDecimal maxExcl = xmlD.getBigDecimalValue();
      if (max == null || max.compareTo(maxExcl) > 0) {
        max = maxExcl;
        maxInclusive = false;
      }
    }
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_TOTAL_DIGITS);
    int totalDigits = -1;
    if (xmlD != null) {
      totalDigits = xmlD.getBigDecimalValue().intValue();

      StringBuffer sb = new StringBuffer(totalDigits);
      for (int i = 0; i < totalDigits; i++) sb.append('9');
      BigDecimal digitsLimit = new BigDecimal(sb.toString());
      if (max != null && max.compareTo(digitsLimit) > 0) {
        max = digitsLimit;
        maxInclusive = true;
      }
      digitsLimit = digitsLimit.negate();
      if (min != null && min.compareTo(digitsLimit) < 0) {
        min = digitsLimit;
        minInclusive = true;
      }
    }

    int sigMin = min == null ? 1 : result.compareTo(min);
    int sigMax = max == null ? -1 : result.compareTo(max);
    boolean minOk = sigMin > 0 || sigMin == 0 && minInclusive;
    boolean maxOk = sigMax < 0 || sigMax == 0 && maxInclusive;

    // Compute the minimum increment
    xmlD = (XmlDecimal) sType.getFacet(SchemaType.FACET_FRACTION_DIGITS);
    int fractionDigits = -1;
    BigDecimal increment;
    if (xmlD == null) increment = new BigDecimal(1);
    else {
      fractionDigits = xmlD.getBigDecimalValue().intValue();
      if (fractionDigits > 0) {
        StringBuffer sb = new StringBuffer("0.");
        for (int i = 1; i < fractionDigits; i++) sb.append('0');
        sb.append('1');
        increment = new BigDecimal(sb.toString());
      } else increment = new BigDecimal(1);
    }

    if (minOk && maxOk) {
      // OK
    } else if (minOk && !maxOk) {
      // TOO BIG
      if (maxInclusive) result = max;
      else result = max.subtract(increment);
    } else if (!minOk && maxOk) {
      // TOO SMALL
      if (minInclusive) result = min;
      else result = min.add(increment);
    } else {
      // MIN > MAX!!
    }

    // We have the number
    // Adjust the scale according to the totalDigits and fractionDigits
    int digits = 0;
    BigDecimal ONE = new BigDecimal(BigInteger.ONE);
    for (BigDecimal n = result; n.abs().compareTo(ONE) >= 0; digits++) n = n.movePointLeft(1);

    if (fractionDigits > 0)
      if (totalDigits >= 0) result.setScale(Math.max(fractionDigits, totalDigits - digits));
      else result.setScale(fractionDigits);
    else if (fractionDigits == 0) result.setScale(0);

    return result.toString();
  }
Esempio n. 8
0
 /**
  * This probably should be Currency responsibility. Even then, it may need to be customized for
  * specialty apps because there are other cases, where the smallest increment is not the smallest
  * unit.
  */
 Money minimumIncrement() {
   BigDecimal one = new BigDecimal(1);
   BigDecimal increment = one.movePointLeft(currency.getDefaultFractionDigits());
   return Money.valueOf(increment, currency);
 }
Esempio n. 9
0
  public static BigDecimal sqrt(BigDecimal squarD, int scalar) {
    // Static constants - perhaps initialize in class Vladimir!
    BigDecimal TWO = new BigDecimal(2);
    double SQRT_10 = 3.162277660168379332;
    MathContext rootMC = new MathContext(scalar);

    // General number and precision checking
    int sign = squarD.signum();
    if (sign == -1) throw new ArithmeticException("\nSquare root of a negative number: " + squarD);
    else if (sign == 0) return squarD.round(rootMC);

    int prec = rootMC.getPrecision(); // the requested precision
    if (prec == 0)
      throw new IllegalArgumentException("\nMost roots won't have infinite precision = 0");

    // Initial precision is that of double numbers 2^63/2 ~ 4E18
    int BITS = 62; // 63-1 an even number of number bits
    int nInit = 16; // precision seems 16 to 18 digits
    MathContext nMC = new MathContext(18, RoundingMode.HALF_UP);

    // Iteration variables, for the square root x and the reciprocal v
    BigDecimal x = null, e = null; // initial x: x0 ~ sqrt()
    BigDecimal v = null, g = null; // initial v: v0 = 1/(2*x)

    // Estimate the square root with the foremost 62 bits of squarD
    BigInteger bi = squarD.unscaledValue(); // bi and scale are a tandem
    int biLen = bi.bitLength();
    int shift = Math.max(0, biLen - BITS + (biLen % 2 == 0 ? 0 : 1)); // even
    // shift..
    bi = bi.shiftRight(shift); // ..floors to 62 or 63 bit BigInteger

    double root = Math.sqrt(bi.doubleValue());
    BigDecimal halfBack = new BigDecimal(BigInteger.ONE.shiftLeft(shift / 2));

    int scale = squarD.scale();
    if (scale % 2 == 1) // add half scales of the root to odds..
    root *= SQRT_10; // 5 -> 2, -5 -> -3 need half a scale more..
    scale = (int) Math.floor(scale / 2.); // ..where 100 -> 10 shifts the
    // scale

    // Initial x - use double root - multiply by halfBack to unshift - set
    // new scale
    x = new BigDecimal(root, nMC);
    x = x.multiply(halfBack, nMC); // x0 ~ sqrt()
    if (scale != 0) x = x.movePointLeft(scale);

    if (prec < nInit) // for prec 15 root x0 must surely be OK
    return x.round(rootMC); // return small prec roots without
    // iterations

    // Initial v - the reciprocal
    v = BigDecimal.ONE.divide(TWO.multiply(x), nMC); // v0 = 1/(2*x)

    // Collect iteration precisions beforehand
    ArrayList<Integer> nPrecs = new ArrayList<Integer>();

    assert nInit > 3 : "Never ending loop!"; // assume nInit = 16 <= prec

    // Let m be the exact digits precision in an earlier! loop
    for (int m = prec + 1; m > nInit; m = m / 2 + (m > 100 ? 1 : 2)) nPrecs.add(m);

    // The loop of "Square Root by Coupled Newton Iteration" for simpletons
    for (int i = nPrecs.size() - 1; i > -1; i--) {
      // Increase precision - next iteration supplies n exact digits
      nMC =
          new MathContext(
              nPrecs.get(i), (i % 2 == 1) ? RoundingMode.HALF_UP : RoundingMode.HALF_DOWN);

      // Next x // e = d - x^2
      e = squarD.subtract(x.multiply(x, nMC), nMC);
      if (i != 0) x = x.add(e.multiply(v, nMC)); // x += e*v ~ sqrt()
      else {
        x = x.add(e.multiply(v, rootMC), rootMC); // root x is ready!
        break;
      }

      // Next v // g = 1 - 2*x*v
      g = BigDecimal.ONE.subtract(TWO.multiply(x).multiply(v, nMC));

      v = v.add(g.multiply(v, nMC)); // v += g*v ~ 1/2/sqrt()
    }

    return x; // return sqrt(squarD) with precision of rootMC
  }