devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

js BigDecimal

作者：不正经 | 2024-04-14 20:02:11

赞

踩

js bigdecimal

学过java的同学应该都知道，java中有一个BigDecimal 是专门用来算金额的，今天这里的BigDecimal是从java翻译成js的。

先看用法：

加法(四舍五入保留两位小数)：

  1. var a = new BigDecimal("2.555555").add(new BigDecimal("5.222222")).setScale(2, MathContext.ROUND_HALF_UP).toString();
  2. console.log(a);

减法： 

new BigDecimal("2.40").subtract(new BigDecimal("2"))

乘法：

new BigDecimal("2.40").multiply(new BigDecimal("2"))

除法：

new BigDecimal("2.40").divide(new BigDecimal("2"), def)

下面来看看源代码： 

  1. /** @license Copyright (c) 2012 Daniel Trebbien and other contributors
  2. Portions Copyright (c) 2003 STZ-IDA and PTV AG, Karlsruhe, Germany
  3. Portions Copyright (c) 1995-2001 International Business Machines Corporation and others
  5. All rights reserved.
  7. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, provided that the above copyright notice(s) and this permission notice appear in all copies of the Software and that both the above copyright notice(s) and this permission notice appear in supporting documentation.
  9. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  11. Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization of the copyright holder.
  12. */
  13. (function () {
  14.  
  15. var MathContext = (function () {
  16. /* Generated from 'MathContext.nrx' 8 Sep 2000 11:07:48 [v2.00] */
  17. /* Options: Binary Comments Crossref Format Java Logo Strictargs Strictcase Trace2 Verbose3 */
  18. //--package com.ibm.icu.math;
  19.  
  20. /* ------------------------------------------------------------------ */
  21. /* MathContext -- Math context settings                               */
  22. /* ------------------------------------------------------------------ */
  23. /* Copyright IBM Corporation, 1997, 2000.  All Rights Reserved.       */
  24. /*                                                                    */
  25. /*   The MathContext object encapsulates the settings used by the     */
  26. /*   BigDecimal class; it could also be used by other arithmetics.    */
  27. /* ------------------------------------------------------------------ */
  28. /* Notes:                                                             */
  29. /*                                                                    */
  30. /* 1. The properties are checked for validity on construction, so     */
  31. /*    the BigDecimal class may assume that they are correct.          */
  32. /* ------------------------------------------------------------------ */
  33. /* Author:    Mike Cowlishaw                                          */
  34. /* 1997.09.03 Initial version (edited from netrexx.lang.RexxSet)      */
  35. /* 1997.09.12 Add lostDigits property                                 */
  36. /* 1998.05.02 Make the class immutable and final; drop set methods    */
  37. /* 1998.06.05 Add Round (rounding modes) property                     */
  38. /* 1998.06.25 Rename from DecimalContext; allow digits=0              */
  39. /* 1998.10.12 change to com.ibm.icu.math package                          */
  40. /* 1999.02.06 add javadoc comments                                    */
  41. /* 1999.03.05 simplify; changes from discussion with J. Bloch         */
  42. /* 1999.03.13 1.00 release to IBM Centre for Java Technology          */
  43. /* 1999.07.10 1.04 flag serialization unused                          */
  44. /* 2000.01.01 1.06 copyright update                                   */
  45. /* ------------------------------------------------------------------ */
  46.  
  47.  
  48. /* JavaScript conversion (c) 2003 STZ-IDA and PTV AG, Karlsruhe, Germany */
  49.  
  50.  
  51.  
  52. /**
  53.  * The <code>MathContext</code> immutable class encapsulates the
  54.  * settings understood by the operator methods of the {@link BigDecimal}
  55.  * class (and potentially other classes).  Operator methods are those
  56.  * that effect an operation on a number or a pair of numbers.
  57.  * <p>
  58.  * The settings, which are not base-dependent, comprise:
  59.  * <ol>
  60.  * <li><code>digits</code>:
  61.  * the number of digits (precision) to be used for an operation
  62.  * <li><code>form</code>:
  63.  * the form of any exponent that results from the operation
  64.  * <li><code>lostDigits</code>:
  65.  * whether checking for lost digits is enabled
  66.  * <li><code>roundingMode</code>:
  67.  * the algorithm to be used for rounding.
  68.  * </ol>
  69.  * <p>
  70.  * When provided, a <code>MathContext</code> object supplies the
  71.  * settings for an operation directly.
  72.  * <p>
  73.  * When <code>MathContext.DEFAULT</code> is provided for a
  74.  * <code>MathContext</code> parameter then the default settings are used
  75.  * (<code>9, SCIENTIFIC, false, ROUND_HALF_UP</code>).
  76.  * <p>
  77.  * In the <code>BigDecimal</code> class, all methods which accept a
  78.  * <code>MathContext</code> object defaults) also have a version of the
  79.  * method which does not accept a MathContext parameter.  These versions
  80.  * carry out unlimited precision fixed point arithmetic (as though the
  81.  * settings were (<code>0, PLAIN, false, ROUND_HALF_UP</code>).
  82.  * <p>
  83.  * The instance variables are shared with default access (so they are
  84.  * directly accessible to the <code>BigDecimal</code> class), but must
  85.  * never be changed.
  86.  * <p>
  87.  * The rounding mode constants have the same names and values as the
  88.  * constants of the same name in <code>java.math.BigDecimal</code>, to
  89.  * maintain compatibility with earlier versions of
  90.  * <code>BigDecimal</code>.
  91.  *
  92.  * @see     BigDecimal
  93.  * @author  Mike Cowlishaw
  94.  * @stable ICU 2.0
  95.  */
  96.  
  97. //--public final class MathContext implements java.io.Serializable{
  98.  //--private static final java.lang.String $0="MathContext.nrx";
  99.  
  100.  //-- methods
  101.  MathContext.prototype.getDigits = getDigits;
  102.  MathContext.prototype.getForm = getForm;
  103.  MathContext.prototype.getLostDigits = getLostDigits;
  104.  MathContext.prototype.getRoundingMode = getRoundingMode;
  105.  MathContext.prototype.toString = toString;
  106.  MathContext.prototype.isValidRound = isValidRound;
  107.  
  108.  
  109.  /* ----- Properties ----- */
  110.  /* properties public constant */
  111.  /**
  112.   * Plain (fixed point) notation, without any exponent.
  113.   * Used as a setting to control the form of the result of a
  114.   * <code>BigDecimal</code> operation.
  115.   * A zero result in plain form may have a decimal part of one or
  116.   * more zeros.
  117.   *
  118.   * @see #ENGINEERING
  119.   * @see #SCIENTIFIC
  120.   * @stable ICU 2.0
  121.   */
  122.  //--public static final int PLAIN=0; // [no exponent]
  123.  MathContext.PLAIN = MathContext.prototype.PLAIN = 0; // [no exponent]
  124.  
  125.  /**
  126.   * Standard floating point notation (with scientific exponential
  127.   * format, where there is one digit before any decimal point).
  128.   * Used as a setting to control the form of the result of a
  129.   * <code>BigDecimal</code> operation.
  130.   * A zero result in plain form may have a decimal part of one or
  131.   * more zeros.
  132.   *
  133.   * @see #ENGINEERING
  134.   * @see #PLAIN
  135.   * @stable ICU 2.0
  136.   */
  137.  //--public static final int SCIENTIFIC=1; // 1 digit before .
  138.  MathContext.SCIENTIFIC = MathContext.prototype.SCIENTIFIC = 1; // 1 digit before .
  139.  
  140.  /**
  141.   * Standard floating point notation (with engineering exponential
  142.   * format, where the power of ten is a multiple of 3).
  143.   * Used as a setting to control the form of the result of a
  144.   * <code>BigDecimal</code> operation.
  145.   * A zero result in plain form may have a decimal part of one or
  146.   * more zeros.
  147.   *
  148.   * @see #PLAIN
  149.   * @see #SCIENTIFIC
  150.   * @stable ICU 2.0
  151.   */
  152.  //--public static final int ENGINEERING=2; // 1-3 digits before .
  153.  MathContext.ENGINEERING = MathContext.prototype.ENGINEERING = 2; // 1-3 digits before .
  154.  
  155.  // The rounding modes match the original BigDecimal class values
  156.  /**
  157.   * Rounding mode to round to a more positive number.
  158.   * Used as a setting to control the rounding mode used during a
  159.   * <code>BigDecimal</code> operation.
  160.   * <p>
  161.   * If any of the discarded digits are non-zero then the result
  162.   * should be rounded towards the next more positive digit.
  163.   * @stable ICU 2.0
  164.   */
  165.  //--public static final int ROUND_CEILING=2;
  166.  MathContext.ROUND_CEILING = MathContext.prototype.ROUND_CEILING = 2;
  167.  
  168.  /**
  169.   * Rounding mode to round towards zero.
  170.   * Used as a setting to control the rounding mode used during a
  171.   * <code>BigDecimal</code> operation.
  172.   * <p>
  173.   * All discarded digits are ignored (truncated).  The result is
  174.   * neither incremented nor decremented.
  175.   * @stable ICU 2.0
  176.   */
  177.  //--public static final int ROUND_DOWN=1;
  178.  MathContext.ROUND_DOWN = MathContext.prototype.ROUND_DOWN = 1;
  179.  
  180.  /**
  181.   * Rounding mode to round to a more negative number.
  182.   * Used as a setting to control the rounding mode used during a
  183.   * <code>BigDecimal</code> operation.
  184.   * <p>
  185.   * If any of the discarded digits are non-zero then the result
  186.   * should be rounded towards the next more negative digit.
  187.   * @stable ICU 2.0
  188.   */
  189.  //--public static final int ROUND_FLOOR=3;
  190.  MathContext.ROUND_FLOOR = MathContext.prototype.ROUND_FLOOR = 3;
  191.  
  192.  /**
  193.   * Rounding mode to round to nearest neighbor, where an equidistant
  194.   * value is rounded down.
  195.   * Used as a setting to control the rounding mode used during a
  196.   * <code>BigDecimal</code> operation.
  197.   * <p>
  198.   * If the discarded digits represent greater than half (0.5 times)
  199.   * the value of a one in the next position then the result should be
  200.   * rounded up (away from zero).  Otherwise the discarded digits are
  201.   * ignored.
  202.   * @stable ICU 2.0
  203.   */
  204.  //--public static final int ROUND_HALF_DOWN=5;
  205.  MathContext.ROUND_HALF_DOWN = MathContext.prototype.ROUND_HALF_DOWN = 5;
  206.  
  207.  /**
  208.   * Rounding mode to round to nearest neighbor, where an equidistant
  209.   * value is rounded to the nearest even neighbor.
  210.   * Used as a setting to control the rounding mode used during a
  211.   * <code>BigDecimal</code> operation.
  212.   * <p>
  213.   * If the discarded digits represent greater than half (0.5 times)
  214.   * the value of a one in the next position then the result should be
  215.   * rounded up (away from zero).  If they represent less than half,
  216.   * then the result should be rounded down.
  217.   * <p>
  218.   * Otherwise (they represent exactly half) the result is rounded
  219.   * down if its rightmost digit is even, or rounded up if its
  220.   * rightmost digit is odd (to make an even digit).
  221.   * @stable ICU 2.0
  222.   */
  223.  //--public static final int ROUND_HALF_EVEN=6;
  224.  MathContext.ROUND_HALF_EVEN = MathContext.prototype.ROUND_HALF_EVEN = 6;
  225.  
  226.  /**
  227.   * Rounding mode to round to nearest neighbor, where an equidistant
  228.   * value is rounded up.
  229.   * Used as a setting to control the rounding mode used during a
  230.   * <code>BigDecimal</code> operation.
  231.   * <p>
  232.   * If the discarded digits represent greater than or equal to half
  233.   * (0.5 times) the value of a one in the next position then the result
  234.   * should be rounded up (away from zero).  Otherwise the discarded
  235.   * digits are ignored.
  236.   * @stable ICU 2.0
  237.   */
  238.  //--public static final int ROUND_HALF_UP=4;
  239.  MathContext.ROUND_HALF_UP = MathContext.prototype.ROUND_HALF_UP = 4;
  240.  
  241.  /**
  242.   * Rounding mode to assert that no rounding is necessary.
  243.   * Used as a setting to control the rounding mode used during a
  244.   * <code>BigDecimal</code> operation.
  245.   * <p>
  246.   * Rounding (potential loss of information) is not permitted.
  247.   * If any of the discarded digits are non-zero then an
  248.   * <code>ArithmeticException</code> should be thrown.
  249.   * @stable ICU 2.0
  250.   */
  251.  //--public static final int ROUND_UNNECESSARY=7;
  252.  MathContext.ROUND_UNNECESSARY = MathContext.prototype.ROUND_UNNECESSARY = 7;
  253.  
  254.  /**
  255.   * Rounding mode to round away from zero.
  256.   * Used as a setting to control the rounding mode used during a
  257.   * <code>BigDecimal</code> operation.
  258.   * <p>
  259.   * If any of the discarded digits are non-zero then the result will
  260.   * be rounded up (away from zero).
  261.   * @stable ICU 2.0
  262.   */
  263.  //--public static final int ROUND_UP=0;
  264.  MathContext.ROUND_UP = MathContext.prototype.ROUND_UP = 0;
  265.  
  266.  
  267.  /* properties shared */
  268.  /**
  269.   * The number of digits (precision) to be used for an operation.
  270.   * A value of 0 indicates that unlimited precision (as many digits
  271.   * as are required) will be used.
  272.   * <p>
  273.   * The {@link BigDecimal} operator methods use this value to
  274.   * determine the precision of results.
  275.   * Note that leading zeros (in the integer part of a number) are
  276.   * never significant.
  277.   * <p>
  278.   * <code>digits</code> will always be non-negative.
  279.   *
  280.   * @serial
  281.   */
  282.  //--int digits;
  283.  
  284.  /**
  285.   * The form of results from an operation.
  286.   * <p>
  287.   * The {@link BigDecimal} operator methods use this value to
  288.   * determine the form of results, in particular whether and how
  289.   * exponential notation should be used.
  290.   *
  291.   * @see #ENGINEERING
  292.   * @see #PLAIN
  293.   * @see #SCIENTIFIC
  294.   * @serial
  295.   */
  296.  //--int form; // values for this must fit in a byte
  297.  
  298.  /**
  299.   * Controls whether lost digits checking is enabled for an
  300.   * operation.
  301.   * Set to <code>true</code> to enable checking, or
  302.   * to <code>false</code> to disable checking.
  303.   * <p>
  304.   * When enabled, the {@link BigDecimal} operator methods check
  305.   * the precision of their operand or operands, and throw an
  306.   * <code>ArithmeticException</code> if an operand is more precise
  307.   * than the digits setting (that is, digits would be lost).
  308.   * When disabled, operands are rounded to the specified digits.
  309.   *
  310.   * @serial
  311.   */
  312.  //--boolean lostDigits;
  313.  
  314.  /**
  315.   * The rounding algorithm to be used for an operation.
  316.   * <p>
  317.   * The {@link BigDecimal} operator methods use this value to
  318.   * determine the algorithm to be used when non-zero digits have to
  319.   * be discarded in order to reduce the precision of a result.
  320.   * The value must be one of the public constants whose name starts
  321.   * with <code>ROUND_</code>.
  322.   *
  323.   * @see #ROUND_CEILING
  324.   * @see #ROUND_DOWN
  325.   * @see #ROUND_FLOOR
  326.   * @see #ROUND_HALF_DOWN
  327.   * @see #ROUND_HALF_EVEN
  328.   * @see #ROUND_HALF_UP
  329.   * @see #ROUND_UNNECESSARY
  330.   * @see #ROUND_UP
  331.   * @serial
  332.   */
  333.  //--int roundingMode;
  334.  
  335.  /* properties private constant */
  336.  // default settings
  337.  //--private static final int DEFAULT_FORM=SCIENTIFIC;
  338.  //--private static final int DEFAULT_DIGITS=9;
  339.  //--private static final boolean DEFAULT_LOSTDIGITS=false;
  340.  //--private static final int DEFAULT_ROUNDINGMODE=ROUND_HALF_UP;
  341.  MathContext.prototype.DEFAULT_FORM=MathContext.prototype.SCIENTIFIC;
  342.  MathContext.prototype.DEFAULT_DIGITS=9;
  343.  MathContext.prototype.DEFAULT_LOSTDIGITS=false;
  344.  MathContext.prototype.DEFAULT_ROUNDINGMODE=MathContext.prototype.ROUND_HALF_UP;
  345.  
  346.  /* properties private constant */
  347.  
  348.  //--private static final int MIN_DIGITS=0; // smallest value for DIGITS.
  349.  //--private static final int MAX_DIGITS=999999999; // largest value for DIGITS.  If increased,
  350.  MathContext.prototype.MIN_DIGITS=0; // smallest value for DIGITS.
  351.  MathContext.prototype.MAX_DIGITS=999999999; // largest value for DIGITS.  If increased,
  352.  // the BigDecimal class may need update.
  353.  // list of valid rounding mode values, most common two first
  354.  //--private static final int ROUNDS[]=new int[]{ROUND_HALF_UP,ROUND_UNNECESSARY,ROUND_CEILING,ROUND_DOWN,ROUND_FLOOR,ROUND_HALF_DOWN,ROUND_HALF_EVEN,ROUND_UP};
  355.  MathContext.prototype.ROUNDS=new Array(MathContext.prototype.ROUND_HALF_UP,MathContext.prototype.ROUND_UNNECESSARY,MathContext.prototype.ROUND_CEILING,MathContext.prototype.ROUND_DOWN,MathContext.prototype.ROUND_FLOOR,MathContext.prototype.ROUND_HALF_DOWN,MathContext.prototype.ROUND_HALF_EVEN,MathContext.prototype.ROUND_UP);
  356.  
  357.  
  358.  //--private static final java.lang.String ROUNDWORDS[]=new java.lang.String[]{"ROUND_HALF_UP","ROUND_UNNECESSARY","ROUND_CEILING","ROUND_DOWN","ROUND_FLOOR","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_UP"}; // matching names of the ROUNDS values
  359.  MathContext.prototype.ROUNDWORDS=new Array("ROUND_HALF_UP","ROUND_UNNECESSARY","ROUND_CEILING","ROUND_DOWN","ROUND_FLOOR","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_UP"); // matching names of the ROUNDS values
  360.  
  361.  
  362.  
  363.  
  364.  /* properties private constant unused */
  365.  
  366.  // Serialization version
  367.  //--private static final long serialVersionUID=7163376998892515376L;
  368.  
  369.  /* properties public constant */
  370.  /**
  371.   * A <code>MathContext</code> object initialized to the default
  372.   * settings for general-purpose arithmetic.  That is,
  373.   * <code>digits=9 form=SCIENTIFIC lostDigits=false
  374.   * roundingMode=ROUND_HALF_UP</code>.
  375.   *
  376.   * @see #SCIENTIFIC
  377.   * @see #ROUND_HALF_UP
  378.   * @stable ICU 2.0
  379.   */
  380.  //--public static final com.ibm.icu.math.MathContext DEFAULT=new com.ibm.icu.math.MathContext(DEFAULT_DIGITS,DEFAULT_FORM,DEFAULT_LOSTDIGITS,DEFAULT_ROUNDINGMODE);
  381.  MathContext.prototype.DEFAULT=new MathContext(MathContext.prototype.DEFAULT_DIGITS,MathContext.prototype.DEFAULT_FORM,MathContext.prototype.DEFAULT_LOSTDIGITS,MathContext.prototype.DEFAULT_ROUNDINGMODE);
  382.  
  383.  
  384.  
  385.  
  386.  /* ----- Constructors ----- */
  387.  
  388.  /**
  389.   * Constructs a new <code>MathContext</code> with a specified
  390.   * precision.
  391.   * The other settings are set to the default values
  392.   * (see {@link #DEFAULT}).
  393.   *
  394.   * An <code>IllegalArgumentException</code> is thrown if the
  395.   * <code>setdigits</code> parameter is out of range
  396.   * (<0 or >999999999).
  397.   *
  398.   * @param setdigits     The <code>int</code> digits setting
  399.   *                      for this <code>MathContext</code>.
  400.   * @throws IllegalArgumentException parameter out of range.
  401.   * @stable ICU 2.0
  402.   */
  403.  
  404.  //--public MathContext(int setdigits){
  405.  //-- this(setdigits,DEFAULT_FORM,DEFAULT_LOSTDIGITS,DEFAULT_ROUNDINGMODE);
  406.  //-- return;}
  407.  
  408.  
  409.  /**
  410.   * Constructs a new <code>MathContext</code> with a specified
  411.   * precision and form.
  412.   * The other settings are set to the default values
  413.   * (see {@link #DEFAULT}).
  414.   *
  415.   * An <code>IllegalArgumentException</code> is thrown if the
  416.   * <code>setdigits</code> parameter is out of range
  417.   * (<0 or >999999999), or if the value given for the
  418.   * <code>setform</code> parameter is not one of the appropriate
  419.   * constants.
  420.   *
  421.   * @param setdigits     The <code>int</code> digits setting
  422.   *                      for this <code>MathContext</code>.
  423.   * @param setform       The <code>int</code> form setting
  424.   *                      for this <code>MathContext</code>.
  425.   * @throws IllegalArgumentException parameter out of range.
  426.   * @stable ICU 2.0
  427.   */
  428.  
  429.  //--public MathContext(int setdigits,int setform){
  430.  //-- this(setdigits,setform,DEFAULT_LOSTDIGITS,DEFAULT_ROUNDINGMODE);
  431.  //-- return;}
  432.  
  433.  /**
  434.   * Constructs a new <code>MathContext</code> with a specified
  435.   * precision, form, and lostDigits setting.
  436.   * The roundingMode setting is set to its default value
  437.   * (see {@link #DEFAULT}).
  438.   *
  439.   * An <code>IllegalArgumentException</code> is thrown if the
  440.   * <code>setdigits</code> parameter is out of range
  441.   * (<0 or >999999999), or if the value given for the
  442.   * <code>setform</code> parameter is not one of the appropriate
  443.   * constants.
  444.   *
  445.   * @param setdigits     The <code>int</code> digits setting
  446.   *                      for this <code>MathContext</code>.
  447.   * @param setform       The <code>int</code> form setting
  448.   *                      for this <code>MathContext</code>.
  449.   * @param setlostdigits The <code>boolean</code> lostDigits
  450.   *                      setting for this <code>MathContext</code>.
  451.   * @throws IllegalArgumentException parameter out of range.
  452.   * @stable ICU 2.0
  453.   */
  454.  
  455.  //--public MathContext(int setdigits,int setform,boolean setlostdigits){
  456.  //-- this(setdigits,setform,setlostdigits,DEFAULT_ROUNDINGMODE);
  457.  //-- return;}
  458.  
  459.  /**
  460.   * Constructs a new <code>MathContext</code> with a specified
  461.   * precision, form, lostDigits, and roundingMode setting.
  462.   *
  463.   * An <code>IllegalArgumentException</code> is thrown if the
  464.   * <code>setdigits</code> parameter is out of range
  465.   * (<0 or >999999999), or if the value given for the
  466.   * <code>setform</code> or <code>setroundingmode</code> parameters is
  467.   * not one of the appropriate constants.
  468.   *
  469.   * @param setdigits       The <code>int</code> digits setting
  470.   *                        for this <code>MathContext</code>.
  471.   * @param setform         The <code>int</code> form setting
  472.   *                        for this <code>MathContext</code>.
  473.   * @param setlostdigits   The <code>boolean</code> lostDigits
  474.   *                        setting for this <code>MathContext</code>.
  475.   * @param setroundingmode The <code>int</code> roundingMode setting
  476.   *                        for this <code>MathContext</code>.
  477.   * @throws IllegalArgumentException parameter out of range.
  478.   * @stable ICU 2.0
  479.   */
  480.  
  481.  //--public MathContext(int setdigits,int setform,boolean setlostdigits,int setroundingmode){super();
  482.  function MathContext() {
  483.   //-- members
  484.   this.digits = 0;
  485.   this.form = 0; // values for this must fit in a byte
  486.   this.lostDigits = false;
  487.   this.roundingMode = 0;
  488.  
  489.   //-- overloaded ctor
  490.   var setform = this.DEFAULT_FORM;
  491.   var setlostdigits = this.DEFAULT_LOSTDIGITS;
  492.   var setroundingmode = this.DEFAULT_ROUNDINGMODE;
  493.   if (MathContext.arguments.length == 4)
  494.    {
  495.     setform = MathContext.arguments[1];
  496.     setlostdigits = MathContext.arguments[2];
  497.     setroundingmode = MathContext.arguments[3];
  498.    }
  499.   else if (MathContext.arguments.length == 3)
  500.    {
  501.     setform = MathContext.arguments[1];
  502.     setlostdigits = MathContext.arguments[2];
  503.    }
  504.   else if (MathContext.arguments.length == 2)
  505.    {
  506.     setform = MathContext.arguments[1];
  507.    }
  508.   else if (MathContext.arguments.length != 1)
  509.    {
  510.     throw "MathContext(): " + MathContext.arguments.length + " arguments given; expected 1 to 4";
  511.    }
  512.   var setdigits = MathContext.arguments[0];
  513.  
  514.  
  515.   // set values, after checking
  516.   if (setdigits!=this.DEFAULT_DIGITS)
  517.    {
  518.     if (setdigits<this.MIN_DIGITS)
  519.      throw "MathContext(): Digits too small: "+setdigits;
  520.     if (setdigits>this.MAX_DIGITS)
  521.      throw "MathContext(): Digits too large: "+setdigits;
  522.    }
  523.   {/*select*/
  524.   if (setform==this.SCIENTIFIC)
  525.    {} // [most common]
  526.   else if (setform==this.ENGINEERING)
  527.    {}
  528.   else if (setform==this.PLAIN)
  529.    {}
  530.   else{
  531.    throw "MathContext() Bad form value: "+setform;
  532.   }
  533.   }
  534.   if ((!(this.isValidRound(setroundingmode))))
  535.    throw "MathContext(): Bad roundingMode value: "+setroundingmode;
  536.   this.digits=setdigits;
  537.   this.form=setform;
  538.   this.lostDigits=setlostdigits; // [no bad value possible]
  539.   this.roundingMode=setroundingmode;
  540.   return;}
  541.  
  542.  /**
  543.   * Returns the digits setting.
  544.   * This value is always non-negative.
  545.   *
  546.   * @return an <code>int</code> which is the value of the digits
  547.   *         setting
  548.   * @stable ICU 2.0
  549.   */
  550.  
  551.  //--public int getDigits(){
  552.  function getDigits() {
  553.   return this.digits;
  554.   }
  555.  
  556.  /**
  557.   * Returns the form setting.
  558.   * This will be one of
  559.   * {@link #ENGINEERING},
  560.   * {@link #PLAIN}, or
  561.   * {@link #SCIENTIFIC}.
  562.   *
  563.   * @return an <code>int</code> which is the value of the form setting
  564.   * @stable ICU 2.0
  565.   */
  566.  
  567.  //--public int getForm(){
  568.  function getForm() {
  569.   return this.form;
  570.   }
  571.  
  572.  /**
  573.   * Returns the lostDigits setting.
  574.   * This will be either <code>true</code> (enabled) or
  575.   * <code>false</code> (disabled).
  576.   *
  577.   * @return a <code>boolean</code> which is the value of the lostDigits
  578.   *           setting
  579.   * @stable ICU 2.0
  580.   */
  581.  
  582.  //--public boolean getLostDigits(){
  583.  function getLostDigits() {
  584.   return this.lostDigits;
  585.   }
  586.  
  587.  /**
  588.   * Returns the roundingMode setting.
  589.   * This will be one of
  590.   * {@link  #ROUND_CEILING},
  591.   * {@link  #ROUND_DOWN},
  592.   * {@link  #ROUND_FLOOR},
  593.   * {@link  #ROUND_HALF_DOWN},
  594.   * {@link  #ROUND_HALF_EVEN},
  595.   * {@link  #ROUND_HALF_UP},
  596.   * {@link  #ROUND_UNNECESSARY}, or
  597.   * {@link  #ROUND_UP}.
  598.   *
  599.   * @return an <code>int</code> which is the value of the roundingMode
  600.   *         setting
  601.   * @stable ICU 2.0
  602.   */
  603.  
  604.  //--public int getRoundingMode(){
  605.  function getRoundingMode() {
  606.   return this.roundingMode;
  607.   }
  608.  
  609.  /** Returns the <code>MathContext</code> as a readable string.
  610.   * The <code>String</code> returned represents the settings of the
  611.   * <code>MathContext</code> object as four blank-delimited words
  612.   * separated by a single blank and with no leading or trailing blanks,
  613.   * as follows:
  614.   * <ol>
  615.   * <li>
  616.   * <code>digits=</code>, immediately followed by
  617.   * the value of the digits setting as a numeric word.
  618.   * <li>
  619.   * <code>form=</code>, immediately followed by
  620.   * the value of the form setting as an uppercase word
  621.   * (one of <code>SCIENTIFIC</code>, <code>PLAIN</code>, or
  622.   * <code>ENGINEERING</code>).
  623.   * <li>
  624.   * <code>lostDigits=</code>, immediately followed by
  625.   * the value of the lostDigits setting
  626.   * (<code>1</code> if enabled, <code>0</code> if disabled).
  627.   * <li>
  628.   * <code>roundingMode=</code>, immediately followed by
  629.   * the value of the roundingMode setting as a word.
  630.   * This word will be the same as the name of the corresponding public
  631.   * constant.
  632.   * </ol>
  633.   * <p>
  634.   * For example:
  635.   * <br><code>
  636.   * digits=9 form=SCIENTIFIC lostDigits=0 roundingMode=ROUND_HALF_UP
  637.   * </code>
  638.   * <p>
  639.   * Additional words may be appended to the result of
  640.   * <code>toString</code> in the future if more properties are added
  641.   * to the class.
  642.   *
  643.   * @return a <code>String</code> representing the context settings.
  644.   * @stable ICU 2.0
  645.   */
  646.  
  647.  //--public java.lang.String toString(){
  648.  function toString() {
  649.   //--java.lang.String formstr=null;
  650.   var formstr=null;
  651.   //--int r=0;
  652.   var r=0;
  653.   //--java.lang.String roundword=null;
  654.   var roundword=null;
  655.   {/*select*/
  656.   if (this.form==this.SCIENTIFIC)
  657.    formstr="SCIENTIFIC";
  658.   else if (this.form==this.ENGINEERING)
  659.    formstr="ENGINEERING";
  660.   else{
  661.    formstr="PLAIN";/* form=PLAIN */
  662.   }
  663.   }
  664.   {var $1=this.ROUNDS.length;r=0;r:for(;$1>0;$1--,r++){
  665.    if (this.roundingMode==this.ROUNDS[r])
  666.     {
  667.      roundword=this.ROUNDWORDS[r];
  668.      break r;
  669.     }
  670.    }
  671.   }/*r*/
  672.   return "digits="+this.digits+" "+"form="+formstr+" "+"lostDigits="+(this.lostDigits?"1":"0")+" "+"roundingMode="+roundword;
  673.   }
  674.  
  675.  
  676.  /* <sgml> Test whether round is valid. </sgml> */
  677.  // This could be made shared for use by BigDecimal for setScale.
  678.  
  679.  //--private static boolean isValidRound(int testround){
  680.  function isValidRound(testround) {
  681.   //--int r=0;
  682.   var r=0;
  683.   {var $2=this.ROUNDS.length;r=0;r:for(;$2>0;$2--,r++){
  684.    if (testround==this.ROUNDS[r])
  685.     return true;
  686.    }
  687.   }/*r*/
  688.   return false;
  689.   }
  690. return MathContext;
  691. })();
  692.  
  693. var BigDecimal = (function (MathContext) {
  694. /* Generated from 'BigDecimal.nrx' 8 Sep 2000 11:10:50 [v2.00] */
  695. /* Options: Binary Comments Crossref Format Java Logo Strictargs Strictcase Trace2 Verbose3 */
  696. //--package com.ibm.icu.math;
  697. //--import java.math.BigInteger;
  698. //--import com.ibm.icu.impl.Utility;
  699.  
  700. /* ------------------------------------------------------------------ */
  701. /* BigDecimal -- Decimal arithmetic for Java                          */
  702. /* ------------------------------------------------------------------ */
  703. /* Copyright IBM Corporation, 1996, 2000.  All Rights Reserved.       */
  704. /*                                                                    */
  705. /* The BigDecimal class provides immutable arbitrary-precision        */
  706. /* floating point (including integer) decimal numbers.                */
  707. /*                                                                    */
  708. /* As the numbers are decimal, there is an exact correspondence       */
  709. /* between an instance of a BigDecimal object and its String          */
  710. /* representation; the BigDecimal class provides direct conversions   */
  711. /* to and from String and character array objects, and well as        */
  712. /* conversions to and from the Java primitive types (which may not    */
  713. /* be exact).                                                         */
  714. /* ------------------------------------------------------------------ */
  715. /* Notes:                                                             */
  716. /*                                                                    */
  717. /* 1. A BigDecimal object is never changed in value once constructed; */
  718. /*    this avoids the need for locking.  Note in particular that the  */
  719. /*    mantissa array may be shared between many BigDecimal objects,   */
  720. /*    so that once exposed it must not be altered.                    */
  721. /*                                                                    */
  722. /* 2. This class looks at MathContext class fields directly (for      */
  723. /*    performance).  It must not and does not change them.            */
  724. /*                                                                    */
  725. /* 3. Exponent checking is delayed until finish(), as we know         */
  726. /*    intermediate calculations cannot cause 31-bit overflow.         */
  727. /*    [This assertion depends on MAX_DIGITS in MathContext.]          */
  728. /*                                                                    */
  729. /* 4. Comments for the public API now follow the javadoc conventions. */
  730. /*    The NetRexx -comments option is used to pass these comments     */
  731. /*    through to the generated Java code (with -format, if desired).  */
  732. /*                                                                    */
  733. /* 5. System.arraycopy is faster than explicit loop as follows        */
  734. /*      Mean length 4:  equal                                         */
  735. /*      Mean length 8:  x2                                            */
  736. /*      Mean length 16: x3                                            */
  737. /*      Mean length 24: x4                                            */
  738. /*    From prior experience, we expect mean length a little below 8,  */
  739. /*    but arraycopy is still the one to use, in general, until later  */
  740. /*    measurements suggest otherwise.                                 */
  741. /*                                                                    */
  742. /* 6. 'DMSRCN' referred to below is the original (1981) IBM S/370     */
  743. /*    assembler code implementation of the algorithms below; it is    */
  744. /*    now called IXXRCN and is available with the OS/390 and VM/ESA   */
  745. /*    operating systems.                                              */
  746. /* ------------------------------------------------------------------ */
  747. /* Change History:                                                    */
  748. /* 1997.09.02 Initial version (derived from netrexx.lang classes)     */
  749. /* 1997.09.12 Add lostDigits checking                                 */
  750. /* 1997.10.06 Change mantissa to a byte array                         */
  751. /* 1997.11.22 Rework power [did not prepare arguments, etc.]          */
  752. /* 1997.12.13 multiply did not prepare arguments                      */
  753. /* 1997.12.14 add did not prepare and align arguments correctly       */
  754. /* 1998.05.02 0.07 packaging changes suggested by Sun and Oracle      */
  755. /* 1998.05.21 adjust remainder operator finalization                  */
  756. /* 1998.06.04 rework to pass MathContext to finish() and round()      */
  757. /* 1998.06.06 change format to use round(); support rounding modes    */
  758. /* 1998.06.25 rename to BigDecimal and begin merge                    */
  759. /*            zero can now have trailing zeros (i.e., exp\=0)         */
  760. /* 1998.06.28 new methods: movePointXxxx, scale, toBigInteger         */
  761. /*                         unscaledValue, valueof                     */
  762. /* 1998.07.01 improve byteaddsub to allow array reuse, etc.           */
  763. /* 1998.07.01 make null testing explicit to avoid JIT bug [Win32]     */
  764. /* 1998.07.07 scaled division  [divide(BigDecimal, int, int)]         */
  765. /* 1998.07.08 setScale, faster equals                                 */
  766. /* 1998.07.11 allow 1E6 (no sign) <sigh>; new double/float conversion */
  767. /* 1998.10.12 change package to com.ibm.icu.math                          */
  768. /* 1998.12.14 power operator no longer rounds RHS [to match ANSI]     */
  769. /*            add toBigDecimal() and BigDecimal(java.math.BigDecimal) */
  770. /* 1998.12.29 improve byteaddsub by using table lookup                */
  771. /* 1999.02.04 lostdigits=0 behaviour rounds instead of digits+1 guard */
  772. /* 1999.02.05 cleaner code for BigDecimal(char[])                     */
  773. /* 1999.02.06 add javadoc comments                                    */
  774. /* 1999.02.11 format() changed from 7 to 2 method form                */
  775. /* 1999.03.05 null pointer checking is no longer explicit             */
  776. /* 1999.03.05 simplify; changes from discussion with J. Bloch:        */
  777. /*            null no longer permitted for MathContext; drop boolean, */
  778. /*            byte, char, float, short constructor, deprecate double  */
  779. /*            constructor, no blanks in string constructor, add       */
  780. /*            offset and length version of char[] constructor;        */
  781. /*            add valueOf(double); drop booleanValue, charValue;      */
  782. /*            add ...Exact versions of remaining convertors           */
  783. /* 1999.03.13 add toBigIntegerExact                                   */
  784. /* 1999.03.13 1.00 release to IBM Centre for Java Technology          */
  785. /* 1999.05.27 1.01 correct 0-0.2 bug under scaled arithmetic          */
  786. /* 1999.06.29 1.02 constructors should not allow exponent > 9 digits  */
  787. /* 1999.07.03 1.03 lost digits should not be checked if digits=0      */
  788. /* 1999.07.06      lost digits Exception message changed              */
  789. /* 1999.07.10 1.04 more work on 0-0.2 (scaled arithmetic)             */
  790. /* 1999.07.17      improve messages from pow method                   */
  791. /* 1999.08.08      performance tweaks                                 */
  792. /* 1999.08.15      fastpath in multiply                               */
  793. /* 1999.11.05 1.05 fix problem in intValueExact [e.g., 5555555555]    */
  794. /* 1999.12.22 1.06 remove multiply fastpath, and improve performance  */
  795. /* 2000.01.01      copyright update [Y2K has arrived]                 */
  796. /* 2000.06.18 1.08 no longer deprecate BigDecimal(double)             */
  797. /* ------------------------------------------------------------------ */
  798.  
  799.  
  800. /* JavaScript conversion (c) 2003 STZ-IDA and PTV AG, Karlsruhe, Germany */
  801.  
  802.  
  803.  
  804. function div(a, b) {
  805.     return (a-(a%b))/b;
  806. }
  807.  
  808. BigDecimal.prototype.div = div;
  809.  
  810. function arraycopy(src, srcindex, dest, destindex, length) {
  811.     var i;
  812.     if (destindex > srcindex) {
  813.         // in case src and dest are equals, but also doesn't hurt
  814.         // if they are different
  815.         for (i = length-1; i >= 0; --i) {
  816.             dest[i+destindex] = src[i+srcindex];
  817.         }
  818.     } else {
  819.         for (i = 0; i < length; ++i) {
  820.             dest[i+destindex] = src[i+srcindex];
  821.         }
  822.     }
  823. }
  824.  
  825. BigDecimal.prototype.arraycopy = arraycopy;
  826.  
  827. function createArrayWithZeros(length) {
  828.     var retVal = new Array(length);
  829.     var i;
  830.     for (i = 0; i < length; ++i) {
  831.         retVal[i] = 0;
  832.     }
  833.     return retVal;
  834. }
  835.  
  836. BigDecimal.prototype.createArrayWithZeros = createArrayWithZeros;
  837.  
  838.  
  839. /**
  840.  * The <code>BigDecimal</code> class implements immutable
  841.  * arbitrary-precision decimal numbers.  The methods of the
  842.  * <code>BigDecimal</code> class provide operations for fixed and
  843.  * floating point arithmetic, comparison, format conversions, and
  844.  * hashing.
  845.  * <p>
  846.  * As the numbers are decimal, there is an exact correspondence between
  847.  * an instance of a <code>BigDecimal</code> object and its
  848.  * <code>String</code> representation; the <code>BigDecimal</code> class
  849.  * provides direct conversions to and from <code>String</code> and
  850.  * character array (<code>char[]</code>) objects, as well as conversions
  851.  * to and from the Java primitive types (which may not be exact) and
  852.  * <code>BigInteger</code>.
  853.  * <p>
  854.  * In the descriptions of constructors and methods in this documentation,
  855.  * the value of a <code>BigDecimal</code> number object is shown as the
  856.  * result of invoking the <code>toString()</code> method on the object.
  857.  * The internal representation of a decimal number is neither defined
  858.  * nor exposed, and is not permitted to affect the result of any
  859.  * operation.
  860.  * <p>
  861.  * The floating point arithmetic provided by this class is defined by
  862.  * the ANSI X3.274-1996 standard, and is also documented at
  863.  * <code>http://www2.hursley.ibm.com/decimal</code>
  864.  * <br><i>[This URL will change.]</i>
  865.  *
  866.  * <h3>Operator methods</h3>
  867.  * <p>
  868.  * Operations on <code>BigDecimal</code> numbers are controlled by a
  869.  * {@link MathContext} object, which provides the context (precision and
  870.  * other information) for the operation. Methods that can take a
  871.  * <code>MathContext</code> parameter implement the standard arithmetic
  872.  * operators for <code>BigDecimal</code> objects and are known as
  873.  * <i>operator methods</i>.  The default settings provided by the
  874.  * constant {@link MathContext#DEFAULT} (<code>digits=9,
  875.  * form=SCIENTIFIC, lostDigits=false, roundingMode=ROUND_HALF_UP</code>)
  876.  * perform general-purpose floating point arithmetic to nine digits of
  877.  * precision.  The <code>MathContext</code> parameter must not be
  878.  * <code>null</code>.
  879.  * <p>
  880.  * Each operator method also has a version provided which does
  881.  * not take a <code>MathContext</code> parameter.  For this version of
  882.  * each method, the context settings used are <code>digits=0,
  883.  * form=PLAIN, lostDigits=false, roundingMode=ROUND_HALF_UP</code>;
  884.  * these settings perform fixed point arithmetic with unlimited
  885.  * precision, as defined for the original BigDecimal class in Java 1.1
  886.  * and Java 1.2.
  887.  * <p>
  888.  * For monadic operators, only the optional <code>MathContext</code>
  889.  * parameter is present; the operation acts upon the current object.
  890.  * <p>
  891.  * For dyadic operators, a <code>BigDecimal</code> parameter is always
  892.  * present; it must not be <code>null</code>.
  893.  * The operation acts with the current object being the left-hand operand
  894.  * and the <code>BigDecimal</code> parameter being the right-hand operand.
  895.  * <p>
  896.  * For example, adding two <code>BigDecimal</code> objects referred to
  897.  * by the names <code>award</code> and <code>extra</code> could be
  898.  * written as any of:
  899.  * <p><code>
  900.  *     award.add(extra)
  901.  * <br>award.add(extra, MathContext.DEFAULT)
  902.  * <br>award.add(extra, acontext)
  903.  * </code>
  904.  * <p>
  905.  * (where <code>acontext</code> is a <code>MathContext</code> object),
  906.  * which would return a <code>BigDecimal</code> object whose value is
  907.  * the result of adding <code>award</code> and <code>extra</code> under
  908.  * the appropriate context settings.
  909.  * <p>
  910.  * When a <code>BigDecimal</code> operator method is used, a set of
  911.  * rules define what the result will be (and, by implication, how the
  912.  * result would be represented as a character string).
  913.  * These rules are defined in the BigDecimal arithmetic documentation
  914.  * (see the URL above), but in summary:
  915.  * <ul>
  916.  * <li>Results are normally calculated with up to some maximum number of
  917.  * significant digits.
  918.  * For example, if the <code>MathContext</code> parameter for an operation
  919.  * were <code>MathContext.DEFAULT</code> then the result would be
  920.  * rounded to 9 digits; the division of 2 by 3 would then result in
  921.  * 0.666666667.
  922.  * <br>
  923.  * You can change the default of 9 significant digits by providing the
  924.  * method with a suitable <code>MathContext</code> object. This lets you
  925.  * calculate using as many digits as you need -- thousands, if necessary.
  926.  * Fixed point (scaled) arithmetic is indicated by using a
  927.  * <code>digits</code> setting of 0 (or omitting the
  928.  * <code>MathContext</code> parameter).
  929.  * <br>
  930.  * Similarly, you can change the algorithm used for rounding from the
  931.  * default "classic" algorithm.
  932.  * <li>
  933.  * In standard arithmetic (that is, when the <code>form</code> setting
  934.  * is not <code>PLAIN</code>), a zero result is always expressed as the
  935.  * single digit <code>'0'</code> (that is, with no sign, decimal point,
  936.  * or exponent part).
  937.  * <li>
  938.  * Except for the division and power operators in standard arithmetic,
  939.  * trailing zeros are preserved (this is in contrast to binary floating
  940.  * point operations and most electronic calculators, which lose the
  941.  * information about trailing zeros in the fractional part of results).
  942.  * <br>
  943.  * So, for example:
  944.  * <p><code>
  945.  *     new BigDecimal("2.40").add(     new BigDecimal("2"))      => "4.40"
  946.  * <br>new BigDecimal("2.40").subtract(new BigDecimal("2"))      => "0.40"
  947.  * <br>new BigDecimal("2.40").multiply(new BigDecimal("2"))      => "4.80"
  948.  * <br>new BigDecimal("2.40").divide(  new BigDecimal("2"), def) => "1.2"
  949.  * </code>
  950.  * <p>where the value on the right of the <code>=></code> would be the
  951.  * result of the operation, expressed as a <code>String</code>, and
  952.  * <code>def</code> (in this and following examples) refers to
  953.  * <code>MathContext.DEFAULT</code>).
  954.  * This preservation of trailing zeros is desirable for most
  955.  * calculations (including financial calculations).
  956.  * If necessary, trailing zeros may be easily removed using division by 1.
  957.  * <li>
  958.  * In standard arithmetic, exponential form is used for a result
  959.  * depending on its value and the current setting of <code>digits</code>
  960.  * (the default is 9 digits).
  961.  * If the number of places needed before the decimal point exceeds the
  962.  * <code>digits</code> setting, or the absolute value of the number is
  963.  * less than <code>0.000001</code>, then the number will be expressed in
  964.  * exponential notation; thus
  965.  * <p><code>
  966.  *   new BigDecimal("1e+6").multiply(new BigDecimal("1e+6"), def)
  967.  * </code>
  968.  * <p>results in <code>1E+12</code> instead of
  969.  * <code>1000000000000</code>, and
  970.  * <p><code>
  971.  *   new BigDecimal("1").divide(new BigDecimal("3E+10"), def)
  972.  * </code>
  973.  * <p>results in <code>3.33333333E-11</code> instead of
  974.  * <code>0.0000000000333333333</code>.
  975.  * <p>
  976.  * The form of the exponential notation (scientific or engineering) is
  977.  * determined by the <code>form</code> setting.
  978.  * <eul>
  979.  * <p>
  980.  * The names of methods in this class follow the conventions established
  981.  * by <code>java.lang.Number</code>, <code>java.math.BigInteger</code>,
  982.  * and <code>java.math.BigDecimal</code> in Java 1.1 and Java 1.2.
  983.  *
  984.  * @see     MathContext
  985.  * @author  Mike Cowlishaw
  986.  * @stable ICU 2.0
  987.  */
  988.  
  989. //--public class BigDecimal extends java.lang.Number implements java.io.Serializable,java.lang.Comparable{
  990. //-- private static final java.lang.String $0="BigDecimal.nrx";
  991.  
  992.  //-- methods
  993.  BigDecimal.prototype.abs = abs;
  994.  BigDecimal.prototype.add = add;
  995.  BigDecimal.prototype.compareTo = compareTo;
  996.  BigDecimal.prototype.divide = divide;
  997.  BigDecimal.prototype.divideInteger = divideInteger;
  998.  BigDecimal.prototype.max = max;
  999.  BigDecimal.prototype.min = min;
  1000.  BigDecimal.prototype.multiply = multiply;
  1001.  BigDecimal.prototype.negate = negate;
  1002.  BigDecimal.prototype.plus = plus;
  1003.  BigDecimal.prototype.pow = pow;
  1004.  BigDecimal.prototype.remainder = remainder;
  1005.  BigDecimal.prototype.subtract = subtract;
  1006.  BigDecimal.prototype.equals = equals;
  1007.  BigDecimal.prototype.format = format;
  1008.  BigDecimal.prototype.intValueExact = intValueExact;
  1009.  BigDecimal.prototype.movePointLeft = movePointLeft;
  1010.  BigDecimal.prototype.movePointRight = movePointRight;
  1011.  BigDecimal.prototype.scale = scale;
  1012.  BigDecimal.prototype.setScale = setScale;
  1013.  BigDecimal.prototype.signum = signum;
  1014.  BigDecimal.prototype.toString = toString;
  1015.  BigDecimal.prototype.layout = layout;
  1016.  BigDecimal.prototype.intcheck = intcheck;
  1017.  BigDecimal.prototype.dodivide = dodivide;
  1018.  BigDecimal.prototype.bad = bad;
  1019.  BigDecimal.prototype.badarg = badarg;
  1020.  BigDecimal.prototype.extend = extend;
  1021.  BigDecimal.prototype.byteaddsub = byteaddsub;
  1022.  BigDecimal.prototype.diginit = diginit;
  1023.  BigDecimal.prototype.clone = clone;
  1024.  BigDecimal.prototype.checkdigits = checkdigits;
  1025.  BigDecimal.prototype.round = round;
  1026.  BigDecimal.prototype.allzero = allzero;
  1027.  BigDecimal.prototype.finish = finish;
  1028.  
  1029.  // Convenience methods
  1030.  BigDecimal.prototype.isGreaterThan = isGreaterThan;
  1031.  BigDecimal.prototype.isLessThan = isLessThan;
  1032.  BigDecimal.prototype.isGreaterThanOrEqualTo = isGreaterThanOrEqualTo;
  1033.  BigDecimal.prototype.isLessThanOrEqualTo = isLessThanOrEqualTo;
  1034.  BigDecimal.prototype.isPositive = isPositive;
  1035.  BigDecimal.prototype.isNegative = isNegative;
  1036.  BigDecimal.prototype.isZero = isZero;
  1037.  
  1038.  
  1039.  /* ----- Constants ----- */
  1040.  /* properties constant public */ // useful to others
  1041.  // the rounding modes (copied here for upwards compatibility)
  1042.  /**
  1043.   * Rounding mode to round to a more positive number.
  1044.   * @see MathContext#ROUND_CEILING
  1045.   * @stable ICU 2.0
  1046.   */
  1047.  //--public static final int ROUND_CEILING=com.ibm.icu.math.MathContext.ROUND_CEILING;
  1048.  BigDecimal.ROUND_CEILING = BigDecimal.prototype.ROUND_CEILING = MathContext.prototype.ROUND_CEILING;
  1049.  
  1050.  /**
  1051.   * Rounding mode to round towards zero.
  1052.   * @see MathContext#ROUND_DOWN
  1053.   * @stable ICU 2.0
  1054.   */
  1055.  //--public static final int ROUND_DOWN=com.ibm.icu.math.MathContext.ROUND_DOWN;
  1056.  BigDecimal.ROUND_DOWN = BigDecimal.prototype.ROUND_DOWN = MathContext.prototype.ROUND_DOWN;
  1057.  
  1058.  /**
  1059.   * Rounding mode to round to a more negative number.
  1060.   * @see MathContext#ROUND_FLOOR
  1061.   * @stable ICU 2.0
  1062.   */
  1063.  //--public static final int ROUND_FLOOR=com.ibm.icu.math.MathContext.ROUND_FLOOR;
  1064.  BigDecimal.ROUND_FLOOR = BigDecimal.prototype.ROUND_FLOOR = MathContext.prototype.ROUND_FLOOR;
  1065.  
  1066.  /**
  1067.   * Rounding mode to round to nearest neighbor, where an equidistant
  1068.   * value is rounded down.
  1069.   * @see MathContext#ROUND_HALF_DOWN
  1070.   * @stable ICU 2.0
  1071.   */
  1072.  //--public static final int ROUND_HALF_DOWN=com.ibm.icu.math.MathContext.ROUND_HALF_DOWN;
  1073.  BigDecimal.ROUND_HALF_DOWN = BigDecimal.prototype.ROUND_HALF_DOWN = MathContext.prototype.ROUND_HALF_DOWN;
  1074.  
  1075.  /**
  1076.   * Rounding mode to round to nearest neighbor, where an equidistant
  1077.   * value is rounded to the nearest even neighbor.
  1078.   * @see MathContext#ROUND_HALF_EVEN
  1079.   * @stable ICU 2.0
  1080.   */
  1081.  //--public static final int ROUND_HALF_EVEN=com.ibm.icu.math.MathContext.ROUND_HALF_EVEN;
  1082.  BigDecimal.ROUND_HALF_EVEN = BigDecimal.prototype.ROUND_HALF_EVEN = MathContext.prototype.ROUND_HALF_EVEN;
  1083.  
  1084.  /**
  1085.   * Rounding mode to round to nearest neighbor, where an equidistant
  1086.   * value is rounded up.
  1087.   * @see MathContext#ROUND_HALF_UP
  1088.   * @stable ICU 2.0
  1089.   */
  1090.  //--public static final int ROUND_HALF_UP=com.ibm.icu.math.MathContext.ROUND_HALF_UP;
  1091.  BigDecimal.ROUND_HALF_UP = BigDecimal.prototype.ROUND_HALF_UP = MathContext.prototype.ROUND_HALF_UP;
  1092.  
  1093.  /**
  1094.   * Rounding mode to assert that no rounding is necessary.
  1095.   * @see MathContext#ROUND_UNNECESSARY
  1096.   * @stable ICU 2.0
  1097.   */
  1098.  //--public static final int ROUND_UNNECESSARY=com.ibm.icu.math.MathContext.ROUND_UNNECESSARY;
  1099.  BigDecimal.ROUND_UNNECESSARY = BigDecimal.prototype.ROUND_UNNECESSARY = MathContext.prototype.ROUND_UNNECESSARY;
  1100.  
  1101.  /**
  1102.   * Rounding mode to round away from zero.
  1103.   * @see MathContext#ROUND_UP
  1104.   * @stable ICU 2.0
  1105.   */
  1106.  //--public static final int ROUND_UP=com.ibm.icu.math.MathContext.ROUND_UP;
  1107.  BigDecimal.ROUND_UP = BigDecimal.prototype.ROUND_UP = MathContext.prototype.ROUND_UP;
  1108.  
  1109.  /* properties constant private */ // locals
  1110.  //--private static final byte ispos=1; // ind: indicates positive (must be 1)
  1111.  //--private static final byte iszero=0; // ind: indicates zero     (must be 0)
  1112.  //--private static final byte isneg=-1; // ind: indicates negative (must be -1)
  1113.  BigDecimal.prototype.ispos = 1;
  1114.  BigDecimal.prototype.iszero = 0;
  1115.  BigDecimal.prototype.isneg = -1;
  1116.  // [later could add NaN, +/- infinity, here]
  1117.  
  1118.  //--private static final int MinExp=-999999999; // minimum exponent allowed
  1119.  //--private static final int MaxExp=999999999; // maximum exponent allowed
  1120.  //--private static final int MinArg=-999999999; // minimum argument integer
  1121.  //--private static final int MaxArg=999999999; // maximum argument integer
  1122.  BigDecimal.prototype.MinExp=-999999999; // minimum exponent allowed
  1123.  BigDecimal.prototype.MaxExp=999999999; // maximum exponent allowed
  1124.  BigDecimal.prototype.MinArg=-999999999; // minimum argument integer
  1125.  BigDecimal.prototype.MaxArg=999999999; // maximum argument integer
  1126.  
  1127.  //--private static final com.ibm.icu.math.MathContext plainMC=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN); // context for plain unlimited math
  1128.  BigDecimal.prototype.plainMC=new MathContext(0, MathContext.prototype.PLAIN);
  1129.  
  1130.  /* properties constant private unused */ // present but not referenced
  1131.  
  1132.  // Serialization version
  1133.  //--private static final long serialVersionUID=8245355804974198832L;
  1134.  
  1135.  //--private static final java.lang.String copyright=" Copyright (c) IBM Corporation 1996, 2000.  All rights reserved. ";
  1136.  
  1137.  /* properties static private */
  1138.  // Precalculated constant arrays (used by byteaddsub)
  1139.  //--private static byte bytecar[]=new byte[(90+99)+1]; // carry/borrow array
  1140.  //--private static byte bytedig[]=diginit(); // next digit array
  1141.  BigDecimal.prototype.bytecar = new Array((90+99)+1);
  1142.  BigDecimal.prototype.bytedig = diginit();
  1143.  
  1144.  /**
  1145.   * The <code>BigDecimal</code> constant "0".
  1146.   *
  1147.   * @see #ONE
  1148.   * @see #TEN
  1149.   * @stable ICU 2.0
  1150.   */
  1151.  //--public static final com.ibm.icu.math.BigDecimal ZERO=new com.ibm.icu.math.BigDecimal((long)0); // use long as we want the int constructor
  1152.  // .. to be able to use this, for speed
  1153. BigDecimal.ZERO = BigDecimal.prototype.ZERO = new BigDecimal("0");
  1154.  
  1155.  /**
  1156.   * The <code>BigDecimal</code> constant "1".
  1157.   *
  1158.   * @see #TEN
  1159.   * @see #ZERO
  1160.   * @stable ICU 2.0
  1161.   */
  1162.  //--public static final com.ibm.icu.math.BigDecimal ONE=new com.ibm.icu.math.BigDecimal((long)1); // use long as we want the int constructor
  1163.  // .. to be able to use this, for speed
  1164. BigDecimal.ONE = BigDecimal.prototype.ONE = new BigDecimal("1");
  1165.  
  1166.  /**
  1167.   * The <code>BigDecimal</code> constant "10".
  1168.   *
  1169.   * @see #ONE
  1170.   * @see #ZERO
  1171.   * @stable ICU 2.0
  1172.   */
  1173.  //--public static final com.ibm.icu.math.BigDecimal TEN=new com.ibm.icu.math.BigDecimal(10);
  1174.  BigDecimal.TEN = BigDecimal.prototype.TEN = new BigDecimal("10");
  1175.  
  1176.  /* ----- Instance properties [all private and immutable] ----- */
  1177.  /* properties private */
  1178.  
  1179.  /**
  1180.   * The indicator. This may take the values:
  1181.   * <ul>
  1182.   * <li>ispos  -- the number is positive
  1183.   * <li>iszero -- the number is zero
  1184.   * <li>isneg  -- the number is negative
  1185.   * </ul>
  1186.   *
  1187.   * @serial
  1188.   */
  1189.  //--private byte ind; // assumed undefined
  1190.  // Note: some code below assumes IND = Sign [-1, 0, 1], at present.
  1191.  // We only need two bits for this, but use a byte [also permits
  1192.  // smooth future extension].
  1193.  
  1194.  /**
  1195.   * The formatting style. This may take the values:
  1196.   * <ul>
  1197.   * <li>MathContext.PLAIN        -- no exponent needed
  1198.   * <li>MathContext.SCIENTIFIC   -- scientific notation required
  1199.   * <li>MathContext.ENGINEERING  -- engineering notation required
  1200.   * </ul>
  1201.   * <p>
  1202.   * This property is an optimization; it allows us to defer number
  1203.   * layout until it is actually needed as a string, hence avoiding
  1204.   * unnecessary formatting.
  1205.   *
  1206.   * @serial
  1207.   */
  1208.  //--private byte form=(byte)com.ibm.icu.math.MathContext.PLAIN; // assumed PLAIN
  1209.  // We only need two bits for this, at present, but use a byte
  1210.  // [again, to allow for smooth future extension]
  1211.  
  1212.  /**
  1213.   * The value of the mantissa.
  1214.   * <p>
  1215.   * Once constructed, this may become shared between several BigDecimal
  1216.   * objects, so must not be altered.
  1217.   * <p>
  1218.   * For efficiency (speed), this is a byte array, with each byte
  1219.   * taking a value of 0 -> 9.
  1220.   * <p>
  1221.   * If the first byte is 0 then the value of the number is zero (and
  1222.   * mant.length=1, except when constructed from a plain number, for
  1223.   * example, 0.000).
  1224.   *
  1225.   * @serial
  1226.   */
  1227.  //--private byte mant[]; // assumed null
  1228.  
  1229.  /**
  1230.   * The exponent.
  1231.   * <p>
  1232.   * For fixed point arithmetic, scale is <code>-exp</code>, and can
  1233.   * apply to zero.
  1234.   *
  1235.   * Note that this property can have a value less than MinExp when
  1236.   * the mantissa has more than one digit.
  1237.   *
  1238.   * @serial
  1239.   */
  1240.  //--private int exp;
  1241.  // assumed 0
  1242.  
  1243.  /* ---------------------------------------------------------------- */
  1244.  /* Constructors                                                     */
  1245.  /* ---------------------------------------------------------------- */
  1246.  
  1247.  /**
  1248.   * Constructs a <code>BigDecimal</code> object from a
  1249.   * <code>java.math.BigDecimal</code>.
  1250.   * <p>
  1251.   * Constructs a <code>BigDecimal</code> as though the parameter had
  1252.   * been represented as a <code>String</code> (using its
  1253.   * <code>toString</code> method) and the
  1254.   * {@link #BigDecimal(java.lang.String)} constructor had then been
  1255.   * used.
  1256.   * The parameter must not be <code>null</code>.
  1257.   * <p>
  1258.   * <i>(Note: this constructor is provided only in the
  1259.   * <code>com.ibm.icu.math</code> version of the BigDecimal class.
  1260.   * It would not be present in a <code>java.math</code> version.)</i>
  1261.   *
  1262.   * @param bd The <code>BigDecimal</code> to be translated.
  1263.   * @stable ICU 2.0
  1264.   */
  1265.  
  1266.  //--public BigDecimal(java.math.BigDecimal bd){
  1267.  //-- this(bd.toString());
  1268.  //-- return;}
  1269.  
  1270.  /**
  1271.   * Constructs a <code>BigDecimal</code> object from a
  1272.   * <code>BigInteger</code>, with scale 0.
  1273.   * <p>
  1274.   * Constructs a <code>BigDecimal</code> which is the exact decimal
  1275.   * representation of the <code>BigInteger</code>, with a scale of
  1276.   * zero.
  1277.   * The value of the <code>BigDecimal</code> is identical to the value
  1278.   * of the <code>BigInteger</code>.
  1279.   * The parameter must not be <code>null</code>.
  1280.   * <p>
  1281.   * The <code>BigDecimal</code> will contain only decimal digits,
  1282.   * prefixed with a leading minus sign (hyphen) if the
  1283.   * <code>BigInteger</code> is negative.  A leading zero will be
  1284.   * present only if the <code>BigInteger</code> is zero.
  1285.   *
  1286.   * @param bi The <code>BigInteger</code> to be converted.
  1287.   * @stable ICU 2.0
  1288.   */
  1289.  
  1290.  //--public BigDecimal(java.math.BigInteger bi){
  1291.  //-- this(bi.toString(10));
  1292.  //-- return;}
  1293.  // exp remains 0
  1294.  
  1295.  /**
  1296.   * Constructs a <code>BigDecimal</code> object from a
  1297.   * <code>BigInteger</code> and a scale.
  1298.   * <p>
  1299.   * Constructs a <code>BigDecimal</code> which is the exact decimal
  1300.   * representation of the <code>BigInteger</code>, scaled by the
  1301.   * second parameter, which may not be negative.
  1302.   * The value of the <code>BigDecimal</code> is the
  1303.   * <code>BigInteger</code> divided by ten to the power of the scale.
  1304.   * The <code>BigInteger</code> parameter must not be
  1305.   * <code>null</code>.
  1306.   * <p>
  1307.   * The <code>BigDecimal</code> will contain only decimal digits, (with
  1308.   * an embedded decimal point followed by <code>scale</code> decimal
  1309.   * digits if the scale is positive), prefixed with a leading minus
  1310.   * sign (hyphen) if the <code>BigInteger</code> is negative.  A
  1311.   * leading zero will be present only if the <code>BigInteger</code> is
  1312.   * zero.
  1313.   *
  1314.   * @param  bi    The <code>BigInteger</code> to be converted.
  1315.   * @param  scale The <code>int</code> specifying the scale.
  1316.   * @throws NumberFormatException if the scale is negative.
  1317.   * @stable ICU 2.0
  1318.   */
  1319.  
  1320.  //--public BigDecimal(java.math.BigInteger bi,int scale){
  1321.  //-- this(bi.toString(10));
  1322.  //-- if (scale<0)
  1323.  //--  throw new java.lang.NumberFormatException("Negative scale:"+" "+scale);
  1324.  //-- exp=(int)-scale; // exponent is -scale
  1325.  //-- return;}
  1326.  
  1327.  /**
  1328.   * Constructs a <code>BigDecimal</code> object from an array of characters.
  1329.   * <p>
  1330.   * Constructs a <code>BigDecimal</code> as though a
  1331.   * <code>String</code> had been constructed from the character array
  1332.   * and the {@link #BigDecimal(java.lang.String)} constructor had then
  1333.   * been used. The parameter must not be <code>null</code>.
  1334.   * <p>
  1335.   * Using this constructor is faster than using the
  1336.   * <code>BigDecimal(String)</code> constructor if the string is
  1337.   * already available in character array form.
  1338.   *
  1339.   * @param inchars The <code>char[]</code> array containing the number
  1340.   *                to be converted.
  1341.   * @throws NumberFormatException if the parameter is not a valid
  1342.   *                number.
  1343.   * @stable ICU 2.0
  1344.   */
  1345.  
  1346.  //--public BigDecimal(char inchars[]){
  1347.  //-- this(inchars,0,inchars.length);
  1348.  //-- return;}
  1349.  
  1350.  /**
  1351.   * Constructs a <code>BigDecimal</code> object from an array of characters.
  1352.   * <p>
  1353.   * Constructs a <code>BigDecimal</code> as though a
  1354.   * <code>String</code> had been constructed from the character array
  1355.   * (or a subarray of that array) and the
  1356.   * {@link #BigDecimal(java.lang.String)} constructor had then been
  1357.   * used. The first parameter must not be <code>null</code>, and the
  1358.   * subarray must be wholly contained within it.
  1359.   * <p>
  1360.   * Using this constructor is faster than using the
  1361.   * <code>BigDecimal(String)</code> constructor if the string is
  1362.   * already available within a character array.
  1363.   *
  1364.   * @param inchars The <code>char[]</code> array containing the number
  1365.   *                to be converted.
  1366.   * @param offset  The <code>int</code> offset into the array of the
  1367.   *                start of the number to be converted.
  1368.   * @param length  The <code>int</code> length of the number.
  1369.   * @throws NumberFormatException if the parameter is not a valid
  1370.   *                number for any reason.
  1371.   * @stable ICU 2.0
  1372.   */
  1373.  
  1374.  //--public BigDecimal(char inchars[],int offset,int length){super();
  1375.  function BigDecimal() {
  1376.   //-- members
  1377.   this.ind = 0;
  1378.   this.form = MathContext.prototype.PLAIN;
  1379.   this.mant = null;
  1380.   this.exp = 0;
  1381.  
  1382.   //-- overloaded ctor
  1383.   if (BigDecimal.arguments.length == 0)
  1384.    return;
  1385.   var inchars;
  1386.   var offset;
  1387.   var length;
  1388.   if (BigDecimal.arguments.length == 1)
  1389.    {
  1390.     inchars = BigDecimal.arguments[0];
  1391.     offset = 0;
  1392.     length = inchars.length;
  1393.    }
  1394.   else
  1395.    {
  1396.     inchars = BigDecimal.arguments[0];
  1397.     offset = BigDecimal.arguments[1];
  1398.     length = BigDecimal.arguments[2];
  1399.    }
  1400.   if (typeof inchars == "string")
  1401.    {
  1402.     inchars = inchars.split("");
  1403.    }
  1404.  
  1405.   //--boolean exotic;
  1406.   var exotic;
  1407.   //--boolean hadexp;
  1408.   var hadexp;
  1409.   //--int d;
  1410.   var d;
  1411.   //--int dotoff;
  1412.   var dotoff;
  1413.   //--int last;
  1414.   var last;
  1415.   //--int i=0;
  1416.   var i=0;
  1417.   //--char si=0;
  1418.   var si=0;
  1419.   //--boolean eneg=false;
  1420.   var eneg=false;
  1421.   //--int k=0;
  1422.   var k=0;
  1423.   //--int elen=0;
  1424.   var elen=0;
  1425.   //--int j=0;
  1426.   var j=0;
  1427.   //--char sj=0;
  1428.   var sj=0;
  1429.   //--int dvalue=0;
  1430.   var dvalue=0;
  1431.   //--int mag=0;
  1432.   var mag=0;
  1433.   // This is the primary constructor; all incoming strings end up
  1434.   // here; it uses explicit (inline) parsing for speed and to avoid
  1435.   // generating intermediate (temporary) objects of any kind.
  1436.   // 1998.06.25: exponent form built only if E/e in string
  1437.   // 1998.06.25: trailing zeros not removed for zero
  1438.   // 1999.03.06: no embedded blanks; allow offset and length
  1439.   if (length<=0)
  1440.    this.bad("BigDecimal(): ", inchars); // bad conversion (empty string)
  1441.   // [bad offset will raise array bounds exception]
  1442.  
  1443.   /* Handle and step past sign */
  1444.   this.ind=this.ispos; // assume positive
  1445.   if (inchars[0]==('-'))
  1446.    {
  1447.     length--;
  1448.     if (length==0)
  1449.      this.bad("BigDecimal(): ", inchars); // nothing after sign
  1450.     this.ind=this.isneg;
  1451.     offset++;
  1452.    }
  1453.   else
  1454.    if (inchars[0]==('+'))
  1455.     {
  1456.      length--;
  1457.      if (length==0)
  1458.       this.bad("BigDecimal(): ", inchars); // nothing after sign
  1459.      offset++;
  1460.     }
  1461.  
  1462.   /* We're at the start of the number */
  1463.   exotic=false; // have extra digits
  1464.   hadexp=false; // had explicit exponent
  1465.   d=0; // count of digits found
  1466.   dotoff=-1; // offset where dot was found
  1467.   last=-1; // last character of mantissa
  1468.   {var $1=length;i=offset;i:for(;$1>0;$1--,i++){
  1469.    si=inchars[i];
  1470.    if (si>='0')  // test for Arabic digit
  1471.     if (si<='9')
  1472.      {
  1473.       last=i;
  1474.       d++; // still in mantissa
  1475.       continue i;
  1476.      }
  1477.    if (si=='.')
  1478.     { // record and ignore
  1479.      if (dotoff>=0)
  1480.       this.bad("BigDecimal(): ", inchars); // two dots
  1481.      dotoff=i-offset; // offset into mantissa
  1482.      continue i;
  1483.     }
  1484.    if (si!='e')
  1485.     if (si!='E')
  1486.      { // expect an extra digit
  1487.       if (si<'0' || si>'9')
  1488.        this.bad("BigDecimal(): ", inchars); // not a number
  1489.       // defer the base 10 check until later to avoid extra method call
  1490.       exotic=true; // will need conversion later
  1491.       last=i;
  1492.       d++; // still in mantissa
  1493.       continue i;
  1494.      }
  1495.    /* Found 'e' or 'E' -- now process explicit exponent */
  1496.    // 1998.07.11: sign no longer required
  1497.    if ((i-offset)>(length-2))
  1498.     this.bad("BigDecimal(): ", inchars); // no room for even one digit
  1499.    eneg=false;
  1500.    if ((inchars[i+1])==('-'))
  1501.     {
  1502.      eneg=true;
  1503.      k=i+2;
  1504.     }
  1505.    else
  1506.     if ((inchars[i+1])==('+'))
  1507.      k=i+2;
  1508.     else
  1509.      k=i+1;
  1510.    // k is offset of first expected digit
  1511.    elen=length-((k-offset)); // possible number of digits
  1512.    if ((elen==0)||(elen>9))
  1513.     this.bad("BigDecimal(): ", inchars); // 0 or more than 9 digits
  1514.    {var $2=elen;j=k;j:for(;$2>0;$2--,j++){
  1515.     sj=inchars[j];
  1516.     if (sj<'0')
  1517.      this.bad("BigDecimal(): ", inchars); // always bad
  1518.     if (sj>'9')
  1519.      { // maybe an exotic digit
  1520.       /*if (si<'0' || si>'9')
  1521.        this.bad(inchars); // not a number
  1522.       dvalue=java.lang.Character.digit(sj,10); // check base
  1523.       if (dvalue<0)
  1524.        bad(inchars); // not base 10*/
  1525.       this.bad("BigDecimal(): ", inchars);
  1526.      }
  1527.     else
  1528.      dvalue=sj-'0';
  1529.     this.exp=(this.exp*10)+dvalue;
  1530.     }
  1531.    }/*j*/
  1532.    if (eneg)
  1533.     this.exp=-this.exp; // was negative
  1534.    hadexp=true; // remember we had one
  1535.    break i; // we are done
  1536.    }
  1537.   }/*i*/
  1538.  
  1539.   /* Here when all inspected */
  1540.   if (d==0)
  1541.    this.bad("BigDecimal(): ", inchars); // no mantissa digits
  1542.   if (dotoff>=0)
  1543.    this.exp=(this.exp+dotoff)-d; // adjust exponent if had dot
  1544.  
  1545.   /* strip leading zeros/dot (leave final if all 0's) */
  1546.   {var $3=last-1;i=offset;i:for(;i<=$3;i++){
  1547.    si=inchars[i];
  1548.    if (si=='0')
  1549.     {
  1550.      offset++;
  1551.      dotoff--;
  1552.      d--;
  1553.     }
  1554.    else
  1555.     if (si=='.')
  1556.      {
  1557.       offset++; // step past dot
  1558.       dotoff--;
  1559.      }
  1560.     else
  1561.      if (si<='9')
  1562.       break i;/* non-0 */
  1563.      else
  1564.       {/* exotic */
  1565.        //if ((java.lang.Character.digit(si,10))!=0)
  1566.         break i; // non-0 or bad
  1567.        // is 0 .. strip like '0'
  1568.        //offset++;
  1569.        //dotoff--;
  1570.        //d--;
  1571.       }
  1572.    }
  1573.   }/*i*/
  1574.  
  1575.   /* Create the mantissa array */
  1576.   this.mant=new Array(d); // we know the length
  1577.   j=offset; // input offset
  1578.   if (exotic)
  1579.    {exotica:do{ // slow: check for exotica
  1580.     {var $4=d;i=0;i:for(;$4>0;$4--,i++){
  1581.      if (i==dotoff)
  1582.       j++; // at dot
  1583.      sj=inchars[j];
  1584.      if (sj<='9')
  1585.       this.mant[i]=sj-'0';/* easy */
  1586.      else
  1587.       {
  1588.        //dvalue=java.lang.Character.digit(sj,10);
  1589.        //if (dvalue<0)
  1590.         this.bad("BigDecimal(): ", inchars); // not a number after all
  1591.        //mant[i]=(byte)dvalue;
  1592.       }
  1593.      j++;
  1594.      }
  1595.     }/*i*/
  1596.    }while(false);}/*exotica*/
  1597.   else
  1598.    {simple:do{
  1599.     {var $5=d;i=0;i:for(;$5>0;$5--,i++){
  1600.      if (i==dotoff)
  1601.       j++;
  1602.      this.mant[i]=inchars[j]-'0';
  1603.      j++;
  1604.      }
  1605.     }/*i*/
  1606.    }while(false);}/*simple*/
  1607.  
  1608.   /* Looks good.  Set the sign indicator and form, as needed. */
  1609.   // Trailing zeros are preserved
  1610.   // The rule here for form is:
  1611.   //   If no E-notation, then request plain notation
  1612.   //   Otherwise act as though add(0,DEFAULT) and request scientific notation
  1613.   // [form is already PLAIN]
  1614.   if (this.mant[0]==0)
  1615.    {
  1616.     this.ind=this.iszero; // force to show zero
  1617.     // negative exponent is significant (e.g., -3 for 0.000) if plain
  1618.     if (this.exp>0)
  1619.      this.exp=0; // positive exponent can be ignored
  1620.     if (hadexp)
  1621.      { // zero becomes single digit from add
  1622.       this.mant=this.ZERO.mant;
  1623.       this.exp=0;
  1624.      }
  1625.    }
  1626.   else
  1627.    { // non-zero
  1628.     // [ind was set earlier]
  1629.     // now determine form
  1630.     if (hadexp)
  1631.      {
  1632.       this.form=MathContext.prototype.SCIENTIFIC;
  1633.       // 1999.06.29 check for overflow
  1634.       mag=(this.exp+this.mant.length)-1; // true exponent in scientific notation
  1635.       if ((mag<this.MinExp)||(mag>this.MaxExp))
  1636.        this.bad("BigDecimal(): ", inchars);
  1637.      }
  1638.    }
  1639.   // say 'BD(c[]): mant[0] mantlen exp ind form:' mant[0] mant.length exp ind form
  1640.   return;
  1641.   }
  1642.  
  1643.  /**
  1644.   * Constructs a <code>BigDecimal</code> object directly from a
  1645.   * <code>double</code>.
  1646.   * <p>
  1647.   * Constructs a <code>BigDecimal</code> which is the exact decimal
  1648.   * representation of the 64-bit signed binary floating point
  1649.   * parameter.
  1650.   * <p>
  1651.   * Note that this constructor it an exact conversion; it does not give
  1652.   * the same result as converting <code>num</code> to a
  1653.   * <code>String</code> using the <code>Double.toString()</code> method
  1654.   * and then using the {@link #BigDecimal(java.lang.String)}
  1655.   * constructor.
  1656.   * To get that result, use the static {@link #valueOf(double)}
  1657.   * method to construct a <code>BigDecimal</code> from a
  1658.   * <code>double</code>.
  1659.   *
  1660.   * @param num The <code>double</code> to be converted.
  1661.   * @throws NumberFormatException if the parameter is infinite or
  1662.   *            not a number.
  1663.   * @stable ICU 2.0
  1664.   */
  1665.  
  1666.  //--public BigDecimal(double num){
  1667.  //-- // 1999.03.06: use exactly the old algorithm
  1668.  //-- // 2000.01.01: note that this constructor does give an exact result,
  1669.  //-- //             so perhaps it should not be deprecated
  1670.  //-- // 2000.06.18: no longer deprecated
  1671.  //-- this((new java.math.BigDecimal(num)).toString());
  1672.  //-- return;}
  1673.  
  1674.  /**
  1675.   * Constructs a <code>BigDecimal</code> object directly from a
  1676.   * <code>int</code>.
  1677.   * <p>
  1678.   * Constructs a <code>BigDecimal</code> which is the exact decimal
  1679.   * representation of the 32-bit signed binary integer parameter.
  1680.   * The <code>BigDecimal</code> will contain only decimal digits,
  1681.   * prefixed with a leading minus sign (hyphen) if the parameter is
  1682.   * negative.
  1683.   * A leading zero will be present only if the parameter is zero.
  1684.   *
  1685.   * @param num The <code>int</code> to be converted.
  1686.   * @stable ICU 2.0
  1687.   */
  1688.  
  1689.  //--public BigDecimal(int num){super();
  1690.  //-- int mun;
  1691.  //-- int i=0;
  1692.  //-- // We fastpath commoners
  1693.  //-- if (num<=9)
  1694.  //--  if (num>=(-9))
  1695.  //--   {singledigit:do{
  1696.  //--    // very common single digit case
  1697.  //--    {/*select*/
  1698.  //--    if (num==0)
  1699.  //--     {
  1700.  //--      mant=ZERO.mant;
  1701.  //--      ind=iszero;
  1702.  //--     }
  1703.  //--    else if (num==1)
  1704.  //--     {
  1705.  //--      mant=ONE.mant;
  1706.  //--      ind=ispos;
  1707.  //--     }
  1708.  //--    else if (num==(-1))
  1709.  //--     {
  1710.  //--      mant=ONE.mant;
  1711.  //--      ind=isneg;
  1712.  //--     }
  1713.  //--    else{
  1714.  //--     {
  1715.  //--      mant=new byte[1];
  1716.  //--      if (num>0)
  1717.  //--       {
  1718.  //--        mant[0]=(byte)num;
  1719.  //--        ind=ispos;
  1720.  //--       }
  1721.  //--      else
  1722.  //--       { // num<-1
  1723.  //--        mant[0]=(byte)((int)-num);
  1724.  //--        ind=isneg;
  1725.  //--       }
  1726.  //--     }
  1727.  //--    }
  1728.  //--    }
  1729.  //--    return;
  1730.  //--   }while(false);}/*singledigit*/
  1731.  //--
  1732.  //-- /* We work on negative numbers so we handle the most negative number */
  1733.  //-- if (num>0)
  1734.  //--  {
  1735.  //--   ind=ispos;
  1736.  //--   num=(int)-num;
  1737.  //--  }
  1738.  //-- else
  1739.  //--  ind=isneg;/* negative */ // [0 case already handled]
  1740.  //-- // [it is quicker, here, to pre-calculate the length with
  1741.  //-- // one loop, then allocate exactly the right length of byte array,
  1742.  //-- // then re-fill it with another loop]
  1743.  //-- mun=num; // working copy
  1744.  //-- {i=9;i:for(;;i--){
  1745.  //--  mun=mun/10;
  1746.  //--  if (mun==0)
  1747.  //--   break i;
  1748.  //--  }
  1749.  //-- }/*i*/
  1750.  //-- // i is the position of the leftmost digit placed
  1751.  //-- mant=new byte[10-i];
  1752.  //-- {i=(10-i)-1;i:for(;;i--){
  1753.  //--  mant[i]=(byte)-(((byte)(num%10)));
  1754.  //--  num=num/10;
  1755.  //--  if (num==0)
  1756.  //--   break i;
  1757.  //--  }
  1758.  //-- }/*i*/
  1759.  //-- return;
  1760.  //-- }
  1761.  
  1762.  /**
  1763.   * Constructs a <code>BigDecimal</code> object directly from a
  1764.   * <code>long</code>.
  1765.   * <p>
  1766.   * Constructs a <code>BigDecimal</code> which is the exact decimal
  1767.   * representation of the 64-bit signed binary integer parameter.
  1768.   * The <code>BigDecimal</code> will contain only decimal digits,
  1769.   * prefixed with a leading minus sign (hyphen) if the parameter is
  1770.   * negative.
  1771.   * A leading zero will be present only if the parameter is zero.
  1772.   *
  1773.   * @param num The <code>long</code> to be converted.
  1774.   * @stable ICU 2.0
  1775.   */
  1776.  
  1777.  //--public BigDecimal(long num){super();
  1778.  //-- long mun;
  1779.  //-- int i=0;
  1780.  //-- // Not really worth fastpathing commoners in this constructor [also,
  1781.  //-- // we use this to construct the static constants].
  1782.  //-- // This is much faster than: this(String.valueOf(num).toCharArray())
  1783.  //-- /* We work on negative num so we handle the most negative number */
  1784.  //-- if (num>0)
  1785.  //--  {
  1786.  //--   ind=ispos;
  1787.  //--   num=(long)-num;
  1788.  //--  }
  1789.  //-- else
  1790.  //--  if (num==0)
  1791.  //--   ind=iszero;
  1792.  //--  else
  1793.  //--   ind=isneg;/* negative */
  1794.  //-- mun=num;
  1795.  //-- {i=18;i:for(;;i--){
  1796.  //--  mun=mun/10;
  1797.  //--  if (mun==0)
  1798.  //--   break i;
  1799.  //--  }
  1800.  //-- }/*i*/
  1801.  //-- // i is the position of the leftmost digit placed
  1802.  //-- mant=new byte[19-i];
  1803.  //-- {i=(19-i)-1;i:for(;;i--){
  1804.  //--  mant[i]=(byte)-(((byte)(num%10)));
  1805.  //--  num=num/10;
  1806.  //--  if (num==0)
  1807.  //--   break i;
  1808.  //--  }
  1809.  //-- }/*i*/
  1810.  //-- return;
  1811.  //-- }
  1812.  
  1813.  /**
  1814.   * Constructs a <code>BigDecimal</code> object from a <code>String</code>.
  1815.   * <p>
  1816.   * Constructs a <code>BigDecimal</code> from the parameter, which must
  1817.   * not be <code>null</code> and must represent a valid <i>number</i>,
  1818.   * as described formally in the documentation referred to
  1819.   * {@link BigDecimal above}.
  1820.   * <p>
  1821.   * In summary, numbers in <code>String</code> form must have at least
  1822.   * one digit, may have a leading sign, may have a decimal point, and
  1823.   * exponential notation may be used.  They follow conventional syntax,
  1824.   * and may not contain blanks.
  1825.   * <p>
  1826.   * Some valid strings from which a <code>BigDecimal</code> might
  1827.   * be constructed are:
  1828.   * <pre>
  1829.   *       "0"         -- Zero
  1830.   *      "12"         -- A whole number
  1831.   *     "-76"         -- A signed whole number
  1832.   *      "12.70"      -- Some decimal places
  1833.   *     "+0.003"      -- Plus sign is allowed
  1834.   *      "17."        -- The same as 17
  1835.   *        ".5"       -- The same as 0.5
  1836.   *      "4E+9"       -- Exponential notation
  1837.   *       "0.73e-7"   -- Exponential notation
  1838.   * </pre>
  1839.   * <p>
  1840.   * (Exponential notation means that the number includes an optional
  1841.   * sign and a power of ten following an '</code>E</code>' that
  1842.   * indicates how the decimal point will be shifted.  Thus the
  1843.   * <code>"4E+9"</code> above is just a short way of writing
  1844.   * <code>4000000000</code>, and the <code>"0.73e-7"</code> is short
  1845.   * for <code>0.000000073</code>.)
  1846.   * <p>
  1847.   * The <code>BigDecimal</code> constructed from the String is in a
  1848.   * standard form, with no blanks, as though the
  1849.   * {@link #add(BigDecimal)} method had been used to add zero to the
  1850.   * number with unlimited precision.
  1851.   * If the string uses exponential notation (that is, includes an
  1852.   * <code>e</code> or an <code>E</code>), then the
  1853.   * <code>BigDecimal</code> number will be expressed in scientific
  1854.   * notation (where the power of ten is adjusted so there is a single
  1855.   * non-zero digit to the left of the decimal point); in this case if
  1856.   * the number is zero then it will be expressed as the single digit 0,
  1857.   * and if non-zero it will have an exponent unless that exponent would
  1858.   * be 0.  The exponent must fit in nine digits both before and after it
  1859.   * is expressed in scientific notation.
  1860.   * <p>
  1861.   * Any digits in the parameter must be decimal; that is,
  1862.   * <code>Character.digit(c, 10)</code> (where </code>c</code> is the
  1863.   * character in question) would not return -1.
  1864.   *
  1865.   * @param string The <code>String</code> to be converted.
  1866.   * @throws NumberFormatException if the parameter is not a valid
  1867.   * number.
  1868.   * @stable ICU 2.0
  1869.   */
  1870.  
  1871.  //--public BigDecimal(java.lang.String string){
  1872.  //-- this(string.toCharArray(),0,string.length());
  1873.  //-- return;}
  1874.  
  1875.  /* <sgml> Make a default BigDecimal object for local use. </sgml> */
  1876.  
  1877.  //--private BigDecimal(){super();
  1878.  //-- return;
  1879.  //-- }
  1880.  
  1881.  /* ---------------------------------------------------------------- */
  1882.  /* Operator methods [methods which take a context parameter]        */
  1883.  /* ---------------------------------------------------------------- */
  1884.  
  1885.  /**
  1886.   * Returns a plain <code>BigDecimal</code> whose value is the absolute
  1887.   * value of this <code>BigDecimal</code>.
  1888.   * <p>
  1889.   * The same as {@link #abs(MathContext)}, where the context is
  1890.   * <code>new MathContext(0, MathContext.PLAIN)</code>.
  1891.   * <p>
  1892.   * The length of the decimal part (the scale) of the result will
  1893.   * be <code>this.scale()</code>
  1894.   *
  1895.   * @return A <code>BigDecimal</code> whose value is the absolute
  1896.   *         value of this <code>BigDecimal</code>.
  1897.   * @stable ICU 2.0
  1898.   */
  1899.  
  1900.  //--public com.ibm.icu.math.BigDecimal abs(){
  1901.  //- return this.abs(plainMC);
  1902.  //- }
  1903.  
  1904.  /**
  1905.   * Returns a <code>BigDecimal</code> whose value is the absolute value
  1906.   * of this <code>BigDecimal</code>.
  1907.   * <p>
  1908.   * If the current object is zero or positive, then the same result as
  1909.   * invoking the {@link #plus(MathContext)} method with the same
  1910.   * parameter is returned.
  1911.   * Otherwise, the same result as invoking the
  1912.   * {@link #negate(MathContext)} method with the same parameter is
  1913.   * returned.
  1914.   *
  1915.   * @param  set The <code>MathContext</code> arithmetic settings.
  1916.   * @return     A <code>BigDecimal</code> whose value is the absolute
  1917.   *             value of this <code>BigDecimal</code>.
  1918.   * @stable ICU 2.0
  1919.   */
  1920.  
  1921.  //--public com.ibm.icu.math.BigDecimal abs(com.ibm.icu.math.MathContext set){
  1922.  function abs() {
  1923.   var set;
  1924.   if (abs.arguments.length == 1)
  1925.    {
  1926.     set = abs.arguments[0];
  1927.    }
  1928.   else if (abs.arguments.length == 0)
  1929.    {
  1930.     set = this.plainMC;
  1931.    }
  1932.   else
  1933.    {
  1934.     throw "abs(): " + abs.arguments.length + " arguments given; expected 0 or 1";
  1935.    }
  1936.   if (this.ind==this.isneg)
  1937.    return this.negate(set);
  1938.   return this.plus(set);
  1939.   }
  1940.  
  1941.  /**
  1942.   * Returns a plain <code>BigDecimal</code> whose value is
  1943.   * <code>this+rhs</code>, using fixed point arithmetic.
  1944.   * <p>
  1945.   * The same as {@link #add(BigDecimal, MathContext)},
  1946.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  1947.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  1948.   * <p>
  1949.   * The length of the decimal part (the scale) of the result will be
  1950.   * the maximum of the scales of the two operands.
  1951.   *
  1952.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  1953.   *             the addition.
  1954.   * @return     A <code>BigDecimal</code> whose value is
  1955.   *             <code>this+rhs</code>, using fixed point arithmetic.
  1956.   * @stable ICU 2.0
  1957.   */
  1958.  
  1959.  //--public com.ibm.icu.math.BigDecimal add(com.ibm.icu.math.BigDecimal rhs){
  1960.  //-- return this.add(rhs,plainMC);
  1961.  //-- }
  1962.  
  1963.  /**
  1964.   * Returns a <code>BigDecimal</code> whose value is <code>this+rhs</code>.
  1965.   * <p>
  1966.   * Implements the addition (<b><code>+</code></b>) operator
  1967.   * (as defined in the decimal documentation, see {@link BigDecimal
  1968.   * class header}),
  1969.   * and returns the result as a <code>BigDecimal</code> object.
  1970.   *
  1971.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  1972.   *             the addition.
  1973.   * @param  set The <code>MathContext</code> arithmetic settings.
  1974.   * @return     A <code>BigDecimal</code> whose value is
  1975.   *             <code>this+rhs</code>.
  1976.   * @stable ICU 2.0
  1977.   */
  1978.  
  1979.  //--public com.ibm.icu.math.BigDecimal add(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  1980.  function add() {
  1981.   var set;
  1982.   if (add.arguments.length == 2)
  1983.    {
  1984.     set = add.arguments[1];
  1985.    }
  1986.   else if (add.arguments.length == 1)
  1987.    {
  1988.     set = this.plainMC;
  1989.    }
  1990.   else
  1991.    {
  1992.     throw "add(): " + add.arguments.length + " arguments given; expected 1 or 2";
  1993.    }
  1994.   var rhs = add.arguments[0];
  1995.   //--com.ibm.icu.math.BigDecimal lhs;
  1996.   var lhs;
  1997.   //--int reqdig;
  1998.   var reqdig;
  1999.   //--com.ibm.icu.math.BigDecimal res;
  2000.   var res;
  2001.   //--byte usel[];
  2002.   var usel;
  2003.   //--int usellen;
  2004.   var usellen;
  2005.   //--byte user[];
  2006.   var user;
  2007.   //--int userlen;
  2008.   var userlen;
  2009.   //--int newlen=0;
  2010.   var newlen=0;
  2011.   //--int tlen=0;
  2012.   var tlen=0;
  2013.   //--int mult=0;
  2014.   var mult=0;
  2015.   //--byte t[]=null;
  2016.   var t=null;
  2017.   //--int ia=0;
  2018.   var ia=0;
  2019.   //--int ib=0;
  2020.   var ib=0;
  2021.   //--int ea=0;
  2022.   var ea=0;
  2023.   //int eb=0;
  2024.   var eb=0;
  2025.   //byte ca=0;
  2026.   var ca=0;
  2027.   //--byte cb=0;
  2028.   var cb=0;
  2029.   /* determine requested digits and form */
  2030.   if (set.lostDigits)
  2031.    this.checkdigits(rhs,set.digits);
  2032.   lhs=this; // name for clarity and proxy
  2033.  
  2034.   /* Quick exit for add floating 0 */
  2035.   // plus() will optimize to return same object if possible
  2036.   if (lhs.ind==0)
  2037.    if (set.form!=MathContext.prototype.PLAIN)
  2038.     return rhs.plus(set);
  2039.   if (rhs.ind==0)
  2040.    if (set.form!=MathContext.prototype.PLAIN)
  2041.     return lhs.plus(set);
  2042.  
  2043.   /* Prepare numbers (round, unless unlimited precision) */
  2044.   reqdig=set.digits; // local copy (heavily used)
  2045.   if (reqdig>0)
  2046.    {
  2047.     if (lhs.mant.length>reqdig)
  2048.      lhs=this.clone(lhs).round(set);
  2049.     if (rhs.mant.length>reqdig)
  2050.      rhs=this.clone(rhs).round(set);
  2051.    // [we could reuse the new LHS for result in this case]
  2052.    }
  2053.  
  2054.   res=new BigDecimal(); // build result here
  2055.  
  2056.   /* Now see how much we have to pad or truncate lhs or rhs in order
  2057.      to align the numbers.  If one number is much larger than the
  2058.      other, then the smaller cannot affect the answer [but we may
  2059.      still need to pad with up to DIGITS trailing zeros]. */
  2060.   // Note sign may be 0 if digits (reqdig) is 0
  2061.   // usel and user will be the byte arrays passed to the adder; we'll
  2062.   // use them on all paths except quick exits
  2063.   usel=lhs.mant;
  2064.   usellen=lhs.mant.length;
  2065.   user=rhs.mant;
  2066.   userlen=rhs.mant.length;
  2067.   {padder:do{/*select*/
  2068.   if (lhs.exp==rhs.exp)
  2069.    {/* no padding needed */
  2070.     // This is the most common, and fastest, path
  2071.     res.exp=lhs.exp;
  2072.    }
  2073.   else if (lhs.exp>rhs.exp)
  2074.    { // need to pad lhs and/or truncate rhs
  2075.     newlen=(usellen+lhs.exp)-rhs.exp;
  2076.     /* If, after pad, lhs would be longer than rhs by digits+1 or
  2077.        more (and digits>0) then rhs cannot affect answer, so we only
  2078.        need to pad up to a length of DIGITS+1. */
  2079.     if (newlen>=((userlen+reqdig)+1))
  2080.      if (reqdig>0)
  2081.       {
  2082.        // LHS is sufficient
  2083.        res.mant=usel;
  2084.        res.exp=lhs.exp;
  2085.        res.ind=lhs.ind;
  2086.        if (usellen<reqdig)
  2087.         { // need 0 padding
  2088.          res.mant=this.extend(lhs.mant,reqdig);
  2089.          res.exp=res.exp-((reqdig-usellen));
  2090.         }
  2091.        return res.finish(set,false);
  2092.       }
  2093.     // RHS may affect result
  2094.     res.exp=rhs.exp; // expected final exponent
  2095.     if (newlen>(reqdig+1))
  2096.      if (reqdig>0)
  2097.       {
  2098.        // LHS will be max; RHS truncated
  2099.        tlen=(newlen-reqdig)-1; // truncation length
  2100.        userlen=userlen-tlen;
  2101.        res.exp=res.exp+tlen;
  2102.        newlen=reqdig+1;
  2103.       }
  2104.     if (newlen>usellen)
  2105.      usellen=newlen; // need to pad LHS
  2106.    }
  2107.   else{ // need to pad rhs and/or truncate lhs
  2108.    newlen=(userlen+rhs.exp)-lhs.exp;
  2109.    if (newlen>=((usellen+reqdig)+1))
  2110.     if (reqdig>0)
  2111.      {
  2112.       // RHS is sufficient
  2113.       res.mant=user;
  2114.       res.exp=rhs.exp;
  2115.       res.ind=rhs.ind;
  2116.       if (userlen<reqdig)
  2117.        { // need 0 padding
  2118.         res.mant=this.extend(rhs.mant,reqdig);
  2119.         res.exp=res.exp-((reqdig-userlen));
  2120.        }
  2121.       return res.finish(set,false);
  2122.      }
  2123.    // LHS may affect result
  2124.    res.exp=lhs.exp; // expected final exponent
  2125.    if (newlen>(reqdig+1))
  2126.     if (reqdig>0)
  2127.      {
  2128.       // RHS will be max; LHS truncated
  2129.       tlen=(newlen-reqdig)-1; // truncation length
  2130.       usellen=usellen-tlen;
  2131.       res.exp=res.exp+tlen;
  2132.       newlen=reqdig+1;
  2133.      }
  2134.    if (newlen>userlen)
  2135.     userlen=newlen; // need to pad RHS
  2136.   }
  2137.   }while(false);}/*padder*/
  2138.  
  2139.   /* OK, we have aligned mantissas.  Now add or subtract. */
  2140.   // 1998.06.27 Sign may now be 0 [e.g., 0.000] .. treat as positive
  2141.   // 1999.05.27 Allow for 00 on lhs [is not larger than 2 on rhs]
  2142.   // 1999.07.10 Allow for 00 on rhs [is not larger than 2 on rhs]
  2143.   if (lhs.ind==this.iszero)
  2144.    res.ind=this.ispos;
  2145.   else
  2146.    res.ind=lhs.ind; // likely sign, all paths
  2147.   if (((lhs.ind==this.isneg)?1:0)==((rhs.ind==this.isneg)?1:0))  // same sign, 0 non-negative
  2148.    mult=1;
  2149.   else
  2150.    {signdiff:do{ // different signs, so subtraction is needed
  2151.     mult=-1; // will cause subtract
  2152.     /* Before we can subtract we must determine which is the larger,
  2153.        as our add/subtract routine only handles non-negative results
  2154.        so we may need to swap the operands. */
  2155.     {swaptest:do{/*select*/
  2156.     if (rhs.ind==this.iszero)
  2157.      {} // original A bigger
  2158.     else if ((usellen<userlen)||(lhs.ind==this.iszero))
  2159.      { // original B bigger
  2160.       t=usel;
  2161.       usel=user;
  2162.       user=t; // swap
  2163.       tlen=usellen;
  2164.       usellen=userlen;
  2165.       userlen=tlen; // ..
  2166.       res.ind=-res.ind; // and set sign
  2167.      }
  2168.     else if (usellen>userlen)
  2169.      {} // original A bigger
  2170.     else{
  2171.      {/* logical lengths the same */ // need compare
  2172.       /* may still need to swap: compare the strings */
  2173.       ia=0;
  2174.       ib=0;
  2175.       ea=usel.length-1;
  2176.       eb=user.length-1;
  2177.       {compare:for(;;){
  2178.        if (ia<=ea)
  2179.         ca=usel[ia];
  2180.        else
  2181.         {
  2182.          if (ib>eb)
  2183.           {/* identical */
  2184.            if (set.form!=MathContext.prototype.PLAIN)
  2185.             return this.ZERO;
  2186.            // [if PLAIN we must do the subtract, in case of 0.000 results]
  2187.            break compare;
  2188.           }
  2189.          ca=0;
  2190.         }
  2191.        if (ib<=eb)
  2192.         cb=user[ib];
  2193.        else
  2194.         cb=0;
  2195.        if (ca!=cb)
  2196.         {
  2197.          if (ca<cb)
  2198.           {/* swap needed */
  2199.            t=usel;
  2200.            usel=user;
  2201.            user=t; // swap
  2202.            tlen=usellen;
  2203.            usellen=userlen;
  2204.            userlen=tlen; // ..
  2205.            res.ind=-res.ind;
  2206.           }
  2207.          break compare;
  2208.         }
  2209.        /* mantissas the same, so far */
  2210.        ia++;
  2211.        ib++;
  2212.        }
  2213.       }/*compare*/
  2214.      } // lengths the same
  2215.     }
  2216.     }while(false);}/*swaptest*/
  2217.    }while(false);}/*signdiff*/
  2218.  
  2219.   /* here, A is > B if subtracting */
  2220.   // add [A+B*1] or subtract [A+(B*-1)]
  2221.   res.mant=this.byteaddsub(usel,usellen,user,userlen,mult,false);
  2222.   // [reuse possible only after chop; accounting makes not worthwhile]
  2223.  
  2224.   // Finish() rounds before stripping leading 0's, then sets form, etc.
  2225.   return res.finish(set,false);
  2226.   }
  2227.  
  2228.  /**
  2229.   * Compares this <code>BigDecimal</code> to another, using unlimited
  2230.   * precision.
  2231.   * <p>
  2232.   * The same as {@link #compareTo(BigDecimal, MathContext)},
  2233.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2234.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  2235.   *
  2236.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2237.   *             the comparison.
  2238.   * @return     An <code>int</code> whose value is -1, 0, or 1 as
  2239.   *             <code>this</code> is numerically less than, equal to,
  2240.   *             or greater than <code>rhs</code>.
  2241.   * @see    #compareTo(Object)
  2242.   * @stable ICU 2.0
  2243.   */
  2244.  
  2245.  //--public int compareTo(com.ibm.icu.math.BigDecimal rhs){
  2246.  //-- return this.compareTo(rhs,plainMC);
  2247.  //-- }
  2248.  
  2249.  /**
  2250.   * Compares this <code>BigDecimal</code> to another.
  2251.   * <p>
  2252.   * Implements numeric comparison,
  2253.   * (as defined in the decimal documentation, see {@link BigDecimal
  2254.   * class header}),
  2255.   * and returns a result of type <code>int</code>.
  2256.   * <p>
  2257.   * The result will be:
  2258.   * <table cellpadding=2><tr>
  2259.   * <td align=right><b>-1</b></td>
  2260.   * <td>if the current object is less than the first parameter</td>
  2261.   * </tr><tr>
  2262.   * <td align=right><b>0</b></td>
  2263.   * <td>if the current object is equal to the first parameter</td>
  2264.   * </tr><tr>
  2265.   * <td align=right><b>1</b></td>
  2266.   * <td>if the current object is greater than the first parameter.</td>
  2267.   * </tr></table>
  2268.   * <p>
  2269.   * A {@link #compareTo(Object)} method is also provided.
  2270.   *
  2271.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2272.   *             the comparison.
  2273.   * @param  set The <code>MathContext</code> arithmetic settings.
  2274.   * @return     An <code>int</code> whose value is -1, 0, or 1 as
  2275.   *             <code>this</code> is numerically less than, equal to,
  2276.   *             or greater than <code>rhs</code>.
  2277.   * @see    #compareTo(Object)
  2278.   * @stable ICU 2.0
  2279.   */
  2280.  
  2281.  //public int compareTo(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  2282.  function compareTo() {
  2283.   var set;
  2284.   if (compareTo.arguments.length == 2)
  2285.    {
  2286.     set = compareTo.arguments[1];
  2287.    }
  2288.   else if (compareTo.arguments.length == 1)
  2289.    {
  2290.     set = this.plainMC;
  2291.    }
  2292.   else
  2293.    {
  2294.     throw "compareTo(): " + compareTo.arguments.length + " arguments given; expected 1 or 2";
  2295.    }
  2296.   var rhs = compareTo.arguments[0];
  2297.   //--int thislength=0;
  2298.   var thislength=0;
  2299.   //--int i=0;
  2300.   var i=0;
  2301.   //--com.ibm.icu.math.BigDecimal newrhs;
  2302.   var newrhs;
  2303.   // rhs=null will raise NullPointerException, as per Comparable interface
  2304.   if (set.lostDigits)
  2305.    this.checkdigits(rhs,set.digits);
  2306.   // [add will recheck in slowpath cases .. but would report -rhs]
  2307.   if ((this.ind==rhs.ind)&&(this.exp==rhs.exp))
  2308.    {
  2309.     /* sign & exponent the same [very common] */
  2310.     thislength=this.mant.length;
  2311.     if (thislength<rhs.mant.length)
  2312.      return -this.ind;
  2313.     if (thislength>rhs.mant.length)
  2314.      return this.ind;
  2315.     /* lengths are the same; we can do a straight mantissa compare
  2316.        unless maybe rounding [rounding is very unusual] */
  2317.     if ((thislength<=set.digits)||(set.digits==0))
  2318.      {
  2319.       {var $6=thislength;i=0;i:for(;$6>0;$6--,i++){
  2320.        if (this.mant[i]<rhs.mant[i])
  2321.         return -this.ind;
  2322.        if (this.mant[i]>rhs.mant[i])
  2323.         return this.ind;
  2324.        }
  2325.       }/*i*/
  2326.       return 0; // identical
  2327.      }
  2328.    /* drop through for full comparison */
  2329.    }
  2330.   else
  2331.    {
  2332.     /* More fastpaths possible */
  2333.     if (this.ind<rhs.ind)
  2334.      return -1;
  2335.     if (this.ind>rhs.ind)
  2336.      return 1;
  2337.    }
  2338.   /* carry out a subtract to make the comparison */
  2339.   newrhs=this.clone(rhs); // safe copy
  2340.   newrhs.ind=-newrhs.ind; // prepare to subtract
  2341.   return this.add(newrhs,set).ind; // add, and return sign of result
  2342.   }
  2343.  
  2344.  /**
  2345.   * Returns a plain <code>BigDecimal</code> whose value is
  2346.   * <code>this/rhs</code>, using fixed point arithmetic.
  2347.   * <p>
  2348.   * The same as {@link #divide(BigDecimal, int)},
  2349.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2350.   * and the rounding mode is {@link MathContext#ROUND_HALF_UP}.
  2351.   *
  2352.   * The length of the decimal part (the scale) of the result will be
  2353.   * the same as the scale of the current object, if the latter were
  2354.   * formatted without exponential notation.
  2355.   *
  2356.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2357.   *             the division.
  2358.   * @return     A plain <code>BigDecimal</code> whose value is
  2359.   *             <code>this/rhs</code>, using fixed point arithmetic.
  2360.   * @throws ArithmeticException if <code>rhs</code> is zero.
  2361.   * @stable ICU 2.0
  2362.   */
  2363.  
  2364.  //--public com.ibm.icu.math.BigDecimal divide(com.ibm.icu.math.BigDecimal rhs){
  2365.  //-- return this.dodivide('D',rhs,plainMC,-1);
  2366.  //-- }
  2367.  
  2368.  /**
  2369.   * Returns a plain <code>BigDecimal</code> whose value is
  2370.   * <code>this/rhs</code>, using fixed point arithmetic and a
  2371.   * rounding mode.
  2372.   * <p>
  2373.   * The same as {@link #divide(BigDecimal, int, int)},
  2374.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2375.   * and the second parameter is <code>this.scale()</code>, and
  2376.   * the third is <code>round</code>.
  2377.   * <p>
  2378.   * The length of the decimal part (the scale) of the result will
  2379.   * therefore be the same as the scale of the current object, if the
  2380.   * latter were formatted without exponential notation.
  2381.   * <p>
  2382.   * @param  rhs   The <code>BigDecimal</code> for the right hand side of
  2383.   *               the division.
  2384.   * @param  round The <code>int</code> rounding mode to be used for
  2385.   *               the division (see the {@link MathContext} class).
  2386.   * @return       A plain <code>BigDecimal</code> whose value is
  2387.   *               <code>this/rhs</code>, using fixed point arithmetic
  2388.   *               and the specified rounding mode.
  2389.   * @throws IllegalArgumentException if <code>round</code> is not a
  2390.   *               valid rounding mode.
  2391.   * @throws ArithmeticException if <code>rhs</code> is zero.
  2392.   * @throws ArithmeticException if <code>round</code> is {@link
  2393.   *               MathContext#ROUND_UNNECESSARY} and
  2394.   *               <code>this.scale()</code> is insufficient to
  2395.   *               represent the result exactly.
  2396.   * @stable ICU 2.0
  2397.   */
  2398.  
  2399.  //--public com.ibm.icu.math.BigDecimal divide(com.ibm.icu.math.BigDecimal rhs,int round){
  2400.  //-- com.ibm.icu.math.MathContext set;
  2401.  //-- set=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,round); // [checks round, too]
  2402.  //-- return this.dodivide('D',rhs,set,-1); // take scale from LHS
  2403.  //-- }
  2404.  
  2405.  /**
  2406.   * Returns a plain <code>BigDecimal</code> whose value is
  2407.   * <code>this/rhs</code>, using fixed point arithmetic and a
  2408.   * given scale and rounding mode.
  2409.   * <p>
  2410.   * The same as {@link #divide(BigDecimal, MathContext)},
  2411.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2412.   * <code>new MathContext(0, MathContext.PLAIN, false, round)</code>,
  2413.   * except that the length of the decimal part (the scale) to be used
  2414.   * for the result is explicit rather than being taken from
  2415.   * <code>this</code>.
  2416.   * <p>
  2417.   * The length of the decimal part (the scale) of the result will be
  2418.   * the same as the scale of the current object, if the latter were
  2419.   * formatted without exponential notation.
  2420.   * <p>
  2421.   * @param  rhs   The <code>BigDecimal</code> for the right hand side of
  2422.   *               the division.
  2423.   * @param  scale The <code>int</code> scale to be used for the result.
  2424.   * @param  round The <code>int</code> rounding mode to be used for
  2425.   *               the division (see the {@link MathContext} class).
  2426.   * @return       A plain <code>BigDecimal</code> whose value is
  2427.   *               <code>this/rhs</code>, using fixed point arithmetic
  2428.   *               and the specified rounding mode.
  2429.   * @throws IllegalArgumentException if <code>round</code> is not a
  2430.   *               valid rounding mode.
  2431.   * @throws ArithmeticException if <code>rhs</code> is zero.
  2432.   * @throws ArithmeticException if <code>scale</code> is negative.
  2433.   * @throws ArithmeticException if <code>round</code> is {@link
  2434.   *               MathContext#ROUND_UNNECESSARY} and <code>scale</code>
  2435.   *               is insufficient to represent the result exactly.
  2436.   * @stable ICU 2.0
  2437.   */
  2438.  
  2439.  //--public com.ibm.icu.math.BigDecimal divide(com.ibm.icu.math.BigDecimal rhs,int scale,int round){
  2440.  //-- com.ibm.icu.math.MathContext set;
  2441.  //-- if (scale<0)
  2442.  //--  throw new java.lang.ArithmeticException("Negative scale:"+" "+scale);
  2443.  //-- set=new com.ibm.icu.math.MathContext(0,com.ibm.icu.math.MathContext.PLAIN,false,round); // [checks round]
  2444.  //-- return this.dodivide('D',rhs,set,scale);
  2445.  //-- }
  2446.  
  2447.  /**
  2448.   * Returns a <code>BigDecimal</code> whose value is <code>this/rhs</code>.
  2449.   * <p>
  2450.   * Implements the division (<b><code>/</code></b>) operator
  2451.   * (as defined in the decimal documentation, see {@link BigDecimal
  2452.   * class header}),
  2453.   * and returns the result as a <code>BigDecimal</code> object.
  2454.   *
  2455.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2456.   *             the division.
  2457.   * @param  set The <code>MathContext</code> arithmetic settings.
  2458.   * @return     A <code>BigDecimal</code> whose value is
  2459.   *             <code>this/rhs</code>.
  2460.   * @throws ArithmeticException if <code>rhs</code> is zero.
  2461.   * @stable ICU 2.0
  2462.   */
  2463.  
  2464.  //--public com.ibm.icu.math.BigDecimal divide(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  2465.  function divide() {
  2466.   var set;
  2467.   var scale = -1;
  2468.   if (divide.arguments.length == 2)
  2469.    {
  2470.     if (typeof divide.arguments[1] == 'number')
  2471.      {
  2472.       set=new MathContext(0,MathContext.prototype.PLAIN,false,divide.arguments[1]); // [checks round, too]
  2473.      }
  2474.     else
  2475.      {
  2476.       set = divide.arguments[1];
  2477.      }
  2478.    }
  2479.   else if (divide.arguments.length == 3)
  2480.    {
  2481.     scale = divide.arguments[1];
  2482.     if (scale<0)
  2483.      throw "divide(): Negative scale: "+scale;
  2484.     set=new MathContext(0,MathContext.prototype.PLAIN,false,divide.arguments[2]); // [checks round]
  2485.    }
  2486.   else if (divide.arguments.length == 1)
  2487.    {
  2488.     set = this.plainMC;
  2489.    }
  2490.   else
  2491.    {
  2492.     throw "divide(): " + divide.arguments.length + " arguments given; expected between 1 and 3";
  2493.    }
  2494.   var rhs = divide.arguments[0];
  2495.   return this.dodivide('D',rhs,set,scale);
  2496.   }
  2497.  
  2498.  /**
  2499.   * Returns a plain <code>BigDecimal</code> whose value is the integer
  2500.   * part of <code>this/rhs</code>.
  2501.   * <p>
  2502.   * The same as {@link #divideInteger(BigDecimal, MathContext)},
  2503.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2504.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  2505.   *
  2506.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2507.   *             the integer division.
  2508.   * @return     A <code>BigDecimal</code> whose value is the integer
  2509.   *             part of <code>this/rhs</code>.
  2510.   * @throws ArithmeticException if <code>rhs</code> is zero.
  2511.   * @stable ICU 2.0
  2512.   */
  2513.  
  2514.  //--public com.ibm.icu.math.BigDecimal divideInteger(com.ibm.icu.math.BigDecimal rhs){
  2515.  //-- // scale 0 to drop .000 when plain
  2516.  //-- return this.dodivide('I',rhs,plainMC,0);
  2517.  //-- }
  2518.  
  2519.  /**
  2520.   * Returns a <code>BigDecimal</code> whose value is the integer
  2521.   * part of <code>this/rhs</code>.
  2522.   * <p>
  2523.   * Implements the integer division operator
  2524.   * (as defined in the decimal documentation, see {@link BigDecimal
  2525.   * class header}),
  2526.   * and returns the result as a <code>BigDecimal</code> object.
  2527.   *
  2528.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2529.   *             the integer division.
  2530.   * @param  set The <code>MathContext</code> arithmetic settings.
  2531.   * @return     A <code>BigDecimal</code> whose value is the integer
  2532.   *             part of <code>this/rhs</code>.
  2533.   * @throws ArithmeticException if <code>rhs</code> is zero.
  2534.   * @throws ArithmeticException if the result will not fit in the
  2535.   *             number of digits specified for the context.
  2536.   * @stable ICU 2.0
  2537.   */
  2538.  
  2539.  //--public com.ibm.icu.math.BigDecimal divideInteger(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  2540.  function divideInteger() {
  2541.   var set;
  2542.   if (divideInteger.arguments.length == 2)
  2543.    {
  2544.     set = divideInteger.arguments[1];
  2545.    }
  2546.   else if (divideInteger.arguments.length == 1)
  2547.    {
  2548.     set = this.plainMC;
  2549.    }
  2550.   else
  2551.    {
  2552.     throw "divideInteger(): " + divideInteger.arguments.length + " arguments given; expected 1 or 2";
  2553.    }
  2554.   var rhs = divideInteger.arguments[0];
  2555.   // scale 0 to drop .000 when plain
  2556.   return this.dodivide('I',rhs,set,0);
  2557.   }
  2558.  
  2559.  /**
  2560.   * Returns a plain <code>BigDecimal</code> whose value is
  2561.   * the maximum of <code>this</code> and <code>rhs</code>.
  2562.   * <p>
  2563.   * The same as {@link #max(BigDecimal, MathContext)},
  2564.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2565.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  2566.   *
  2567.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2568.   *             the comparison.
  2569.   * @return     A <code>BigDecimal</code> whose value is
  2570.   *             the maximum of <code>this</code> and <code>rhs</code>.
  2571.   * @stable ICU 2.0
  2572.   */
  2573.  
  2574.  //--public com.ibm.icu.math.BigDecimal max(com.ibm.icu.math.BigDecimal rhs){
  2575.  //-- return this.max(rhs,plainMC);
  2576.  //-- }
  2577.  
  2578.  /**
  2579.   * Returns a <code>BigDecimal</code> whose value is
  2580.   * the maximum of <code>this</code> and <code>rhs</code>.
  2581.   * <p>
  2582.   * Returns the larger of the current object and the first parameter.
  2583.   * <p>
  2584.   * If calling the {@link #compareTo(BigDecimal, MathContext)} method
  2585.   * with the same parameters would return <code>1</code> or
  2586.   * <code>0</code>, then the result of calling the
  2587.   * {@link #plus(MathContext)} method on the current object (using the
  2588.   * same <code>MathContext</code> parameter) is returned.
  2589.   * Otherwise, the result of calling the {@link #plus(MathContext)}
  2590.   * method on the first parameter object (using the same
  2591.   * <code>MathContext</code> parameter) is returned.
  2592.   *
  2593.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2594.   *             the comparison.
  2595.   * @param  set The <code>MathContext</code> arithmetic settings.
  2596.   * @return     A <code>BigDecimal</code> whose value is
  2597.   *             the maximum of <code>this</code> and <code>rhs</code>.
  2598.   * @stable ICU 2.0
  2599.   */
  2600.  
  2601.  //--public com.ibm.icu.math.BigDecimal max(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  2602.  function max() {
  2603.   var set;
  2604.   if (max.arguments.length == 2)
  2605.    {
  2606.     set = max.arguments[1];
  2607.    }
  2608.   else if (max.arguments.length == 1)
  2609.    {
  2610.     set = this.plainMC;
  2611.    }
  2612.   else
  2613.    {
  2614.     throw "max(): " + max.arguments.length + " arguments given; expected 1 or 2";
  2615.    }
  2616.   var rhs = max.arguments[0];
  2617.   if ((this.compareTo(rhs,set))>=0)
  2618.    return this.plus(set);
  2619.   else
  2620.    return rhs.plus(set);
  2621.   }
  2622.  
  2623.  /**
  2624.   * Returns a plain <code>BigDecimal</code> whose value is
  2625.   * the minimum of <code>this</code> and <code>rhs</code>.
  2626.   * <p>
  2627.   * The same as {@link #min(BigDecimal, MathContext)},
  2628.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2629.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  2630.   *
  2631.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2632.   *             the comparison.
  2633.   * @return     A <code>BigDecimal</code> whose value is
  2634.   *             the minimum of <code>this</code> and <code>rhs</code>.
  2635.   * @stable ICU 2.0
  2636.   */
  2637.  
  2638.  //--public com.ibm.icu.math.BigDecimal min(com.ibm.icu.math.BigDecimal rhs){
  2639.  //-- return this.min(rhs,plainMC);
  2640.  //-- }
  2641.  
  2642.  /**
  2643.   * Returns a <code>BigDecimal</code> whose value is
  2644.   * the minimum of <code>this</code> and <code>rhs</code>.
  2645.   * <p>
  2646.   * Returns the smaller of the current object and the first parameter.
  2647.   * <p>
  2648.   * If calling the {@link #compareTo(BigDecimal, MathContext)} method
  2649.   * with the same parameters would return <code>-1</code> or
  2650.   * <code>0</code>, then the result of calling the
  2651.   * {@link #plus(MathContext)} method on the current object (using the
  2652.   * same <code>MathContext</code> parameter) is returned.
  2653.   * Otherwise, the result of calling the {@link #plus(MathContext)}
  2654.   * method on the first parameter object (using the same
  2655.   * <code>MathContext</code> parameter) is returned.
  2656.   *
  2657.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2658.   *             the comparison.
  2659.   * @param  set The <code>MathContext</code> arithmetic settings.
  2660.   * @return     A <code>BigDecimal</code> whose value is
  2661.   *             the minimum of <code>this</code> and <code>rhs</code>.
  2662.   * @stable ICU 2.0
  2663.   */
  2664.  
  2665.  //--public com.ibm.icu.math.BigDecimal min(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  2666.  function min() {
  2667.   var set;
  2668.   if (min.arguments.length == 2)
  2669.    {
  2670.     set = min.arguments[1];
  2671.    }
  2672.   else if (min.arguments.length == 1)
  2673.    {
  2674.     set = this.plainMC;
  2675.    }
  2676.   else
  2677.    {
  2678.     throw "min(): " + min.arguments.length + " arguments given; expected 1 or 2";
  2679.    }
  2680.   var rhs = min.arguments[0];
  2681.   if ((this.compareTo(rhs,set))<=0)
  2682.    return this.plus(set);
  2683.   else
  2684.    return rhs.plus(set);
  2685.   }
  2686.  
  2687.  /**
  2688.   * Returns a plain <code>BigDecimal</code> whose value is
  2689.   * <code>this*rhs</code>, using fixed point arithmetic.
  2690.   * <p>
  2691.   * The same as {@link #add(BigDecimal, MathContext)},
  2692.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2693.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  2694.   * <p>
  2695.   * The length of the decimal part (the scale) of the result will be
  2696.   * the sum of the scales of the operands, if they were formatted
  2697.   * without exponential notation.
  2698.   *
  2699.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2700.   *             the multiplication.
  2701.   * @return     A <code>BigDecimal</code> whose value is
  2702.   *             <code>this*rhs</code>, using fixed point arithmetic.
  2703.   * @stable ICU 2.0
  2704.   */
  2705.  
  2706.  //--public com.ibm.icu.math.BigDecimal multiply(com.ibm.icu.math.BigDecimal rhs){
  2707.  //-- return this.multiply(rhs,plainMC);
  2708.  //-- }
  2709.  
  2710.  /**
  2711.   * Returns a <code>BigDecimal</code> whose value is <code>this*rhs</code>.
  2712.   * <p>
  2713.   * Implements the multiplication (<b><code>*</code></b>) operator
  2714.   * (as defined in the decimal documentation, see {@link BigDecimal
  2715.   * class header}),
  2716.   * and returns the result as a <code>BigDecimal</code> object.
  2717.   *
  2718.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2719.   *             the multiplication.
  2720.   * @param  set The <code>MathContext</code> arithmetic settings.
  2721.   * @return     A <code>BigDecimal</code> whose value is
  2722.   *             <code>this*rhs</code>.
  2723.   * @stable ICU 2.0
  2724.   */
  2725.  
  2726.  //--public com.ibm.icu.math.BigDecimal multiply(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  2727.  function multiply() {
  2728.   var set;
  2729.   if (multiply.arguments.length == 2)
  2730.    {
  2731.     set = multiply.arguments[1];
  2732.    }
  2733.   else if (multiply.arguments.length == 1)
  2734.    {
  2735.     set = this.plainMC;
  2736.    }
  2737.   else
  2738.    {
  2739.     throw "multiply(): " + multiply.arguments.length + " arguments given; expected 1 or 2";
  2740.    }
  2741.   var rhs = multiply.arguments[0];
  2742.   //--com.ibm.icu.math.BigDecimal lhs;
  2743.   var lhs;
  2744.   //--int padding;
  2745.   var padding;
  2746.   //--int reqdig;
  2747.   var reqdig;
  2748.   //--byte multer[]=null;
  2749.   var multer=null;
  2750.   //--byte multand[]=null;
  2751.   var multand=null;
  2752.   //--int multandlen;
  2753.   var multandlen;
  2754.   //--int acclen=0;
  2755.   var acclen=0;
  2756.   //--com.ibm.icu.math.BigDecimal res;
  2757.   var res;
  2758.   //--byte acc[];
  2759.   var acc;
  2760.   //--int n=0;
  2761.   var n=0;
  2762.   //--byte mult=0;
  2763.   var mult=0;
  2764.   if (set.lostDigits)
  2765.    this.checkdigits(rhs,set.digits);
  2766.   lhs=this; // name for clarity and proxy
  2767.  
  2768.   /* Prepare numbers (truncate, unless unlimited precision) */
  2769.   padding=0; // trailing 0's to add
  2770.   reqdig=set.digits; // local copy
  2771.   if (reqdig>0)
  2772.    {
  2773.     if (lhs.mant.length>reqdig)
  2774.      lhs=this.clone(lhs).round(set);
  2775.     if (rhs.mant.length>reqdig)
  2776.      rhs=this.clone(rhs).round(set);
  2777.    // [we could reuse the new LHS for result in this case]
  2778.    }
  2779.   else
  2780.    {/* unlimited */
  2781.     // fixed point arithmetic will want every trailing 0; we add these
  2782.     // after the calculation rather than before, for speed.
  2783.     if (lhs.exp>0)
  2784.      padding=padding+lhs.exp;
  2785.     if (rhs.exp>0)
  2786.      padding=padding+rhs.exp;
  2787.    }
  2788.  
  2789.   // For best speed, as in DMSRCN, we use the shorter number as the
  2790.   // multiplier and the longer as the multiplicand.
  2791.   // 1999.12.22: We used to special case when the result would fit in
  2792.   //             a long, but with Java 1.3 this gave no advantage.
  2793.   if (lhs.mant.length<rhs.mant.length)
  2794.    {
  2795.     multer=lhs.mant;
  2796.     multand=rhs.mant;
  2797.    }
  2798.   else
  2799.    {
  2800.     multer=rhs.mant;
  2801.     multand=lhs.mant;
  2802.    }
  2803.  
  2804.   /* Calculate how long result byte array will be */
  2805.   multandlen=(multer.length+multand.length)-1; // effective length
  2806.   // optimize for 75% of the cases where a carry is expected...
  2807.   if ((multer[0]*multand[0])>9)
  2808.    acclen=multandlen+1;
  2809.   else
  2810.    acclen=multandlen;
  2811.  
  2812.   /* Now the main long multiplication loop */
  2813.   res=new BigDecimal(); // where we'll build result
  2814.   acc=this.createArrayWithZeros(acclen); // accumulator, all zeros
  2815.   // 1998.07.01: calculate from left to right so that accumulator goes
  2816.   // to likely final length on first addition; this avoids a one-digit
  2817.   // extension (and object allocation) each time around the loop.
  2818.   // Initial number therefore has virtual zeros added to right.
  2819.   {var $7=multer.length;n=0;n:for(;$7>0;$7--,n++){
  2820.    mult=multer[n];
  2821.    if (mult!=0)
  2822.     { // [optimization]
  2823.      // accumulate [accumulator is reusable array]
  2824.      acc=this.byteaddsub(acc,acc.length,multand,multandlen,mult,true);
  2825.     }
  2826.    // divide multiplicand by 10 for next digit to right
  2827.    multandlen--; // 'virtual length'
  2828.    }
  2829.   }/*n*/
  2830.  
  2831.   res.ind=lhs.ind*rhs.ind; // final sign
  2832.   res.exp=(lhs.exp+rhs.exp)-padding; // final exponent
  2833.   // [overflow is checked by finish]
  2834.  
  2835.   /* add trailing zeros to the result, if necessary */
  2836.   if (padding==0)
  2837.    res.mant=acc;
  2838.   else
  2839.    res.mant=this.extend(acc,acc.length+padding); // add trailing 0s
  2840.   return res.finish(set,false);
  2841.   }
  2842.  
  2843.  /**
  2844.   * Returns a plain <code>BigDecimal</code> whose value is
  2845.   * <code>-this</code>.
  2846.   * <p>
  2847.   * The same as {@link #negate(MathContext)}, where the context is
  2848.   * <code>new MathContext(0, MathContext.PLAIN)</code>.
  2849.   * <p>
  2850.   * The length of the decimal part (the scale) of the result will be
  2851.   * be <code>this.scale()</code>
  2852.   *
  2853.   *
  2854.   * @return A <code>BigDecimal</code> whose value is
  2855.   *         <code>-this</code>.
  2856.   * @stable ICU 2.0
  2857.   */
  2858.  
  2859.  //--public com.ibm.icu.math.BigDecimal negate(){
  2860.  //-- return this.negate(plainMC);
  2861.  //-- }
  2862.  
  2863.  /**
  2864.   * Returns a <code>BigDecimal</code> whose value is <code>-this</code>.
  2865.   * <p>
  2866.   * Implements the negation (Prefix <b><code>-</code></b>) operator
  2867.   * (as defined in the decimal documentation, see {@link BigDecimal
  2868.   * class header}),
  2869.   * and returns the result as a <code>BigDecimal</code> object.
  2870.   *
  2871.   * @param  set The <code>MathContext</code> arithmetic settings.
  2872.   * @return A <code>BigDecimal</code> whose value is
  2873.   *         <code>-this</code>.
  2874.   * @stable ICU 2.0
  2875.   */
  2876.  
  2877.  //public com.ibm.icu.math.BigDecimal negate(com.ibm.icu.math.MathContext set){
  2878.  function negate() {
  2879.   var set;
  2880.   if (negate.arguments.length == 1)
  2881.    {
  2882.     set = negate.arguments[0];
  2883.    }
  2884.   else if (negate.arguments.length == 0)
  2885.    {
  2886.     set = this.plainMC;
  2887.    }
  2888.   else
  2889.    {
  2890.     throw "negate(): " + negate.arguments.length + " arguments given; expected 0 or 1";
  2891.    }
  2892.   //--com.ibm.icu.math.BigDecimal res;
  2893.   var res;
  2894.   // Originally called minus(), changed to matched Java precedents
  2895.   // This simply clones, flips the sign, and possibly rounds
  2896.   if (set.lostDigits)
  2897.    this.checkdigits(null,set.digits);
  2898.   res=this.clone(this); // safe copy
  2899.   res.ind=-res.ind;
  2900.   return res.finish(set,false);
  2901.   }
  2902.  
  2903.  /**
  2904.   * Returns a plain <code>BigDecimal</code> whose value is
  2905.   * <code>+this</code>.
  2906.   * Note that <code>this</code> is not necessarily a
  2907.   * plain <code>BigDecimal</code>, but the result will always be.
  2908.   * <p>
  2909.   * The same as {@link #plus(MathContext)}, where the context is
  2910.   * <code>new MathContext(0, MathContext.PLAIN)</code>.
  2911.   * <p>
  2912.   * The length of the decimal part (the scale) of the result will be
  2913.   * be <code>this.scale()</code>
  2914.   *
  2915.   * @return A <code>BigDecimal</code> whose value is
  2916.   *         <code>+this</code>.
  2917.   * @stable ICU 2.0
  2918.   */
  2919.  
  2920.  //--public com.ibm.icu.math.BigDecimal plus(){
  2921.  //-- return this.plus(plainMC);
  2922.  //-- }
  2923.  
  2924.  /**
  2925.   * Returns a <code>BigDecimal</code> whose value is
  2926.   * <code>+this</code>.
  2927.   * <p>
  2928.   * Implements the plus (Prefix <b><code>+</code></b>) operator
  2929.   * (as defined in the decimal documentation, see {@link BigDecimal
  2930.   * class header}),
  2931.   * and returns the result as a <code>BigDecimal</code> object.
  2932.   * <p>
  2933.   * This method is useful for rounding or otherwise applying a context
  2934.   * to a decimal value.
  2935.   *
  2936.   * @param  set The <code>MathContext</code> arithmetic settings.
  2937.   * @return A <code>BigDecimal</code> whose value is
  2938.   *         <code>+this</code>.
  2939.   * @stable ICU 2.0
  2940.   */
  2941.  
  2942.  //public com.ibm.icu.math.BigDecimal plus(com.ibm.icu.math.MathContext set){
  2943.  function plus() {
  2944.   var set;
  2945.   if (plus.arguments.length == 1)
  2946.    {
  2947.     set = plus.arguments[0];
  2948.    }
  2949.   else if (plus.arguments.length == 0)
  2950.    {
  2951.     set = this.plainMC;
  2952.    }
  2953.   else
  2954.    {
  2955.     throw "plus(): " + plus.arguments.length + " arguments given; expected 0 or 1";
  2956.    }
  2957.   // This clones and forces the result to the new settings
  2958.   // May return same object
  2959.   if (set.lostDigits)
  2960.    this.checkdigits(null,set.digits);
  2961.   // Optimization: returns same object for some common cases
  2962.   if (set.form==MathContext.prototype.PLAIN)
  2963.    if (this.form==MathContext.prototype.PLAIN)
  2964.     {
  2965.      if (this.mant.length<=set.digits)
  2966.       return this;
  2967.      if (set.digits==0)
  2968.       return this;
  2969.     }
  2970.   return this.clone(this).finish(set,false);
  2971.   }
  2972.  
  2973.  /**
  2974.   * Returns a plain <code>BigDecimal</code> whose value is
  2975.   * <code>this**rhs</code>, using fixed point arithmetic.
  2976.   * <p>
  2977.   * The same as {@link #pow(BigDecimal, MathContext)},
  2978.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  2979.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  2980.   * <p>
  2981.   * The parameter is the power to which the <code>this</code> will be
  2982.   * raised; it must be in the range 0 through 999999999, and must
  2983.   * have a decimal part of zero.  Note that these restrictions may be
  2984.   * removed in the future, so they should not be used as a test for a
  2985.   * whole number.
  2986.   * <p>
  2987.   * In addition, the power must not be negative, as no
  2988.   * <code>MathContext</code> is used and so the result would then
  2989.   * always be 0.
  2990.   *
  2991.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  2992.   *             the operation (the power).
  2993.   * @return     A <code>BigDecimal</code> whose value is
  2994.   *             <code>this**rhs</code>, using fixed point arithmetic.
  2995.   * @throws ArithmeticException if <code>rhs</code> is out of range or
  2996.   *             is not a whole number.
  2997.   * @stable ICU 2.0
  2998.   */
  2999.  
  3000.  //--public com.ibm.icu.math.BigDecimal pow(com.ibm.icu.math.BigDecimal rhs){
  3001.  //-- return this.pow(rhs,plainMC);
  3002.  //-- }
  3003.  // The name for this method is inherited from the precedent set by the
  3004.  // BigInteger and Math classes.
  3005.  
  3006.  /**
  3007.   * Returns a <code>BigDecimal</code> whose value is <code>this**rhs</code>.
  3008.   * <p>
  3009.   * Implements the power (<b><code>**</code></b>) operator
  3010.   * (as defined in the decimal documentation, see {@link BigDecimal
  3011.   * class header}),
  3012.   * and returns the result as a <code>BigDecimal</code> object.
  3013.   * <p>
  3014.   * The first parameter is the power to which the <code>this</code>
  3015.   * will be raised; it must be in the range -999999999 through
  3016.   * 999999999, and must have a decimal part of zero.  Note that these
  3017.   * restrictions may be removed in the future, so they should not be
  3018.   * used as a test for a whole number.
  3019.   * <p>
  3020.   * If the <code>digits</code> setting of the <code>MathContext</code>
  3021.   * parameter is 0, the power must be zero or positive.
  3022.   *
  3023.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  3024.   *             the operation (the power).
  3025.   * @param  set The <code>MathContext</code> arithmetic settings.
  3026.   * @return     A <code>BigDecimal</code> whose value is
  3027.   *             <code>this**rhs</code>.
  3028.   * @throws ArithmeticException if <code>rhs</code> is out of range or
  3029.   *             is not a whole number.
  3030.   * @stable ICU 2.0
  3031.   */
  3032.  
  3033.  //--public com.ibm.icu.math.BigDecimal pow(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  3034.  function pow() {
  3035.   var set;
  3036.   if (pow.arguments.length == 2)
  3037.    {
  3038.     set = pow.arguments[1];
  3039.    }
  3040.   else if (pow.arguments.length == 1)
  3041.    {
  3042.     set = this.plainMC;
  3043.    }
  3044.   else
  3045.    {
  3046.     throw "pow(): " + pow.arguments.length + " arguments given; expected 1 or 2";
  3047.    }
  3048.   var rhs = pow.arguments[0];
  3049.   //--int n;
  3050.   var n;
  3051.   //--com.ibm.icu.math.BigDecimal lhs;
  3052.   var lhs;
  3053.   //--int reqdig;
  3054.   var reqdig;
  3055.   //-- int workdigits=0;
  3056.   var workdigits=0;
  3057.   //--int L=0;
  3058.   var L=0;
  3059.   //--com.ibm.icu.math.MathContext workset;
  3060.   var workset;
  3061.   //--com.ibm.icu.math.BigDecimal res;
  3062.   var res;
  3063.   //--boolean seenbit;
  3064.   var seenbit;
  3065.   //--int i=0;
  3066.   var i=0;
  3067.   if (set.lostDigits)
  3068.    this.checkdigits(rhs,set.digits);
  3069.   n=rhs.intcheck(this.MinArg,this.MaxArg); // check RHS by the rules
  3070.   lhs=this; // clarified name
  3071.  
  3072.   reqdig=set.digits; // local copy (heavily used)
  3073.   if (reqdig==0)
  3074.    {
  3075.     if (rhs.ind==this.isneg)
  3076.      //--throw new java.lang.ArithmeticException("Negative power:"+" "+rhs.toString());
  3077.      throw "pow(): Negative power: " + rhs.toString();
  3078.     workdigits=0;
  3079.    }
  3080.   else
  3081.    {/* non-0 digits */
  3082.     if ((rhs.mant.length+rhs.exp)>reqdig)
  3083.      //--throw new java.lang.ArithmeticException("Too many digits:"+" "+rhs.toString());
  3084.      throw "pow(): Too many digits: " + rhs.toString();
  3085.  
  3086.     /* Round the lhs to DIGITS if need be */
  3087.     if (lhs.mant.length>reqdig)
  3088.      lhs=this.clone(lhs).round(set);
  3089.  
  3090.     /* L for precision calculation [see ANSI X3.274-1996] */
  3091.     L=rhs.mant.length+rhs.exp; // length without decimal zeros/exp
  3092.     workdigits=(reqdig+L)+1; // calculate the working DIGITS
  3093.    }
  3094.  
  3095.   /* Create a copy of set for working settings */
  3096.   // Note: no need to check for lostDigits again.
  3097.   // 1999.07.17 Note: this construction must follow RHS check
  3098.   workset=new MathContext(workdigits,set.form,false,set.roundingMode);
  3099.  
  3100.   res=this.ONE; // accumulator
  3101.   if (n==0)
  3102.    return res; // x**0 == 1
  3103.   if (n<0)
  3104.    n=-n; // [rhs.ind records the sign]
  3105.   seenbit=false; // set once we've seen a 1-bit
  3106.   {i=1;i:for(;;i++){ // for each bit [top bit ignored]
  3107.    //n=n+n; // shift left 1 bit
  3108.    n<<=1;
  3109.    if (n<0)
  3110.     { // top bit is set
  3111.      seenbit=true; // OK, we're off
  3112.      res=res.multiply(lhs,workset); // acc=acc*x
  3113.     }
  3114.    if (i==31)
  3115.     break i; // that was the last bit
  3116.    if ((!seenbit))
  3117.     continue i; // we don't have to square 1
  3118.    res=res.multiply(res,workset); // acc=acc*acc [square]
  3119.    }
  3120.   }/*i*/ // 32 bits
  3121.   if (rhs.ind<0)  // was a **-n [hence digits>0]
  3122.    res=this.ONE.divide(res,workset); // .. so acc=1/acc
  3123.   return res.finish(set,true); // round and strip [original digits]
  3124.   }
  3125.  
  3126.  /**
  3127.   * Returns a plain <code>BigDecimal</code> whose value is
  3128.   * the remainder of <code>this/rhs</code>, using fixed point arithmetic.
  3129.   * <p>
  3130.   * The same as {@link #remainder(BigDecimal, MathContext)},
  3131.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  3132.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  3133.   * <p>
  3134.   * This is not the modulo operator -- the result may be negative.
  3135.   *
  3136.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  3137.   *             the remainder operation.
  3138.   * @return     A <code>BigDecimal</code> whose value is the remainder
  3139.   *             of <code>this/rhs</code>, using fixed point arithmetic.
  3140.   * @throws ArithmeticException if <code>rhs</code> is zero.
  3141.   * @stable ICU 2.0
  3142.   */
  3143.  
  3144.  //--public com.ibm.icu.math.BigDecimal remainder(com.ibm.icu.math.BigDecimal rhs){
  3145.  //-- return this.dodivide('R',rhs,plainMC,-1);
  3146.  //-- }
  3147.  
  3148.  /**
  3149.   * Returns a <code>BigDecimal</code> whose value is the remainder of
  3150.   * <code>this/rhs</code>.
  3151.   * <p>
  3152.   * Implements the remainder operator
  3153.   * (as defined in the decimal documentation, see {@link BigDecimal
  3154.   * class header}),
  3155.   * and returns the result as a <code>BigDecimal</code> object.
  3156.   * <p>
  3157.   * This is not the modulo operator -- the result may be negative.
  3158.   *
  3159.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  3160.   *             the remainder operation.
  3161.   * @param  set The <code>MathContext</code> arithmetic settings.
  3162.   * @return     A <code>BigDecimal</code> whose value is the remainder
  3163.   *             of <code>this+rhs</code>.
  3164.   * @throws ArithmeticException if <code>rhs</code> is zero.
  3165.   * @throws ArithmeticException if the integer part of the result will
  3166.   *             not fit in the number of digits specified for the
  3167.   *             context.
  3168.   * @stable ICU 2.0
  3169.   */
  3170.  
  3171.  //--public com.ibm.icu.math.BigDecimal remainder(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  3172.  function remainder() {
  3173.   var set;
  3174.   if (remainder.arguments.length == 2)
  3175.    {
  3176.     set = remainder.arguments[1];
  3177.    }
  3178.   else if (remainder.arguments.length == 1)
  3179.    {
  3180.     set = this.plainMC;
  3181.    }
  3182.   else
  3183.    {
  3184.     throw "remainder(): " + remainder.arguments.length + " arguments given; expected 1 or 2";
  3185.    }
  3186.   var rhs = remainder.arguments[0];
  3187.   return this.dodivide('R',rhs,set,-1);
  3188.   }
  3189.  
  3190.  /**
  3191.   * Returns a plain <code>BigDecimal</code> whose value is
  3192.   * <code>this-rhs</code>, using fixed point arithmetic.
  3193.   * <p>
  3194.   * The same as {@link #subtract(BigDecimal, MathContext)},
  3195.   * where the <code>BigDecimal</code> is <code>rhs</code>,
  3196.   * and the context is <code>new MathContext(0, MathContext.PLAIN)</code>.
  3197.   * <p>
  3198.   * The length of the decimal part (the scale) of the result will be
  3199.   * the maximum of the scales of the two operands.
  3200.   *
  3201.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  3202.   *             the subtraction.
  3203.   * @return     A <code>BigDecimal</code> whose value is
  3204.   *             <code>this-rhs</code>, using fixed point arithmetic.
  3205.   * @stable ICU 2.0
  3206.   */
  3207.  
  3208.  //--public com.ibm.icu.math.BigDecimal subtract(com.ibm.icu.math.BigDecimal rhs){
  3209.  //-- return this.subtract(rhs,plainMC);
  3210.  //-- }
  3211.  
  3212.  /**
  3213.   * Returns a <code>BigDecimal</code> whose value is <code>this-rhs</code>.
  3214.   * <p>
  3215.   * Implements the subtraction (<b><code>-</code></b>) operator
  3216.   * (as defined in the decimal documentation, see {@link BigDecimal
  3217.   * class header}),
  3218.   * and returns the result as a <code>BigDecimal</code> object.
  3219.   *
  3220.   * @param  rhs The <code>BigDecimal</code> for the right hand side of
  3221.   *             the subtraction.
  3222.   * @param  set The <code>MathContext</code> arithmetic settings.
  3223.   * @return     A <code>BigDecimal</code> whose value is
  3224.   *             <code>this-rhs</code>.
  3225.   * @stable ICU 2.0
  3226.   */
  3227.  
  3228.  //--public com.ibm.icu.math.BigDecimal subtract(com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set){
  3229.  function subtract() {
  3230.   var set;
  3231.   if (subtract.arguments.length == 2)
  3232.    {
  3233.     set = subtract.arguments[1];
  3234.    }
  3235.   else if (subtract.arguments.length == 1)
  3236.    {
  3237.     set = this.plainMC;
  3238.    }
  3239.   else
  3240.    {
  3241.     throw "subtract(): " + subtract.arguments.length + " arguments given; expected 1 or 2";
  3242.    }
  3243.   var rhs = subtract.arguments[0];
  3244.   //--com.ibm.icu.math.BigDecimal newrhs;
  3245.   var newrhs;
  3246.   if (set.lostDigits)
  3247.    this.checkdigits(rhs,set.digits);
  3248.   // [add will recheck .. but would report -rhs]
  3249.   /* carry out the subtraction */
  3250.   // we could fastpath -0, but it is too rare.
  3251.   newrhs=this.clone(rhs); // safe copy
  3252.   newrhs.ind=-newrhs.ind; // prepare to subtract
  3253.   return this.add(newrhs,set); // arithmetic
  3254.   }
  3255.  
  3256.  /* ---------------------------------------------------------------- */
  3257.  /* Other methods                                                    */
  3258.  /* ---------------------------------------------------------------- */
  3259.  
  3260.  /**
  3261.   * Converts this <code>BigDecimal</code> to a <code>byte</code>.
  3262.   * If the <code>BigDecimal</code> has a non-zero decimal part or is
  3263.   * out of the possible range for a <code>byte</code> (8-bit signed
  3264.   * integer) result then an <code>ArithmeticException</code> is thrown.
  3265.   *
  3266.   * @return A <code>byte</code> equal in value to <code>this</code>.
  3267.   * @throws ArithmeticException if <code>this</code> has a non-zero
  3268.   *                 decimal part, or will not fit in a <code>byte</code>.
  3269.   * @stable ICU 2.0
  3270.   */
  3271.  
  3272.  //--public byte byteValueExact(){
  3273.  //-- int num;
  3274.  //-- num=this.intValueExact(); // will check decimal part too
  3275.  //-- if ((num>127)|(num<(-128)))
  3276.  //--  throw new java.lang.ArithmeticException("Conversion overflow:"+" "+this.toString());
  3277.  //-- return (byte)num;
  3278.  //-- }
  3279.  
  3280.  /**
  3281.   * Compares this <code>BigDecimal</code> with the value of the parameter.
  3282.   * <p>
  3283.   * If the parameter is <code>null</code>, or is not an instance of the
  3284.   * <code>BigDecimal</code> type, an exception is thrown.
  3285.   * Otherwise, the parameter is cast to type <code>BigDecimal</code>
  3286.   * and the result of the {@link #compareTo(BigDecimal)} method,
  3287.   * using the cast parameter, is returned.
  3288.   * <p>
  3289.   * The {@link #compareTo(BigDecimal, MathContext)} method should be
  3290.   * used when a <code>MathContext</code> is needed for the comparison.
  3291.   *
  3292.   * @param  rhs The <code>Object</code> for the right hand side of
  3293.   *             the comparison.
  3294.   * @return     An <code>int</code> whose value is -1, 0, or 1 as
  3295.   *             <code>this</code> is numerically less than, equal to,
  3296.   *             or greater than <code>rhs</code>.
  3297.   * @throws ClassCastException if <code>rhs</code> cannot be cast to
  3298.   *                 a <code>BigDecimal</code> object.
  3299.   * @see    #compareTo(BigDecimal)
  3300.   * @stable ICU 2.0
  3301.   */
  3302.  
  3303.  //--public int compareTo(java.lang.Object rhsobj){
  3304.  //-- // the cast in the next line will raise ClassCastException if necessary
  3305.  //-- return compareTo((com.ibm.icu.math.BigDecimal)rhsobj,plainMC);
  3306.  //-- }
  3307.  
  3308.  /**
  3309.   * Converts this <code>BigDecimal</code> to a <code>double</code>.
  3310.   * If the <code>BigDecimal</code> is out of the possible range for a
  3311.   * <code>double</code> (64-bit signed floating point) result then an
  3312.   * <code>ArithmeticException</code> is thrown.
  3313.   * <p>
  3314.   * The double produced is identical to result of expressing the
  3315.   * <code>BigDecimal</code> as a <code>String</code> and then
  3316.   * converting it using the <code>Double(String)</code> constructor;
  3317.   * this can result in values of <code>Double.NEGATIVE_INFINITY</code>
  3318.   * or <code>Double.POSITIVE_INFINITY</code>.
  3319.   *
  3320.   * @return A <code>double</code> corresponding to <code>this</code>.
  3321.   * @stable ICU 2.0
  3322.   */
  3323.  
  3324.  //--public double doubleValue(){
  3325.  //-- // We go via a String [as does BigDecimal in JDK 1.2]
  3326.  //-- // Next line could possibly raise NumberFormatException
  3327.  //-- return java.lang.Double.valueOf(this.toString()).doubleValue();
  3328.  //-- }
  3329.  
  3330.  /**
  3331.   * Compares this <code>BigDecimal</code> with <code>rhs</code> for
  3332.   * equality.
  3333.   * <p>
  3334.   * If the parameter is <code>null</code>, or is not an instance of the
  3335.   * BigDecimal type, or is not exactly equal to the current
  3336.   * <code>BigDecimal</code> object, then <i>false</i> is returned.
  3337.   * Otherwise, <i>true</i> is returned.
  3338.   * <p>
  3339.   * "Exactly equal", here, means that the <code>String</code>
  3340.   * representations of the <code>BigDecimal</code> numbers are
  3341.   * identical (they have the same characters in the same sequence).
  3342.   * <p>
  3343.   * The {@link #compareTo(BigDecimal, MathContext)} method should be
  3344.   * used for more general comparisons.
  3345.   * @param  rhs The <code>Object</code> for the right hand side of
  3346.   *             the comparison.
  3347.   * @return     A <code>boolean</code> whose value <i>true</i> if and
  3348.   *             only if the operands have identical string representations.
  3349.   * @throws ClassCastException if <code>rhs</code> cannot be cast to
  3350.   *                 a <code>BigDecimal</code> object.
  3351.   * @stable ICU 2.0
  3352.   * @see    #compareTo(Object)
  3353.   * @see    #compareTo(BigDecimal)
  3354.   * @see    #compareTo(BigDecimal, MathContext)
  3355.   */
  3356.  
  3357.  //--public boolean equals(java.lang.Object obj){
  3358.  function equals(obj) {
  3359.   //--com.ibm.icu.math.BigDecimal rhs;
  3360.   var rhs;
  3361.   //--int i=0;
  3362.   var i=0;
  3363.   //--char lca[]=null;
  3364.   var lca=null;
  3365.   //--char rca[]=null;
  3366.   var rca=null;
  3367.   // We are equal iff toString of both are exactly the same
  3368.   if (obj==null)
  3369.    return false; // not equal
  3370.   if ((!(((obj instanceof BigDecimal)))))
  3371.    return false; // not a decimal
  3372.   rhs=obj; // cast; we know it will work
  3373.   if (this.ind!=rhs.ind)
  3374.    return false; // different signs never match
  3375.   if (((this.mant.length==rhs.mant.length)&&(this.exp==rhs.exp))&&(this.form==rhs.form))
  3376.  
  3377.    { // mantissas say all
  3378.     // here with equal-length byte arrays to compare
  3379.     {var $8=this.mant.length;i=0;i:for(;$8>0;$8--,i++){
  3380.      if (this.mant[i]!=rhs.mant[i])
  3381.       return false;
  3382.      }
  3383.     }/*i*/
  3384.    }
  3385.   else
  3386.    { // need proper layout
  3387.     lca=this.layout(); // layout to character array
  3388.     rca=rhs.layout();
  3389.     if (lca.length!=rca.length)
  3390.      return false; // mismatch
  3391.     // here with equal-length character arrays to compare
  3392.     {var $9=lca.length;i=0;i:for(;$9>0;$9--,i++){
  3393.      if (lca[i]!=rca[i])
  3394.       return false;
  3395.      }
  3396.     }/*i*/
  3397.    }
  3398.   return true; // arrays have identical content
  3399.   }
  3400.  
  3401.  /**
  3402.   * Converts this <code>BigDecimal</code> to a <code>float</code>.
  3403.   * If the <code>BigDecimal</code> is out of the possible range for a
  3404.   * <code>float</code> (32-bit signed floating point) result then an
  3405.   * <code>ArithmeticException</code> is thrown.
  3406.   * <p>
  3407.   * The float produced is identical to result of expressing the
  3408.   * <code>BigDecimal</code> as a <code>String</code> and then
  3409.   * converting it using the <code>Float(String)</code> constructor;
  3410.   * this can result in values of <code>Float.NEGATIVE_INFINITY</code>
  3411.   * or <code>Float.POSITIVE_INFINITY</code>.
  3412.   *
  3413.   * @return A <code>float</code> corresponding to <code>this</code>.
  3414.   * @stable ICU 2.0
  3415.   */
  3416.  
  3417.  //--public float floatValue(){
  3418.  //-- return java.lang.Float.valueOf(this.toString()).floatValue();
  3419.  //-- }
  3420.  
  3421.  /**
  3422.   * Returns the <code>String</code> representation of this
  3423.   * <code>BigDecimal</code>, modified by layout parameters.
  3424.   * <p>
  3425.   * <i>This method is provided as a primitive for use by more
  3426.   * sophisticated classes, such as <code>DecimalFormat</code>, that
  3427.   * can apply locale-sensitive editing of the result.  The level of
  3428.   * formatting that it provides is a necessary part of the BigDecimal
  3429.   * class as it is sensitive to and must follow the calculation and
  3430.   * rounding rules for BigDecimal arithmetic.
  3431.   * However, if the function is provided elsewhere, it may be removed
  3432.   * from this class. </i>
  3433.   * <p>
  3434.   * The parameters, for both forms of the <code>format</code> method
  3435.   * are all of type <code>int</code>.
  3436.   * A value of -1 for any parameter indicates that the default action
  3437.   * or value for that parameter should be used.
  3438.   * <p>
  3439.   * The parameters, <code>before</code> and <code>after</code>,
  3440.   * specify the number of characters to be used for the integer part
  3441.   * and decimal part of the result respectively.  Exponential notation
  3442.   * is not used. If either parameter is -1 (which indicates the default
  3443.   * action), the number of characters used will be exactly as many as
  3444.   * are needed for that part.
  3445.   * <p>
  3446.   * <code>before</code> must be a positive number; if it is larger than
  3447.   * is needed to contain the integer part, that part is padded on the
  3448.   * left with blanks to the requested length. If <code>before</code> is
  3449.   * not large enough to contain the integer part of the number
  3450.   * (including the sign, for negative numbers) an exception is thrown.
  3451.   * <p>
  3452.   * <code>after</code> must be a non-negative number; if it is not the
  3453.   * same size as the decimal part of the number, the number will be
  3454.   * rounded (or extended with zeros) to fit.  Specifying 0 for
  3455.   * <code>after</code> will cause the number to be rounded to an
  3456.   * integer (that is, it will have no decimal part or decimal point).
  3457.   * The rounding method will be the default,
  3458.   * <code>MathContext.ROUND_HALF_UP</code>.
  3459.   * <p>
  3460.   * Other rounding methods, and the use of exponential notation, can
  3461.   * be selected by using {@link #format(int,int,int,int,int,int)}.
  3462.   * Using the two-parameter form of the method has exactly the same
  3463.   * effect as using the six-parameter form with the final four
  3464.   * parameters all being -1.
  3465.   *
  3466.   * @param  before The <code>int</code> specifying the number of places
  3467.   *                before the decimal point.  Use -1 for 'as many as
  3468.   *                are needed'.
  3469.   * @param  after  The <code>int</code> specifying the number of places
  3470.   *                after the decimal point.  Use -1 for 'as many as are
  3471.   *                needed'.
  3472.   * @return        A <code>String</code> representing this
  3473.   *                <code>BigDecimal</code>, laid out according to the
  3474.   *                specified parameters
  3475.   * @throws ArithmeticException if the number cannot be laid out as
  3476.   *                requested.
  3477.   * @throws IllegalArgumentException if a parameter is out of range.
  3478.   * @stable ICU 2.0
  3479.   * @see    #toString
  3480.   * @see    #toCharArray
  3481.   */
  3482.  
  3483.  //--public java.lang.String format(int before,int after){
  3484.  //-- return format(before,after,-1,-1,com.ibm.icu.math.MathContext.SCIENTIFIC,ROUND_HALF_UP);
  3485.  //-- }
  3486.  
  3487.  /**
  3488.   * Returns the <code>String</code> representation of this
  3489.   * <code>BigDecimal</code>, modified by layout parameters and allowing
  3490.   * exponential notation.
  3491.   * <p>
  3492.   * <i>This method is provided as a primitive for use by more
  3493.   * sophisticated classes, such as <code>DecimalFormat</code>, that
  3494.   * can apply locale-sensitive editing of the result.  The level of
  3495.   * formatting that it provides is a necessary part of the BigDecimal
  3496.   * class as it is sensitive to and must follow the calculation and
  3497.   * rounding rules for BigDecimal arithmetic.
  3498.   * However, if the function is provided elsewhere, it may be removed
  3499.   * from this class. </i>
  3500.   * <p>
  3501.   * The parameters are all of type <code>int</code>.
  3502.   * A value of -1 for any parameter indicates that the default action
  3503.   * or value for that parameter should be used.
  3504.   * <p>
  3505.   * The first two parameters (<code>before</code> and
  3506.   * <code>after</code>) specify the number of characters to be used for
  3507.   * the integer part and decimal part of the result respectively, as
  3508.   * defined for {@link #format(int,int)}.
  3509.   * If either of these is -1 (which indicates the default action), the
  3510.   * number of characters used will be exactly as many as are needed for
  3511.   * that part.
  3512.   * <p>
  3513.   * The remaining parameters control the use of exponential notation
  3514.   * and rounding.  Three (<code>explaces</code>, <code>exdigits</code>,
  3515.   * and <code>exform</code>) control the exponent part of the result.
  3516.   * As before, the default action for any of these parameters may be
  3517.   * selected by using the value -1.
  3518.   * <p>
  3519.   * <code>explaces</code> must be a positive number; it sets the number
  3520.   * of places (digits after the sign of the exponent) to be used for
  3521.   * any exponent part, the default (when <code>explaces</code> is -1)
  3522.   * being to use as many as are needed.
  3523.   * If <code>explaces</code> is not -1, space is always reserved for
  3524.   * an exponent; if one is not needed (for example, if the exponent
  3525.   * will be 0) then <code>explaces</code>+2 blanks are appended to the
  3526.   * result.
  3527.   * <!-- (This preserves vertical alignment of similarly formatted
  3528.   *       numbers in a monospace font.) -->
  3529.   * If <code>explaces</code> is not -1 and is not large enough to
  3530.   * contain the exponent, an exception is thrown.
  3531.   * <p>
  3532.   * <code>exdigits</code> sets the trigger point for use of exponential
  3533.   * notation. If, before any rounding, the number of places needed
  3534.   * before the decimal point exceeds <code>exdigits</code>, or if the
  3535.   * absolute value of the result is less than <code>0.000001</code>,
  3536.   * then exponential form will be used, provided that
  3537.   * <code>exdigits</code> was specified.
  3538.   * When <code>exdigits</code> is -1, exponential notation will never
  3539.   * be used. If 0 is specified for <code>exdigits</code>, exponential
  3540.   * notation is always used unless the exponent would be 0.
  3541.   * <p>
  3542.   * <code>exform</code> sets the form for exponential notation (if
  3543.   * needed).
  3544.   * It  may be either {@link MathContext#SCIENTIFIC} or
  3545.   * {@link MathContext#ENGINEERING}.
  3546.   * If the latter, engineering, form is requested, up to three digits
  3547.   * (plus sign, if negative) may be needed for the integer part of the
  3548.   * result (<code>before</code>).  Otherwise, only one digit (plus
  3549.   * sign, if negative) is needed.
  3550.   * <p>
  3551.   * Finally, the sixth argument, <code>exround</code>, selects the
  3552.   * rounding algorithm to be used, and must be one of the values
  3553.   * indicated by a public constant in the {@link MathContext} class
  3554.   * whose name starts with <code>ROUND_</code>.
  3555.   * The default (<code>ROUND_HALF_UP</code>) may also be selected by
  3556.   * using the value -1, as before.
  3557.   * <p>
  3558.   * The special value <code>MathContext.ROUND_UNNECESSARY</code> may be
  3559.   * used to detect whether non-zero digits are discarded -- if
  3560.   * <code>exround</code> has this value than if non-zero digits would
  3561.   * be discarded (rounded) during formatting then an
  3562.   * <code>ArithmeticException</code> is thrown.
  3563.   *
  3564.   * @param  before   The <code>int</code> specifying the number of places
  3565.   *                  before the decimal point.
  3566.   *                  Use -1 for 'as many as are needed'.
  3567.   * @param  after    The <code>int</code> specifying the number of places
  3568.   *                  after the decimal point.
  3569.   *                  Use -1 for 'as many as are needed'.
  3570.   * @param  explaces The <code>int</code> specifying the number of places
  3571.   *                  to be used for any exponent.
  3572.   *                  Use -1 for 'as many as are needed'.
  3573.   * @param  exdigits The <code>int</code> specifying the trigger
  3574.   *                  (digits before the decimal point) which if
  3575.   *                  exceeded causes exponential notation to be used.
  3576.   *                  Use 0 to force exponential notation.
  3577.   *                  Use -1 to force plain notation (no exponential
  3578.   *                  notation).
  3579.   * @param  exform   The <code>int</code> specifying the form of
  3580.   *                  exponential notation to be used
  3581.   *                  ({@link MathContext#SCIENTIFIC} or
  3582.   *                  {@link MathContext#ENGINEERING}).
  3583.   * @param  exround  The <code>int</code> specifying the rounding mode
  3584.   *                  to use.
  3585.   *                  Use -1 for the default, {@link MathContext#ROUND_HALF_UP}.
  3586.   * @return          A <code>String</code> representing this
  3587.   *                  <code>BigDecimal</code>, laid out according to the
  3588.   *                  specified parameters
  3589.   * @throws ArithmeticException if the number cannot be laid out as
  3590.   *                  requested.
  3591.   * @throws IllegalArgumentException if a parameter is out of range.
  3592.   * @see    #toString
  3593.   * @see    #toCharArray
  3594.   * @stable ICU 2.0
  3595.   */
  3596.  
  3597.  //--public java.lang.String format(int before,int after,int explaces,int exdigits,int exformint,int exround){
  3598.  function format() {
  3599.   var explaces;
  3600.   var exdigits;
  3601.   var exformint;
  3602.   var exround;
  3603.   if (format.arguments.length == 6)
  3604.    {
  3605.     explaces = format.arguments[2];
  3606.     exdigits = format.arguments[3];
  3607.     exformint = format.arguments[4];
  3608.     exround = format.arguments[5];
  3609.    }
  3610.   else if (format.arguments.length == 2)
  3611.    {
  3612.     explaces = -1;
  3613.     exdigits = -1;
  3614.     exformint = MathContext.prototype.SCIENTIFIC;
  3615.     exround = this.ROUND_HALF_UP;
  3616.    }
  3617.   else
  3618.    {
  3619.     throw "format(): " + format.arguments.length + " arguments given; expected 2 or 6";
  3620.    }
  3621.   var before = format.arguments[0];
  3622.   var after = format.arguments[1];
  3623.   //--com.ibm.icu.math.BigDecimal num;
  3624.   var num;
  3625.   //--int mag=0;
  3626.   var mag=0;
  3627.   //--int thisafter=0;
  3628.   var thisafter=0;
  3629.   //--int lead=0;
  3630.   var lead=0;
  3631.   //--byte newmant[]=null;
  3632.   var newmant=null;
  3633.   //--int chop=0;
  3634.   var chop=0;
  3635.   //--int need=0;
  3636.   var need=0;
  3637.   //--int oldexp=0;
  3638.   var oldexp=0;
  3639.   //--char a[];
  3640.   var a;
  3641.   //--int p=0;
  3642.   var p=0;
  3643.   //--char newa[]=null;
  3644.   var newa=null;
  3645.   //--int i=0;
  3646.   var i=0;
  3647.   //--int places=0;
  3648.   var places=0;
  3649.  
  3650.  
  3651.   /* Check arguments */
  3652.   if ((before<(-1))||(before==0))
  3653.    this.badarg("format",1,before);
  3654.   if (after<(-1))
  3655.    this.badarg("format",2,after);
  3656.   if ((explaces<(-1))||(explaces==0))
  3657.    this.badarg("format",3,explaces);
  3658.   if (exdigits<(-1))
  3659.    this.badarg("format",4,exdigits);
  3660.   {/*select*/
  3661.   if (exformint==MathContext.prototype.SCIENTIFIC)
  3662.    {}
  3663.   else if (exformint==MathContext.prototype.ENGINEERING)
  3664.    {}
  3665.   else if (exformint==(-1))
  3666.    exformint=MathContext.prototype.SCIENTIFIC;
  3667.    // note PLAIN isn't allowed
  3668.   else{
  3669.    this.badarg("format",5,exformint);
  3670.   }
  3671.   }
  3672.   // checking the rounding mode is done by trying to construct a
  3673.   // MathContext object with that mode; it will fail if bad
  3674.   if (exround!=this.ROUND_HALF_UP)
  3675.    {try{ // if non-default...
  3676.     if (exround==(-1))
  3677.      exround=this.ROUND_HALF_UP;
  3678.     else
  3679.      new MathContext(9,MathContext.prototype.SCIENTIFIC,false,exround);
  3680.    }
  3681.    catch ($10){
  3682.     this.badarg("format",6,exround);
  3683.    }}
  3684.  
  3685.   num=this.clone(this); // make private copy
  3686.  
  3687.   /* Here:
  3688.      num       is BigDecimal to format
  3689.      before    is places before point [>0]
  3690.      after     is places after point  [>=0]
  3691.      explaces  is exponent places     [>0]
  3692.      exdigits  is exponent digits     [>=0]
  3693.      exformint is exponent form       [one of two]
  3694.      exround   is rounding mode       [one of eight]
  3695.      'before' through 'exdigits' are -1 if not specified
  3696.   */
  3697.  
  3698.   /* determine form */
  3699.   {setform:do{/*select*/
  3700.   if (exdigits==(-1))
  3701.    num.form=MathContext.prototype.PLAIN;
  3702.   else if (num.ind==this.iszero)
  3703.    num.form=MathContext.prototype.PLAIN;
  3704.   else{
  3705.    // determine whether triggers
  3706.    mag=num.exp+num.mant.length;
  3707.    if (mag>exdigits)
  3708.     num.form=exformint;
  3709.    else
  3710.     if (mag<(-5))
  3711.      num.form=exformint;
  3712.     else
  3713.      num.form=MathContext.prototype.PLAIN;
  3714.   }
  3715.   }while(false);}/*setform*/
  3716.  
  3717.   /* If 'after' was specified then we may need to adjust the
  3718.      mantissa.  This is a little tricky, as we must conform to the
  3719.      rules of exponential layout if necessary (e.g., we cannot end up
  3720.      with 10.0 if scientific). */
  3721.   if (after>=0)
  3722.    {setafter:for(;;){
  3723.     // calculate the current after-length
  3724.     {/*select*/
  3725.     if (num.form==MathContext.prototype.PLAIN)
  3726.      thisafter=-num.exp; // has decimal part
  3727.     else if (num.form==MathContext.prototype.SCIENTIFIC)
  3728.      thisafter=num.mant.length-1;
  3729.     else{ // engineering
  3730.      lead=(((num.exp+num.mant.length)-1))%3; // exponent to use
  3731.      if (lead<0)
  3732.       lead=3+lead; // negative exponent case
  3733.      lead++; // number of leading digits
  3734.      if (lead>=num.mant.length)
  3735.       thisafter=0;
  3736.      else
  3737.       thisafter=num.mant.length-lead;
  3738.     }
  3739.     }
  3740.     if (thisafter==after)
  3741.      break setafter; // we're in luck
  3742.     if (thisafter<after)
  3743.      { // need added trailing zeros
  3744.       // [thisafter can be negative]
  3745.       newmant=this.extend(num.mant,(num.mant.length+after)-thisafter);
  3746.       num.mant=newmant;
  3747.       num.exp=num.exp-((after-thisafter)); // adjust exponent
  3748.       if (num.exp<this.MinExp)
  3749.        throw "format(): Exponent Overflow: " + num.exp;
  3750.       break setafter;
  3751.      }
  3752.     // We have too many digits after the decimal point; this could
  3753.     // cause a carry, which could change the mantissa...
  3754.     // Watch out for implied leading zeros in PLAIN case
  3755.     chop=thisafter-after; // digits to lop [is >0]
  3756.     if (chop>num.mant.length)
  3757.      { // all digits go, no chance of carry
  3758.       // carry on with zero
  3759.       num.mant=this.ZERO.mant;
  3760.       num.ind=this.iszero;
  3761.       num.exp=0;
  3762.       continue setafter; // recheck: we may need trailing zeros
  3763.      }
  3764.     // we have a digit to inspect from existing mantissa
  3765.     // round the number as required
  3766.     need=num.mant.length-chop; // digits to end up with [may be 0]
  3767.     oldexp=num.exp; // save old exponent
  3768.     num.round(need,exround);
  3769.     // if the exponent grew by more than the digits we chopped, then
  3770.     // we must have had a carry, so will need to recheck the layout
  3771.     if ((num.exp-oldexp)==chop)
  3772.      break setafter; // number did not have carry
  3773.     // mantissa got extended .. so go around and check again
  3774.     }
  3775.    }/*setafter*/
  3776.  
  3777.   a=num.layout(); // lay out, with exponent if required, etc.
  3778.  
  3779.   /* Here we have laid-out number in 'a' */
  3780.   // now apply 'before' and 'explaces' as needed
  3781.   if (before>0)
  3782.    {
  3783.     // look for '.' or 'E'
  3784.     {var $11=a.length;p=0;p:for(;$11>0;$11--,p++){
  3785.      if (a[p]=='.')
  3786.       break p;
  3787.      if (a[p]=='E')
  3788.       break p;
  3789.      }
  3790.     }/*p*/
  3791.     // p is now offset of '.', 'E', or character after end of array
  3792.     // that is, the current length of before part
  3793.     if (p>before)
  3794.      this.badarg("format",1,before); // won't fit
  3795.     if (p<before)
  3796.      { // need leading blanks
  3797.       newa=new Array((a.length+before)-p);
  3798.       {var $12=before-p;i=0;i:for(;$12>0;$12--,i++){
  3799.        newa[i]=' ';
  3800.        }
  3801.       }/*i*/
  3802.       //--java.lang.System.arraycopy((java.lang.Object)a,0,(java.lang.Object)newa,i,a.length);
  3803.       this.arraycopy(a,0,newa,i,a.length);
  3804.       a=newa;
  3805.      }
  3806.    // [if p=before then it's just the right length]
  3807.    }
  3808.  
  3809.   if (explaces>0)
  3810.    {
  3811.     // look for 'E' [cannot be at offset 0]
  3812.     {var $13=a.length-1;p=a.length-1;p:for(;$13>0;$13--,p--){
  3813.      if (a[p]=='E')
  3814.       break p;
  3815.      }
  3816.     }/*p*/
  3817.     // p is now offset of 'E', or 0
  3818.     if (p==0)
  3819.      { // no E part; add trailing blanks
  3820.       newa=new Array((a.length+explaces)+2);
  3821.       //--java.lang.System.arraycopy((java.lang.Object)a,0,(java.lang.Object)newa,0,a.length);
  3822.       this.arraycopy(a,0,newa,0,a.length);
  3823.       {var $14=explaces+2;i=a.length;i:for(;$14>0;$14--,i++){
  3824.        newa[i]=' ';
  3825.        }
  3826.       }/*i*/
  3827.       a=newa;
  3828.      }
  3829.     else
  3830.      {/* found E */ // may need to insert zeros
  3831.       places=(a.length-p)-2; // number so far
  3832.       if (places>explaces)
  3833.        this.badarg("format",3,explaces);
  3834.       if (places<explaces)
  3835.        { // need to insert zeros
  3836.         newa=new Array((a.length+explaces)-places);
  3837.         //--java.lang.System.arraycopy((java.lang.Object)a,0,(java.lang.Object)newa,0,p+2); // through E and sign
  3838.         this.arraycopy(a,0,newa,0,p+2);
  3839.         {var $15=explaces-places;i=p+2;i:for(;$15>0;$15--,i++){
  3840.          newa[i]='0';
  3841.          }
  3842.         }/*i*/
  3843.         //--java.lang.System.arraycopy((java.lang.Object)a,p+2,(java.lang.Object)newa,i,places); // remainder of exponent
  3844.         this.arraycopy(a,p+2,newa,i,places);
  3845.         a=newa;
  3846.        }
  3847.      // [if places=explaces then it's just the right length]
  3848.      }
  3849.    }
  3850.   return a.join("");
  3851.   }
  3852.  
  3853.  /**
  3854.   * Returns the hashcode for this <code>BigDecimal</code>.
  3855.   * This hashcode is suitable for use by the
  3856.   * <code>java.util.Hashtable</code> class.
  3857.   * <p>
  3858.   * Note that two <code>BigDecimal</code> objects are only guaranteed
  3859.   * to produce the same hashcode if they are exactly equal (that is,
  3860.   * the <code>String</code> representations of the
  3861.   * <code>BigDecimal</code> numbers are identical -- they have the same
  3862.   * characters in the same sequence).
  3863.   *
  3864.   * @return An <code>int</code> that is the hashcode for <code>this</code>.
  3865.   * @stable ICU 2.0
  3866.   */
  3867.  
  3868.  //--public int hashCode(){
  3869.  //-- // Maybe calculate ourselves, later.  If so, note that there can be
  3870.  //-- // more than one internal representation for a given toString() result.
  3871.  //-- return this.toString().hashCode();
  3872.  //-- }
  3873.  
  3874.  /**
  3875.   * Converts this <code>BigDecimal</code> to an <code>int</code>.
  3876.   * If the <code>BigDecimal</code> has a non-zero decimal part it is
  3877.   * discarded. If the <code>BigDecimal</code> is out of the possible
  3878.   * range for an <code>int</code> (32-bit signed integer) result then
  3879.   * only the low-order 32 bits are used. (That is, the number may be
  3880.   * <i>decapitated</i>.)  To avoid unexpected errors when these
  3881.   * conditions occur, use the {@link #intValueExact} method.
  3882.   *
  3883.   * @return An <code>int</code> converted from <code>this</code>,
  3884.   *         truncated and decapitated if necessary.
  3885.   * @stable ICU 2.0
  3886.   */
  3887.  
  3888.  //--public int intValue(){
  3889.  //-- return toBigInteger().intValue();
  3890.  //-- }
  3891.  
  3892.  /**
  3893.   * Converts this <code>BigDecimal</code> to an <code>int</code>.
  3894.   * If the <code>BigDecimal</code> has a non-zero decimal part or is
  3895.   * out of the possible range for an <code>int</code> (32-bit signed
  3896.   * integer) result then an <code>ArithmeticException</code> is thrown.
  3897.   *
  3898.   * @return An <code>int</code> equal in value to <code>this</code>.
  3899.   * @throws ArithmeticException if <code>this</code> has a non-zero
  3900.   *                 decimal part, or will not fit in an
  3901.   *                 <code>int</code>.
  3902.   * @stable ICU 2.0
  3903.   */
  3904.  
  3905.  //--public int intValueExact(){
  3906.  function intValueExact() {
  3907.   //--int lodigit;
  3908.   var lodigit;
  3909.   //--int useexp=0;
  3910.   var useexp=0;
  3911.   //--int result;
  3912.   var result;
  3913.   //--int i=0;
  3914.   var i=0;
  3915.   //--int topdig=0;
  3916.   var topdig=0;
  3917.   // This does not use longValueExact() as the latter can be much
  3918.   // slower.
  3919.   // intcheck (from pow) relies on this to check decimal part
  3920.   if (this.ind==this.iszero)
  3921.    return 0; // easy, and quite common
  3922.   /* test and drop any trailing decimal part */
  3923.   lodigit=this.mant.length-1;
  3924.   if (this.exp<0)
  3925.    {
  3926.     lodigit=lodigit+this.exp; // reduces by -(-exp)
  3927.     /* all decimal places must be 0 */
  3928.     if ((!(this.allzero(this.mant,lodigit+1))))
  3929.      throw "intValueExact(): Decimal part non-zero: " + this.toString();
  3930.     if (lodigit<0)
  3931.      return 0; // -1<this<1
  3932.     useexp=0;
  3933.    }
  3934.   else
  3935.    {/* >=0 */
  3936.     if ((this.exp+lodigit)>9)  // early exit
  3937.      throw "intValueExact(): Conversion overflow: "+this.toString();
  3938.     useexp=this.exp;
  3939.    }
  3940.   /* convert the mantissa to binary, inline for speed */
  3941.   result=0;
  3942.   {var $16=lodigit+useexp;i=0;i:for(;i<=$16;i++){
  3943.    result=result*10;
  3944.    if (i<=lodigit)
  3945.     result=result+this.mant[i];
  3946.    }
  3947.   }/*i*/
  3948.  
  3949.   /* Now, if the risky length, check for overflow */
  3950.   if ((lodigit+useexp)==9)
  3951.    {
  3952.     // note we cannot just test for -ve result, as overflow can move a
  3953.     // zero into the top bit [consider 5555555555]
  3954.     topdig=div(result,1000000000); // get top digit, preserving sign
  3955.     if (topdig!=this.mant[0])
  3956.      { // digit must match and be positive
  3957.       // except in the special case ...
  3958.       if (result==-2147483648)  // looks like the special
  3959.        if (this.ind==this.isneg)  // really was negative
  3960.         if (this.mant[0]==2)
  3961.          return result; // really had top digit 2
  3962.       throw "intValueExact(): Conversion overflow: "+this.toString();
  3963.      }
  3964.    }
  3965.  
  3966.   /* Looks good */
  3967.   if (this.ind==this.ispos)
  3968.    return result;
  3969.   return -result;
  3970.   }
  3971.  
  3972.  /**
  3973.   * Converts this <code>BigDecimal</code> to a <code>long</code>.
  3974.   * If the <code>BigDecimal</code> has a non-zero decimal part it is
  3975.   * discarded. If the <code>BigDecimal</code> is out of the possible
  3976.   * range for a <code>long</code> (64-bit signed integer) result then
  3977.   * only the low-order 64 bits are used. (That is, the number may be
  3978.   * <i>decapitated</i>.)  To avoid unexpected errors when these
  3979.   * conditions occur, use the {@link #longValueExact} method.
  3980.   *
  3981.   * @return A <code>long</code> converted from <code>this</code>,
  3982.   *         truncated and decapitated if necessary.
  3983.   * @stable ICU 2.0
  3984.   */
  3985.  
  3986.  //--public long longValue(){
  3987.  //-- return toBigInteger().longValue();
  3988.  //-- }
  3989.  
  3990.  /**
  3991.   * Converts this <code>BigDecimal</code> to a <code>long</code>.
  3992.   * If the <code>BigDecimal</code> has a non-zero decimal part or is
  3993.   * out of the possible range for a <code>long</code> (64-bit signed
  3994.   * integer) result then an <code>ArithmeticException</code> is thrown.
  3995.   *
  3996.   * @return A <code>long</code> equal in value to <code>this</code>.
  3997.   * @throws ArithmeticException if <code>this</code> has a non-zero
  3998.   *                 decimal part, or will not fit in a
  3999.   *                 <code>long</code>.
  4000.   * @stable ICU 2.0
  4001.   */
  4002.  
  4003.  //--public long longValueExact(){
  4004.  //-- int lodigit;
  4005.  //-- int cstart=0;
  4006.  //-- int useexp=0;
  4007.  //-- long result;
  4008.  //-- int i=0;
  4009.  //-- long topdig=0;
  4010.  //-- // Identical to intValueExact except for result=long, and exp>=20 test
  4011.  //-- if (ind==0)
  4012.  //--  return 0; // easy, and quite common
  4013.  //-- lodigit=mant.length-1; // last included digit
  4014.  //-- if (exp<0)
  4015.  //--  {
  4016.  //--   lodigit=lodigit+exp; // -(-exp)
  4017.  //--   /* all decimal places must be 0 */
  4018.  //--   if (lodigit<0)
  4019.  //--    cstart=0;
  4020.  //--   else
  4021.  //--    cstart=lodigit+1;
  4022.  //--   if ((!(allzero(mant,cstart))))
  4023.  //--    throw new java.lang.ArithmeticException("Decimal part non-zero:"+" "+this.toString());
  4024.  //--   if (lodigit<0)
  4025.  //--    return 0; // -1<this<1
  4026.  //--   useexp=0;
  4027.  //--  }
  4028.  //-- else
  4029.  //--  {/* >=0 */
  4030.  //--   if ((exp+mant.length)>18)  // early exit
  4031.  //--    throw new java.lang.ArithmeticException("Conversion overflow:"+" "+this.toString());
  4032.  //--   useexp=exp;
  4033.  //--  }
  4034.  //--
  4035.  //-- /* convert the mantissa to binary, inline for speed */
  4036.  //-- // note that we could safely use the 'test for wrap to negative'
  4037.  //-- // algorithm here, but instead we parallel the intValueExact
  4038.  //-- // algorithm for ease of checking and maintenance.
  4039.  //-- result=(long)0;
  4040.  //-- {int $17=lodigit+useexp;i=0;i:for(;i<=$17;i++){
  4041.  //--  result=result*10;
  4042.  //--  if (i<=lodigit)
  4043.  //--   result=result+mant[i];
  4044.  //--  }
  4045.  //-- }/*i*/
  4046.  //--
  4047.  //-- /* Now, if the risky length, check for overflow */
  4048.  //-- if ((lodigit+useexp)==18)
  4049.  //--  {
  4050.  //--   topdig=result/1000000000000000000L; // get top digit, preserving sign
  4051.  //--   if (topdig!=mant[0])
  4052.  //--    { // digit must match and be positive
  4053.  //--     // except in the special case ...
  4054.  //--     if (result==java.lang.Long.MIN_VALUE)  // looks like the special
  4055.  //--      if (ind==isneg)  // really was negative
  4056.  //--       if (mant[0]==9)
  4057.  //--        return result; // really had top digit 9
  4058.  //--     throw new java.lang.ArithmeticException("Conversion overflow:"+" "+this.toString());
  4059.  //--    }
  4060.  //--  }
  4061.  //--
  4062.  //-- /* Looks good */
  4063.  //-- if (ind==ispos)
  4064.  //--  return result;
  4065.  //-- return (long)-result;
  4066.  //-- }
  4067.  
  4068.  /**
  4069.   * Returns a plain <code>BigDecimal</code> whose decimal point has
  4070.   * been moved to the left by a specified number of positions.
  4071.   * The parameter, <code>n</code>, specifies the number of positions to
  4072.   * move the decimal point.
  4073.   * That is, if <code>n</code> is 0 or positive, the number returned is
  4074.   * given by:
  4075.   * <p><code>
  4076.   * this.multiply(TEN.pow(new BigDecimal(-n)))
  4077.   * </code>
  4078.   * <p>
  4079.   * <code>n</code> may be negative, in which case the method returns
  4080.   * the same result as <code>movePointRight(-n)</code>.
  4081.   *
  4082.   * @param  n The <code>int</code> specifying the number of places to
  4083.   *           move the decimal point leftwards.
  4084.   * @return   A <code>BigDecimal</code> derived from
  4085.   *           <code>this</code>, with the decimal point moved
  4086.   *           <code>n</code> places to the left.
  4087.   * @stable ICU 2.0
  4088.   */
  4089.  
  4090.  //--public com.ibm.icu.math.BigDecimal movePointLeft(int n){
  4091.  function movePointLeft(n) {
  4092.   //--com.ibm.icu.math.BigDecimal res;
  4093.   var res;
  4094.   // very little point in optimizing for shift of 0
  4095.   res=this.clone(this);
  4096.   res.exp=res.exp-n;
  4097.   return res.finish(this.plainMC,false); // finish sets form and checks exponent
  4098.   }
  4099.  
  4100.  /**
  4101.   * Returns a plain <code>BigDecimal</code> whose decimal point has
  4102.   * been moved to the right by a specified number of positions.
  4103.   * The parameter, <code>n</code>, specifies the number of positions to
  4104.   * move the decimal point.
  4105.   * That is, if <code>n</code> is 0 or positive, the number returned is
  4106.   * given by:
  4107.   * <p><code>
  4108.   * this.multiply(TEN.pow(new BigDecimal(n)))
  4109.   * </code>
  4110.   * <p>
  4111.   * <code>n</code> may be negative, in which case the method returns
  4112.   * the same result as <code>movePointLeft(-n)</code>.
  4113.   *
  4114.   * @param  n The <code>int</code> specifying the number of places to
  4115.   *           move the decimal point rightwards.
  4116.   * @return   A <code>BigDecimal</code> derived from
  4117.   *           <code>this</code>, with the decimal point moved
  4118.   *           <code>n</code> places to the right.
  4119.   * @stable ICU 2.0
  4120.   */
  4121.  
  4122.  //--public com.ibm.icu.math.BigDecimal movePointRight(int n){
  4123.  function movePointRight(n) {
  4124.   //--com.ibm.icu.math.BigDecimal res;
  4125.   var res;
  4126.   res=this.clone(this);
  4127.   res.exp=res.exp+n;
  4128.   return res.finish(this.plainMC,false);
  4129.   }
  4130.  
  4131.  /**
  4132.   * Returns the scale of this <code>BigDecimal</code>.
  4133.   * Returns a non-negative <code>int</code> which is the scale of the
  4134.   * number. The scale is the number of digits in the decimal part of
  4135.   * the number if the number were formatted without exponential
  4136.   * notation.
  4137.   *
  4138.   * @return An <code>int</code> whose value is the scale of this
  4139.   *         <code>BigDecimal</code>.
  4140.   * @stable ICU 2.0
  4141.   */
  4142.  
  4143.  //--public int scale(){
  4144.  function scale() {
  4145.   if (this.exp>=0)
  4146.    return 0; // scale can never be negative
  4147.   return -this.exp;
  4148.   }
  4149.  
  4150.  /**
  4151.   * Returns a plain <code>BigDecimal</code> with a given scale.
  4152.   * <p>
  4153.   * If the given scale (which must be zero or positive) is the same as
  4154.   * or greater than the length of the decimal part (the scale) of this
  4155.   * <code>BigDecimal</code> then trailing zeros will be added to the
  4156.   * decimal part as necessary.
  4157.   * <p>
  4158.   * If the given scale is less than the length of the decimal part (the
  4159.   * scale) of this <code>BigDecimal</code> then trailing digits
  4160.   * will be removed, and in this case an
  4161.   * <code>ArithmeticException</code> is thrown if any discarded digits
  4162.   * are non-zero.
  4163.   * <p>
  4164.   * The same as {@link #setScale(int, int)}, where the first parameter
  4165.   * is the scale, and the second is
  4166.   * <code>MathContext.ROUND_UNNECESSARY</code>.
  4167.   *
  4168.   * @param  scale The <code>int</code> specifying the scale of the
  4169.   *               resulting <code>BigDecimal</code>.
  4170.   * @return       A plain <code>BigDecimal</code> with the given scale.
  4171.   * @throws ArithmeticException if <code>scale</code> is negative.
  4172.   * @throws ArithmeticException if reducing scale would discard
  4173.   *               non-zero digits.
  4174.   * @stable ICU 2.0
  4175.   */
  4176.  
  4177.  //--public com.ibm.icu.math.BigDecimal setScale(int scale){
  4178.  //-- return setScale(scale,ROUND_UNNECESSARY);
  4179.  //-- }
  4180.  
  4181.  /**
  4182.   * Returns a plain <code>BigDecimal</code> with a given scale.
  4183.   * <p>
  4184.   * If the given scale (which must be zero or positive) is the same as
  4185.   * or greater than the length of the decimal part (the scale) of this
  4186.   * <code>BigDecimal</code> then trailing zeros will be added to the
  4187.   * decimal part as necessary.
  4188.   * <p>
  4189.   * If the given scale is less than the length of the decimal part (the
  4190.   * scale) of this <code>BigDecimal</code> then trailing digits
  4191.   * will be removed, and the rounding mode given by the second
  4192.   * parameter is used to determine if the remaining digits are
  4193.   * affected by a carry.
  4194.   * In this case, an <code>IllegalArgumentException</code> is thrown if
  4195.   * <code>round</code> is not a valid rounding mode.
  4196.   * <p>
  4197.   * If <code>round</code> is <code>MathContext.ROUND_UNNECESSARY</code>,
  4198.   * an <code>ArithmeticException</code> is thrown if any discarded
  4199.   * digits are non-zero.
  4200.   *
  4201.   * @param  scale The <code>int</code> specifying the scale of the
  4202.   *               resulting <code>BigDecimal</code>.
  4203.   * @param  round The <code>int</code> rounding mode to be used for
  4204.   *               the division (see the {@link MathContext} class).
  4205.   * @return       A plain <code>BigDecimal</code> with the given scale.
  4206.   * @throws IllegalArgumentException if <code>round</code> is not a
  4207.   *               valid rounding mode.
  4208.   * @throws ArithmeticException if <code>scale</code> is negative.
  4209.   * @throws ArithmeticException if <code>round</code> is
  4210.   *               <code>MathContext.ROUND_UNNECESSARY</code>, and
  4211.   *               reducing scale would discard non-zero digits.
  4212.   * @stable ICU 2.0
  4213.   */
  4214.  
  4215.  //--public com.ibm.icu.math.BigDecimal setScale(int scale,int round){
  4216.  function setScale() {
  4217.   var round;
  4218.   if (setScale.arguments.length == 2)
  4219.    {
  4220.     round = setScale.arguments[1];
  4221.    }
  4222.   else if (setScale.arguments.length == 1)
  4223.    {
  4224.     round = this.ROUND_UNNECESSARY;
  4225.    }
  4226.   else
  4227.    {
  4228.     throw "setScale(): " + setScale.arguments.length + " given; expected 1 or 2";
  4229.    }
  4230.   var scale = setScale.arguments[0];
  4231.   //--int ourscale;
  4232.   var ourscale;
  4233.   //--com.ibm.icu.math.BigDecimal res;
  4234.   var res;
  4235.   //--int padding=0;
  4236.   var padding=0;
  4237.   //--int newlen=0;
  4238.   var newlen=0;
  4239.   // at present this naughtily only checks the round value if it is
  4240.   // needed (used), for speed
  4241.   ourscale=this.scale();
  4242.   if (ourscale==scale)  // already correct scale
  4243.    if (this.form==MathContext.prototype.PLAIN)  // .. and form
  4244.     return this;
  4245.   res=this.clone(this); // need copy
  4246.   if (ourscale<=scale)
  4247.    { // simply zero-padding/changing form
  4248.     // if ourscale is 0 we may have lots of 0s to add
  4249.     if (ourscale==0)
  4250.      padding=res.exp+scale;
  4251.     else
  4252.      padding=scale-ourscale;
  4253.     res.mant=this.extend(res.mant,res.mant.length+padding);
  4254.     res.exp=-scale; // as requested
  4255.    }
  4256.   else
  4257.    {/* ourscale>scale: shortening, probably */
  4258.     if (scale<0)
  4259.      //--throw new java.lang.ArithmeticException("Negative scale:"+" "+scale);
  4260.      throw "setScale(): Negative scale: " + scale;
  4261.     // [round() will raise exception if invalid round]
  4262.     newlen=res.mant.length-((ourscale-scale)); // [<=0 is OK]
  4263.     res=res.round(newlen,round); // round to required length
  4264.     // This could have shifted left if round (say) 0.9->1[.0]
  4265.     // Repair if so by adding a zero and reducing exponent
  4266.     if (res.exp!=(-scale))
  4267.      {
  4268.       res.mant=this.extend(res.mant,res.mant.length+1);
  4269.       res.exp=res.exp-1;
  4270.      }
  4271.    }
  4272.   res.form=MathContext.prototype.PLAIN; // by definition
  4273.   return res;
  4274.   }
  4275.  
  4276.  /**
  4277.   * Converts this <code>BigDecimal</code> to a <code>short</code>.
  4278.   * If the <code>BigDecimal</code> has a non-zero decimal part or is
  4279.   * out of the possible range for a <code>short</code> (16-bit signed
  4280.   * integer) result then an <code>ArithmeticException</code> is thrown.
  4281.   *
  4282.   * @return A <code>short</code> equal in value to <code>this</code>.
  4283.   * @throws ArithmeticException if <code>this</code> has a non-zero
  4284.   *                 decimal part, or will not fit in a
  4285.   *                 <code>short</code>.
  4286.   * @stable ICU 2.0
  4287.   */
  4288.  
  4289.  //--public short shortValueExact(){
  4290.  //-- int num;
  4291.  //-- num=this.intValueExact(); // will check decimal part too
  4292.  //-- if ((num>32767)|(num<(-32768)))
  4293.  //--  throw new java.lang.ArithmeticException("Conversion overflow:"+" "+this.toString());
  4294.  //-- return (short)num;
  4295.  //-- }
  4296.  
  4297.  /**
  4298.   * Returns the sign of this <code>BigDecimal</code>, as an
  4299.   * <code>int</code>.
  4300.   * This returns the <i>signum</i> function value that represents the
  4301.   * sign of this <code>BigDecimal</code>.
  4302.   * That is, -1 if the <code>BigDecimal</code> is negative, 0 if it is
  4303.   * numerically equal to zero, or 1 if it is positive.
  4304.   *
  4305.   * @return An <code>int</code> which is -1 if the
  4306.   *         <code>BigDecimal</code> is negative, 0 if it is
  4307.   *         numerically equal to zero, or 1 if it is positive.
  4308.   * @stable ICU 2.0
  4309.   */
  4310.  
  4311.  //--public int signum(){
  4312.  function signum() {
  4313.   return this.ind; // [note this assumes values for ind.]
  4314.   }
  4315.  
  4316.  /**
  4317.   * Converts this <code>BigDecimal</code> to a
  4318.   * <code>java.math.BigDecimal</code>.
  4319.   * <p>
  4320.   * This is an exact conversion; the result is the same as if the
  4321.   * <code>BigDecimal</code> were formatted as a plain number without
  4322.   * any rounding or exponent and then the
  4323.   * <code>java.math.BigDecimal(java.lang.String)</code> constructor
  4324.   * were used to construct the result.
  4325.   * <p>
  4326.   * <i>(Note: this method is provided only in the
  4327.   * <code>com.ibm.icu.math</code> version of the BigDecimal class.
  4328.   * It would not be present in a <code>java.math</code> version.)</i>
  4329.   *
  4330.   * @return The <code>java.math.BigDecimal</code> equal in value
  4331.   *         to this <code>BigDecimal</code>.
  4332.   * @stable ICU 2.0
  4333.   */
  4334.  
  4335.  //--public java.math.BigDecimal toBigDecimal(){
  4336.  //-- return new java.math.BigDecimal(this.unscaledValue(),this.scale());
  4337.  //-- }
  4338.  
  4339.  /**
  4340.   * Converts this <code>BigDecimal</code> to a
  4341.   * <code>java.math.BigInteger</code>.
  4342.   * <p>
  4343.   * Any decimal part is truncated (discarded).
  4344.   * If an exception is desired should the decimal part be non-zero,
  4345.   * use {@link #toBigIntegerExact()}.
  4346.   *
  4347.   * @return The <code>java.math.BigInteger</code> equal in value
  4348.   *         to the integer part of this <code>BigDecimal</code>.
  4349.   * @stable ICU 2.0
  4350.   */
  4351.  
  4352.  //--public java.math.BigInteger toBigInteger(){
  4353.  //-- com.ibm.icu.math.BigDecimal res=null;
  4354.  //-- int newlen=0;
  4355.  //-- byte newmant[]=null;
  4356.  //-- {/*select*/
  4357.  //-- if ((exp>=0)&(form==com.ibm.icu.math.MathContext.PLAIN))
  4358.  //--  res=this; // can layout simply
  4359.  //-- else if (exp>=0)
  4360.  //--  {
  4361.  //--   res=clone(this); // safe copy
  4362.  //--   res.form=(byte)com.ibm.icu.math.MathContext.PLAIN; // .. and request PLAIN
  4363.  //--  }
  4364.  //-- else{
  4365.  //--  { // exp<0; scale to be truncated
  4366.  //--   // we could use divideInteger, but we may as well be quicker
  4367.  //--   if (((int)-this.exp)>=this.mant.length)
  4368.  //--    res=ZERO; // all blows away
  4369.  //--   else
  4370.  //--    {
  4371.  //--     res=clone(this); // safe copy
  4372.  //--     newlen=res.mant.length+res.exp;
  4373.  //--     newmant=new byte[newlen]; // [shorter]
  4374.  //--     java.lang.System.arraycopy((java.lang.Object)res.mant,0,(java.lang.Object)newmant,0,newlen);
  4375.  //--     res.mant=newmant;
  4376.  //--     res.form=(byte)com.ibm.icu.math.MathContext.PLAIN;
  4377.  //--     res.exp=0;
  4378.  //--    }
  4379.  //--  }
  4380.  //-- }
  4381.  //-- }
  4382.  //-- return new BigInteger(new java.lang.String(res.layout()));
  4383.  //-- }
  4384.  
  4385.  /**
  4386.   * Converts this <code>BigDecimal</code> to a
  4387.   * <code>java.math.BigInteger</code>.
  4388.   * <p>
  4389.   * An exception is thrown if the decimal part (if any) is non-zero.
  4390.   *
  4391.   * @return The <code>java.math.BigInteger</code> equal in value
  4392.   *         to the integer part of this <code>BigDecimal</code>.
  4393.   * @throws ArithmeticException if <code>this</code> has a non-zero
  4394.   *         decimal part.
  4395.   * @stable ICU 2.0
  4396.   */
  4397.  
  4398.  //--public java.math.BigInteger toBigIntegerExact(){
  4399.  //-- /* test any trailing decimal part */
  4400.  //-- if (exp<0)
  4401.  //--  { // possible decimal part
  4402.  //--   /* all decimal places must be 0; note exp<0 */
  4403.  //--   if ((!(allzero(mant,mant.length+exp))))
  4404.  //--    throw new java.lang.ArithmeticException("Decimal part non-zero:"+" "+this.toString());
  4405.  //--  }
  4406.  //-- return toBigInteger();
  4407.  //-- }
  4408.  
  4409.  /**
  4410.   * Returns the <code>BigDecimal</code> as a character array.
  4411.   * The result of this method is the same as using the
  4412.   * sequence <code>toString().toCharArray()</code>, but avoids creating
  4413.   * the intermediate <code>String</code> and <code>char[]</code>
  4414.   * objects.
  4415.   *
  4416.   * @return The <code>char[]</code> array corresponding to this
  4417.   *         <code>BigDecimal</code>.
  4418.   * @stable ICU 2.0
  4419.   */
  4420.  
  4421.  //--public char[] toCharArray(){
  4422.  //-- return layout();
  4423.  //-- }
  4424.  
  4425.  /**
  4426.   * Returns the <code>BigDecimal</code> as a <code>String</code>.
  4427.   * This returns a <code>String</code> that exactly represents this
  4428.   * <code>BigDecimal</code>, as defined in the decimal documentation
  4429.   * (see {@link BigDecimal class header}).
  4430.   * <p>
  4431.   * By definition, using the {@link #BigDecimal(String)} constructor
  4432.   * on the result <code>String</code> will create a
  4433.   * <code>BigDecimal</code> that is exactly equal to the original
  4434.   * <code>BigDecimal</code>.
  4435.   *
  4436.   * @return The <code>String</code> exactly corresponding to this
  4437.   *         <code>BigDecimal</code>.
  4438.   * @see    #format(int, int)
  4439.   * @see    #format(int, int, int, int, int, int)
  4440.   * @see    #toCharArray()
  4441.   * @stable ICU 2.0
  4442.   */
  4443.  
  4444.  //--public java.lang.String toString(){
  4445.  function toString() {
  4446.   return this.layout().join("");
  4447.   }
  4448.  
  4449.  /**
  4450.   * Returns the number as a <code>BigInteger</code> after removing the
  4451.   * scale.
  4452.   * That is, the number is expressed as a plain number, any decimal
  4453.   * point is then removed (retaining the digits of any decimal part),
  4454.   * and the result is then converted to a <code>BigInteger</code>.
  4455.   *
  4456.   * @return The <code>java.math.BigInteger</code> equal in value to
  4457.   *         this <code>BigDecimal</code> multiplied by ten to the
  4458.   *         power of <code>this.scale()</code>.
  4459.   * @stable ICU 2.0
  4460.   */
  4461.  
  4462.  //--public java.math.BigInteger unscaledValue(){
  4463.  //-- com.ibm.icu.math.BigDecimal res=null;
  4464.  //-- if (exp>=0)
  4465.  //--  res=this;
  4466.  //-- else
  4467.  //--  {
  4468.  //--   res=clone(this); // safe copy
  4469.  //--   res.exp=0; // drop scale
  4470.  //--  }
  4471.  //-- return res.toBigInteger();
  4472.  //-- }
  4473.  
  4474.  /**
  4475.   * Translates a <code>double</code> to a <code>BigDecimal</code>.
  4476.   * <p>
  4477.   * Returns a <code>BigDecimal</code> which is the decimal
  4478.   * representation of the 64-bit signed binary floating point
  4479.   * parameter. If the parameter is infinite, or is not a number (NaN),
  4480.   * a <code>NumberFormatException</code> is thrown.
  4481.   * <p>
  4482.   * The number is constructed as though <code>num</code> had been
  4483.   * converted to a <code>String</code> using the
  4484.   * <code>Double.toString()</code> method and the
  4485.   * {@link #BigDecimal(java.lang.String)} constructor had then been used.
  4486.   * This is typically not an exact conversion.
  4487.   *
  4488.   * @param  dub The <code>double</code> to be translated.
  4489.   * @return     The <code>BigDecimal</code> equal in value to
  4490.   *             <code>dub</code>.
  4491.   * @throws NumberFormatException if the parameter is infinite or
  4492.   *             not a number.
  4493.   * @stable ICU 2.0
  4494.   */
  4495.  
  4496.  //--public static com.ibm.icu.math.BigDecimal valueOf(double dub){
  4497.  //-- // Reminder: a zero double returns '0.0', so we cannot fastpath to
  4498.  //-- // use the constant ZERO.  This might be important enough to justify
  4499.  //-- // a factory approach, a cache, or a few private constants, later.
  4500.  //-- return new com.ibm.icu.math.BigDecimal((new java.lang.Double(dub)).toString());
  4501.  //-- }
  4502.  
  4503.  /**
  4504.   * Translates a <code>long</code> to a <code>BigDecimal</code>.
  4505.   * That is, returns a plain <code>BigDecimal</code> whose value is
  4506.   * equal to the given <code>long</code>.
  4507.   *
  4508.   * @param  lint The <code>long</code> to be translated.
  4509.   * @return      The <code>BigDecimal</code> equal in value to
  4510.   *              <code>lint</code>.
  4511.   * @stable ICU 2.0
  4512.   */
  4513.  
  4514.  //--public static com.ibm.icu.math.BigDecimal valueOf(long lint){
  4515.  //-- return valueOf(lint,0);
  4516.  //-- }
  4517.  
  4518.  /**
  4519.   * Translates a <code>long</code> to a <code>BigDecimal</code> with a
  4520.   * given scale.
  4521.   * That is, returns a plain <code>BigDecimal</code> whose unscaled
  4522.   * value is equal to the given <code>long</code>, adjusted by the
  4523.   * second parameter, <code>scale</code>.
  4524.   * <p>
  4525.   * The result is given by:
  4526.   * <p><code>
  4527.   * (new BigDecimal(lint)).divide(TEN.pow(new BigDecimal(scale)))
  4528.   * </code>
  4529.   * <p>
  4530.   * A <code>NumberFormatException</code> is thrown if <code>scale</code>
  4531.   * is negative.
  4532.   *
  4533.   * @param  lint  The <code>long</code> to be translated.
  4534.   * @param  scale The <code>int</code> scale to be applied.
  4535.   * @return       The <code>BigDecimal</code> equal in value to
  4536.   *               <code>lint</code>.
  4537.   * @throws NumberFormatException if the scale is negative.
  4538.   * @stable ICU 2.0
  4539.   */
  4540.  
  4541.  //--public static com.ibm.icu.math.BigDecimal valueOf(long lint,int scale){
  4542.  //-- com.ibm.icu.math.BigDecimal res=null;
  4543.  //-- {/*select*/
  4544.  //-- if (lint==0)
  4545.  //--  res=ZERO;
  4546.  //-- else if (lint==1)
  4547.  //--  res=ONE;
  4548.  //-- else if (lint==10)
  4549.  //--  res=TEN;
  4550.  //-- else{
  4551.  //--  res=new com.ibm.icu.math.BigDecimal(lint);
  4552.  //-- }
  4553.  //-- }
  4554.  //-- if (scale==0)
  4555.  //--  return res;
  4556.  //-- if (scale<0)
  4557.  //--  throw new java.lang.NumberFormatException("Negative scale:"+" "+scale);
  4558.  //-- res=clone(res); // safe copy [do not mutate]
  4559.  //-- res.exp=(int)-scale; // exponent is -scale
  4560.  //-- return res;
  4561.  //-- }
  4562.  
  4563.  /* ---------------------------------------------------------------- */
  4564.  /* Private methods                                                  */
  4565.  /* ---------------------------------------------------------------- */
  4566.  
  4567.  /* <sgml> Return char array value of a BigDecimal (conversion from
  4568.        BigDecimal to laid-out canonical char array).
  4569.     <p>The mantissa will either already have been rounded (following an
  4570.        operation) or will be of length appropriate (in the case of
  4571.        construction from an int, for example).
  4572.     <p>We must not alter the mantissa, here.
  4573.     <p>'form' describes whether we are to use exponential notation (and
  4574.        if so, which), or if we are to lay out as a plain/pure numeric.
  4575.     </sgml> */
  4576.  
  4577.  //--private char[] layout(){
  4578.  function layout() {
  4579.   //--char cmant[];
  4580.   var cmant;
  4581.   //--int i=0;
  4582.   var i=0;
  4583.   //--java.lang.StringBuffer sb=null;
  4584.   var sb=null;
  4585.   //--int euse=0;
  4586.   var euse=0;
  4587.   //--int sig=0;
  4588.   var sig=0;
  4589.   //--char csign=0;
  4590.   var csign=0;
  4591.   //--char rec[]=null;
  4592.   var rec=null;
  4593.   //--int needsign;
  4594.   var needsign;
  4595.   //--int mag;
  4596.   var mag;
  4597.   //--int len=0;
  4598.   var len=0;
  4599.   cmant=new Array(this.mant.length); // copy byte[] to a char[]
  4600.   {var $18=this.mant.length;i=0;i:for(;$18>0;$18--,i++){
  4601.    cmant[i]=this.mant[i]+'';
  4602.    }
  4603.   }/*i*/
  4604.  
  4605.   if (this.form!=MathContext.prototype.PLAIN)
  4606.    {/* exponential notation needed */
  4607.     //--sb=new java.lang.StringBuffer(cmant.length+15); // -x.xxxE+999999999
  4608.     sb="";
  4609.     if (this.ind==this.isneg)
  4610.      sb += '-';
  4611.     euse=(this.exp+cmant.length)-1; // exponent to use
  4612.     /* setup sig=significant digits and copy to result */
  4613.     if (this.form==MathContext.prototype.SCIENTIFIC)
  4614.      { // [default]
  4615.       sb += cmant[0]; // significant character
  4616.       if (cmant.length>1)  // have decimal part
  4617.        //--sb.append('.').append(cmant,1,cmant.length-1);
  4618.        sb += '.';
  4619.        sb += cmant.slice(1).join("");
  4620.      }
  4621.     else
  4622.      {engineering:do{
  4623.       sig=euse%3; // common
  4624.       if (sig<0)
  4625.        sig=3+sig; // negative exponent
  4626.       euse=euse-sig;
  4627.       sig++;
  4628.       if (sig>=cmant.length)
  4629.        { // zero padding may be needed
  4630.         //--sb.append(cmant,0,cmant.length);
  4631.         sb += cmant.join("");
  4632.         {var $19=sig-cmant.length;for(;$19>0;$19--){
  4633.          sb += '0';
  4634.          }
  4635.         }
  4636.        }
  4637.       else
  4638.        { // decimal point needed
  4639.         //--sb.append(cmant,0,sig).append('.').append(cmant,sig,cmant.length-sig);
  4640.         sb += cmant.slice(0,sig).join("");
  4641.         sb += '.';
  4642.         sb += cmant.slice(sig).join("");
  4643.        }
  4644.      }while(false);}/*engineering*/
  4645.     if (euse!=0)
  4646.      {
  4647.       if (euse<0)
  4648.        {
  4649.         csign='-';
  4650.         euse=-euse;
  4651.        }
  4652.       else
  4653.        csign='+';
  4654.       //--sb.append('E').append(csign).append(euse);
  4655.       sb += 'E';
  4656.       sb += csign;
  4657.       sb += euse;
  4658.      }
  4659.     //--rec=new Array(sb.length);
  4660.     //--Utility.getChars(sb, 0,sb.length(),rec,0);
  4661.     //--return rec;
  4662.     return sb.split("");
  4663.    }
  4664.  
  4665.   /* Here for non-exponential (plain) notation */
  4666.   if (this.exp==0)
  4667.    {/* easy */
  4668.     if (this.ind>=0)
  4669.      return cmant; // non-negative integer
  4670.     rec=new Array(cmant.length+1);
  4671.     rec[0]='-';
  4672.     //--java.lang.System.arraycopy((java.lang.Object)cmant,0,(java.lang.Object)rec,1,cmant.length);
  4673.     this.arraycopy(cmant,0,rec,1,cmant.length);
  4674.     return rec;
  4675.    }
  4676.  
  4677.   /* Need a '.' and/or some zeros */
  4678.   needsign=((this.ind==this.isneg)?1:0); // space for sign?  0 or 1
  4679.  
  4680.   /* MAG is the position of the point in the mantissa (index of the
  4681.      character it follows) */
  4682.   mag=this.exp+cmant.length;
  4683.  
  4684.   if (mag<1)
  4685.    {/* 0.00xxxx form */
  4686.     len=(needsign+2)-this.exp; // needsign+2+(-mag)+cmant.length
  4687.     rec=new Array(len);
  4688.     if (needsign!=0)
  4689.      rec[0]='-';
  4690.     rec[needsign]='0';
  4691.     rec[needsign+1]='.';
  4692.     {var $20=-mag;i=needsign+2;i:for(;$20>0;$20--,i++){ // maybe none
  4693.      rec[i]='0';
  4694.      }
  4695.     }/*i*/
  4696.     //--java.lang.System.arraycopy((java.lang.Object)cmant,0,(java.lang.Object)rec,(needsign+2)-mag,cmant.length);
  4697.     this.arraycopy(cmant,0,rec,(needsign+2)-mag,cmant.length);
  4698.     return rec;
  4699.    }
  4700.  
  4701.   if (mag>cmant.length)
  4702.    {/* xxxx0000 form */
  4703.     len=needsign+mag;
  4704.     rec=new Array(len);
  4705.     if (needsign!=0)
  4706.      rec[0]='-';
  4707.     //--java.lang.System.arraycopy((java.lang.Object)cmant,0,(java.lang.Object)rec,needsign,cmant.length);
  4708.     this.arraycopy(cmant,0,rec,needsign,cmant.length);
  4709.     {var $21=mag-cmant.length;i=needsign+cmant.length;i:for(;$21>0;$21--,i++){ // never 0
  4710.      rec[i]='0';
  4711.      }
  4712.     }/*i*/
  4713.     return rec;
  4714.    }
  4715.  
  4716.   /* decimal point is in the middle of the mantissa */
  4717.   len=(needsign+1)+cmant.length;
  4718.   rec=new Array(len);
  4719.   if (needsign!=0)
  4720.    rec[0]='-';
  4721.   //--java.lang.System.arraycopy((java.lang.Object)cmant,0,(java.lang.Object)rec,needsign,mag);
  4722.   this.arraycopy(cmant,0,rec,needsign,mag);
  4723.   rec[needsign+mag]='.';
  4724.   //--java.lang.System.arraycopy((java.lang.Object)cmant,mag,(java.lang.Object)rec,(needsign+mag)+1,cmant.length-mag);
  4725.   this.arraycopy(cmant,mag,rec,(needsign+mag)+1,cmant.length-mag);
  4726.   return rec;
  4727.   }
  4728.  
  4729.  /* <sgml> Checks a BigDecimal argument to ensure it's a true integer
  4730.        in a given range.
  4731.     <p>If OK, returns it as an int. </sgml> */
  4732.  // [currently only used by pow]
  4733.  
  4734.  //--private int intcheck(int min,int max){
  4735.  function intcheck(min, max) {
  4736.   //--int i;
  4737.   var i;
  4738.   i=this.intValueExact(); // [checks for non-0 decimal part]
  4739.   // Use same message as though intValueExact failed due to size
  4740.   if ((i<min)||(i>max))
  4741.    throw "intcheck(): Conversion overflow: "+i;
  4742.   return i;
  4743.   }
  4744.  
  4745.  /* <sgml> Carry out division operations. </sgml> */
  4746.  /*
  4747.     Arg1 is operation code: D=divide, I=integer divide, R=remainder
  4748.     Arg2 is the rhs.
  4749.     Arg3 is the context.
  4750.     Arg4 is explicit scale iff code='D' or 'I' (-1 if none).
  4752.     Underlying algorithm (complications for Remainder function and
  4753.     scaled division are omitted for clarity):
  4755.       Test for x/0 and then 0/x
  4756.       Exp =Exp1 - Exp2
  4757.       Exp =Exp +len(var1) -len(var2)
  4758.       Sign=Sign1 * Sign2
  4759.       Pad accumulator (Var1) to double-length with 0's (pad1)
  4760.       Pad Var2 to same length as Var1
  4761.       B2B=1st two digits of var2, +1 to allow for roundup
  4762.       have=0
  4763.       Do until (have=digits+1 OR residue=0)
  4764.         if exp<0 then if integer divide/residue then leave
  4765.         this_digit=0
  4766.         Do forever
  4767.            compare numbers
  4768.            if <0 then leave inner_loop
  4769.            if =0 then (- quick exit without subtract -) do
  4770.               this_digit=this_digit+1; output this_digit
  4771.               leave outer_loop; end
  4772.            Compare lengths of numbers (mantissae):
  4773.            If same then CA=first_digit_of_Var1
  4774.                    else CA=first_two_digits_of_Var1
  4775.            mult=ca*10/b2b   -- Good and safe guess at divisor
  4776.            if mult=0 then mult=1
  4777.            this_digit=this_digit+mult
  4778.            subtract
  4779.            end inner_loop
  4780.          if have\=0 | this_digit\=0 then do
  4781.            output this_digit
  4782.            have=have+1; end
  4783.          var2=var2/10
  4784.          exp=exp-1
  4785.          end outer_loop
  4786.       exp=exp+1   -- set the proper exponent
  4787.       if have=0 then generate answer=0
  4788.       Return to FINISHED
  4789.       Result defined by MATHV1
  4791.     For extended commentary, see DMSRCN.
  4792.   */
  4793.  
  4794.  //--private com.ibm.icu.math.BigDecimal dodivide(char code,com.ibm.icu.math.BigDecimal rhs,com.ibm.icu.math.MathContext set,int scale){
  4795.  function dodivide(code, rhs, set, scale) {
  4796.   //--com.ibm.icu.math.BigDecimal lhs;
  4797.   var lhs;
  4798.   //--int reqdig;
  4799.   var reqdig;
  4800.   //--int newexp;
  4801.   var newexp;
  4802.   //--com.ibm.icu.math.BigDecimal res;
  4803.   var res;
  4804.   //--int newlen;
  4805.   var newlen;
  4806.   //--byte var1[];
  4807.   var var1;
  4808.   //--int var1len;
  4809.   var var1len;
  4810.   //--byte var2[];
  4811.   var var2;
  4812.   //--int var2len;
  4813.   var var2len;
  4814.   //--int b2b;
  4815.   var b2b;
  4816.   //--int have;
  4817.   var have;
  4818.   //--int thisdigit=0;
  4819.   var thisdigit=0;
  4820.   //--int i=0;
  4821.   var i=0;
  4822.   //--byte v2=0;
  4823.   var v2=0;
  4824.   //--int ba=0;
  4825.   var ba=0;
  4826.   //--int mult=0;
  4827.   var mult=0;
  4828.   //--int start=0;
  4829.   var start=0;
  4830.   //--int padding=0;
  4831.   var padding=0;
  4832.   //--int d=0;
  4833.   var d=0;
  4834.   //--byte newvar1[]=null;
  4835.   var newvar1=null;
  4836.   //--byte lasthave=0;
  4837.   var lasthave=0;
  4838.   //--int actdig=0;
  4839.   var actdig=0;
  4840.   //--byte newmant[]=null;
  4841.   var newmant=null;
  4842.  
  4843.   if (set.lostDigits)
  4844.    this.checkdigits(rhs,set.digits);
  4845.   lhs=this; // name for clarity
  4846.  
  4847.   // [note we must have checked lostDigits before the following checks]
  4848.   if (rhs.ind==0)
  4849.    throw "dodivide(): Divide by 0"; // includes 0/0
  4850.   if (lhs.ind==0)
  4851.    { // 0/x => 0 [possibly with .0s]
  4852.     if (set.form!=MathContext.prototype.PLAIN)
  4853.      return this.ZERO;
  4854.     if (scale==(-1))
  4855.      return lhs;
  4856.     return lhs.setScale(scale);
  4857.    }
  4858.  
  4859.   /* Prepare numbers according to BigDecimal rules */
  4860.   reqdig=set.digits; // local copy (heavily used)
  4861.   if (reqdig>0)
  4862.    {
  4863.     if (lhs.mant.length>reqdig)
  4864.      lhs=this.clone(lhs).round(set);
  4865.     if (rhs.mant.length>reqdig)
  4866.      rhs=this.clone(rhs).round(set);
  4867.    }
  4868.   else
  4869.    {/* scaled divide */
  4870.     if (scale==(-1))
  4871.      scale=lhs.scale();
  4872.     // set reqdig to be at least large enough for the computation
  4873.     reqdig=lhs.mant.length; // base length
  4874.     // next line handles both positive lhs.exp and also scale mismatch
  4875.     if (scale!=(-lhs.exp))
  4876.      reqdig=(reqdig+scale)+lhs.exp;
  4877.     reqdig=(reqdig-((rhs.mant.length-1)))-rhs.exp; // reduce by RHS effect
  4878.     if (reqdig<lhs.mant.length)
  4879.      reqdig=lhs.mant.length; // clamp
  4880.     if (reqdig<rhs.mant.length)
  4881.      reqdig=rhs.mant.length; // ..
  4882.    }
  4883.  
  4884.   /* precalculate exponent */
  4885.   newexp=((lhs.exp-rhs.exp)+lhs.mant.length)-rhs.mant.length;
  4886.   /* If new exponent -ve, then some quick exits are possible */
  4887.   if (newexp<0)
  4888.    if (code!='D')
  4889.     {
  4890.      if (code=='I')
  4891.       return this.ZERO; // easy - no integer part
  4892.      /* Must be 'R'; remainder is [finished clone of] input value */
  4893.      return this.clone(lhs).finish(set,false);
  4894.     }
  4895.  
  4896.   /* We need slow division */
  4897.   res=new BigDecimal(); // where we'll build result
  4898.   res.ind=(lhs.ind*rhs.ind); // final sign (for D/I)
  4899.   res.exp=newexp; // initial exponent (for D/I)
  4900.   res.mant=this.createArrayWithZeros(reqdig+1); // where build the result
  4901.  
  4902.   /* Now [virtually pad the mantissae with trailing zeros */
  4903.   // Also copy the LHS, which will be our working array
  4904.   newlen=(reqdig+reqdig)+1;
  4905.   var1=this.extend(lhs.mant,newlen); // always makes longer, so new safe array
  4906.   var1len=newlen; // [remaining digits are 0]
  4907.  
  4908.   var2=rhs.mant;
  4909.   var2len=newlen;
  4910.  
  4911.   /* Calculate first two digits of rhs (var2), +1 for later estimations */
  4912.   b2b=(var2[0]*10)+1;
  4913.   if (var2.length>1)
  4914.    b2b=b2b+var2[1];
  4915.  
  4916.   /* start the long-division loops */
  4917.   have=0;
  4918.   {outer:for(;;){
  4919.    thisdigit=0;
  4920.    /* find the next digit */
  4921.    {inner:for(;;){
  4922.     if (var1len<var2len)
  4923.      break inner; // V1 too low
  4924.     if (var1len==var2len)
  4925.      { // compare needed
  4926.       {compare:do{ // comparison
  4927.        {var $22=var1len;i=0;i:for(;$22>0;$22--,i++){
  4928.         // var1len is always <= var1.length
  4929.         if (i<var2.length)
  4930.          v2=var2[i];
  4931.         else
  4932.          v2=0;
  4933.         if (var1[i]<v2)
  4934.          break inner; // V1 too low
  4935.         if (var1[i]>v2)
  4936.          break compare; // OK to subtract
  4937.         }
  4938.        }/*i*/
  4939.        /* reach here if lhs and rhs are identical; subtraction will
  4940.           increase digit by one, and the residue will be 0 so we
  4941.           are done; leave the loop with residue set to 0 (in case
  4942.           code is 'R' or ROUND_UNNECESSARY or a ROUND_HALF_xxxx is
  4943.           being checked) */
  4944.        thisdigit++;
  4945.        res.mant[have]=thisdigit;
  4946.        have++;
  4947.        var1[0]=0; // residue to 0 [this is all we'll test]
  4948.        // var1len=1      -- [optimized out]
  4949.        break outer;
  4950.       }while(false);}/*compare*/
  4951.       /* prepare for subtraction.  Estimate BA (lengths the same) */
  4952.       ba=var1[0]; // use only first digit
  4953.      } // lengths the same
  4954.     else
  4955.      {/* lhs longer than rhs */
  4956.       /* use first two digits for estimate */
  4957.       ba=var1[0]*10;
  4958.       if (var1len>1)
  4959.        ba=ba+var1[1];
  4960.      }
  4961.     /* subtraction needed; V1>=V2 */
  4962.     mult=div((ba*10),b2b);
  4963.     if (mult==0)
  4964.      mult=1;
  4965.     thisdigit=thisdigit+mult;
  4966.     // subtract; var1 reusable
  4967.     var1=this.byteaddsub(var1,var1len,var2,var2len,-mult,true);
  4968.     if (var1[0]!=0)
  4969.      continue inner; // maybe another subtract needed
  4970.     /* V1 now probably has leading zeros, remove leading 0's and try
  4971.        again. (It could be longer than V2) */
  4972.     {var $23=var1len-2;start=0;start:for(;start<=$23;start++){
  4973.      if (var1[start]!=0)
  4974.       break start;
  4975.      var1len--;
  4976.      }
  4977.     }/*start*/
  4978.     if (start==0)
  4979.      continue inner;
  4980.     // shift left
  4981.     //--java.lang.System.arraycopy((java.lang.Object)var1,start,(java.lang.Object)var1,0,var1len);
  4982.     this.arraycopy(var1,start,var1,0,var1len);
  4983.     }
  4984.    }/*inner*/
  4985.  
  4986.    /* We have the next digit */
  4987.    if ((have!=0)||(thisdigit!=0))
  4988.     { // put the digit we got
  4989.      res.mant[have]=thisdigit;
  4990.      have++;
  4991.      if (have==(reqdig+1))
  4992.       break outer; // we have all we need
  4993.      if (var1[0]==0)
  4994.       break outer; // residue now 0
  4995.     }
  4996.    /* can leave now if a scaled divide and exponent is small enough */
  4997.    if (scale>=0)
  4998.     if ((-res.exp)>scale)
  4999.      break outer;
  5000.    /* can leave now if not Divide and no integer part left  */
  5001.    if (code!='D')
  5002.     if (res.exp<=0)
  5003.      break outer;
  5004.    res.exp=res.exp-1; // reduce the exponent
  5005.    /* to get here, V1 is less than V2, so divide V2 by 10 and go for
  5006.       the next digit */
  5007.    var2len--;
  5008.    }
  5009.   }/*outer*/
  5010.  
  5011.   /* here when we have finished dividing, for some reason */
  5012.   // have is the number of digits we collected in res.mant
  5013.   if (have==0)
  5014.    have=1; // res.mant[0] is 0; we always want a digit
  5015.  
  5016.   if ((code=='I')||(code=='R'))
  5017.    {/* check for integer overflow needed */
  5018.     if ((have+res.exp)>reqdig)
  5019.      throw "dodivide(): Integer overflow";
  5020.  
  5021.     if (code=='R')
  5022.      {remainder:do{
  5023.       /* We were doing Remainder -- return the residue */
  5024.       if (res.mant[0]==0)  // no integer part was found
  5025.        return this.clone(lhs).finish(set,false); // .. so return lhs, canonical
  5026.       if (var1[0]==0)
  5027.        return this.ZERO; // simple 0 residue
  5028.       res.ind=lhs.ind; // sign is always as LHS
  5029.       /* Calculate the exponent by subtracting the number of padding zeros
  5030.          we added and adding the original exponent */
  5031.       padding=((reqdig+reqdig)+1)-lhs.mant.length;
  5032.       res.exp=(res.exp-padding)+lhs.exp;
  5033.  
  5034.       /* strip insignificant padding zeros from residue, and create/copy
  5035.          the resulting mantissa if need be */
  5036.       d=var1len;
  5037.       {i=d-1;i:for(;i>=1;i--){if(!((res.exp<lhs.exp)&&(res.exp<rhs.exp)))break;
  5038.        if (var1[i]!=0)
  5039.         break i;
  5040.        d--;
  5041.        res.exp=res.exp+1;
  5042.        }
  5043.       }/*i*/
  5044.       if (d<var1.length)
  5045.        {/* need to reduce */
  5046.         newvar1=new Array(d);
  5047.         //--java.lang.System.arraycopy((java.lang.Object)var1,0,(java.lang.Object)newvar1,0,d); // shorten
  5048.         this.arraycopy(var1,0,newvar1,0,d);
  5049.         var1=newvar1;
  5050.        }
  5051.       res.mant=var1;
  5052.       return res.finish(set,false);
  5053.      }while(false);}/*remainder*/
  5054.    }
  5055.  
  5056.   else
  5057.    {/* 'D' -- no overflow check needed */
  5058.     // If there was a residue then bump the final digit (iff 0 or 5)
  5059.     // so that the residue is visible for ROUND_UP, ROUND_HALF_xxx and
  5060.     // ROUND_UNNECESSARY checks (etc.) later.
  5061.     // [if we finished early, the residue will be 0]
  5062.     if (var1[0]!=0)
  5063.      { // residue not 0
  5064.       lasthave=res.mant[have-1];
  5065.       if (((lasthave%5))==0)
  5066.        res.mant[have-1]=(lasthave+1);
  5067.      }
  5068.    }
  5069.  
  5070.   /* Here for Divide or Integer Divide */
  5071.   // handle scaled results first ['I' always scale 0, optional for 'D']
  5072.   if (scale>=0)
  5073.    {scaled:do{
  5074.     // say 'scale have res.exp len' scale have res.exp res.mant.length
  5075.     if (have!=res.mant.length)
  5076.      // already padded with 0's, so just adjust exponent
  5077.      res.exp=res.exp-((res.mant.length-have));
  5078.     // calculate number of digits we really want [may be 0]
  5079.     actdig=res.mant.length-(((-res.exp)-scale));
  5080.     res.round(actdig,set.roundingMode); // round to desired length
  5081.     // This could have shifted left if round (say) 0.9->1[.0]
  5082.     // Repair if so by adding a zero and reducing exponent
  5083.     if (res.exp!=(-scale))
  5084.      {
  5085.       res.mant=this.extend(res.mant,res.mant.length+1);
  5086.       res.exp=res.exp-1;
  5087.      }
  5088.     return res.finish(set,true); // [strip if not PLAIN]
  5089.    }while(false);}/*scaled*/
  5090.  
  5091.   // reach here only if a non-scaled
  5092.   if (have==res.mant.length)
  5093.    { // got digits+1 digits
  5094.     res.round(set);
  5095.     have=reqdig;
  5096.    }
  5097.   else
  5098.    {/* have<=reqdig */
  5099.     if (res.mant[0]==0)
  5100.      return this.ZERO; // fastpath
  5101.     // make the mantissa truly just 'have' long
  5102.     // [we could let finish do this, during strip, if we adjusted
  5103.     // the exponent; however, truncation avoids the strip loop]
  5104.     newmant=new Array(have); // shorten
  5105.     //--java.lang.System.arraycopy((java.lang.Object)res.mant,0,(java.lang.Object)newmant,0,have);
  5106.     this.arraycopy(res.mant,0,newmant,0,have);
  5107.     res.mant=newmant;
  5108.    }
  5109.   return res.finish(set,true);
  5110.   }
  5111.  
  5112.  /* <sgml> Report a conversion exception. </sgml> */
  5113.  
  5114.  //--private void bad(char s[]){
  5115.  function bad(prefix, s) {
  5116.   throw prefix + "Not a number: "+s;
  5117.   }
  5118.  
  5119.  /* <sgml> Report a bad argument to a method. </sgml>
  5120.     Arg1 is method name
  5121.     Arg2 is argument position
  5122.     Arg3 is what was found */
  5123.  
  5124.  //--private void badarg(java.lang.String name,int pos,java.lang.String value){
  5125.  function badarg(name, pos, value) {
  5126.   throw "Bad argument "+pos+" to "+name+": "+value;
  5127.   }
  5128.  
  5129.  /* <sgml> Extend byte array to given length, padding with 0s.  If no
  5130.     extension is required then return the same array. </sgml>
  5132.     Arg1 is the source byte array
  5133.     Arg2 is the new length (longer)
  5134.     */
  5135.  
  5136.  //--private static final byte[] extend(byte inarr[],int newlen){
  5137.  function extend(inarr, newlen) {
  5138.   //--byte newarr[];
  5139.   var newarr;
  5140.   if (inarr.length==newlen)
  5141.    return inarr;
  5142.   newarr=createArrayWithZeros(newlen);
  5143.   //--java.lang.System.arraycopy((java.lang.Object)inarr,0,(java.lang.Object)newarr,0,inarr.length);
  5144.   this.arraycopy(inarr,0,newarr,0,inarr.length);
  5145.   // 0 padding is carried out by the JVM on allocation initialization
  5146.   return newarr;
  5147.   }
  5148.  
  5149.  /* <sgml> Add or subtract two >=0 integers in byte arrays
  5150.     <p>This routine performs the calculation:
  5151.     <pre>
  5152.     C=A+(B*M)
  5153.     </pre>
  5154.     Where M is in the range -9 through +9
  5155.     <p>
  5156.     If M<0 then A>=B must be true, so the result is always
  5157.     non-negative.
  5159.     Leading zeros are not removed after a subtraction.  The result is
  5160.     either the same length as the longer of A and B, or 1 longer than
  5161.     that (if a carry occurred).
  5163.     A is not altered unless Arg6 is 1.
  5164.     B is never altered.
  5166.     Arg1 is A
  5167.     Arg2 is A length to use (if longer than A, pad with 0's)
  5168.     Arg3 is B
  5169.     Arg4 is B length to use (if longer than B, pad with 0's)
  5170.     Arg5 is M, the multiplier
  5171.     Arg6 is 1 if A can be used to build the result (if it fits)
  5173.     This routine is severely performance-critical; *any* change here
  5174.     must be measured (timed) to assure no performance degradation.
  5175.     */
  5176.  // 1996.02.20 -- enhanced version of DMSRCN algorithm (1981)
  5177.  // 1997.10.05 -- changed to byte arrays (from char arrays)
  5178.  // 1998.07.01 -- changed to allow destructive reuse of LHS
  5179.  // 1998.07.01 -- changed to allow virtual lengths for the arrays
  5180.  // 1998.12.29 -- use lookaside for digit/carry calculation
  5181.  // 1999.08.07 -- avoid multiply when mult=1, and make db an int
  5182.  // 1999.12.22 -- special case m=-1, also drop 0 special case
  5183.  
  5184.  //--private static final byte[] byteaddsub(byte a[],int avlen,byte b[],int bvlen,int m,boolean reuse){
  5185.  function byteaddsub(a, avlen, b, bvlen, m, reuse) {
  5186.   //--int alength;
  5187.   var alength;
  5188.   //--int blength;
  5189.   var blength;
  5190.   //--int ap;
  5191.   var ap;
  5192.   //--int bp;
  5193.   var bp;
  5194.   //--int maxarr;
  5195.   var maxarr;
  5196.   //--byte reb[];
  5197.   var reb;
  5198.   //--boolean quickm;
  5199.   var quickm;
  5200.   //--int digit;
  5201.   var digit;
  5202.   //--int op=0;
  5203.   var op=0;
  5204.   //--int dp90=0;
  5205.   var dp90=0;
  5206.   //--byte newarr[];
  5207.   var newarr;
  5208.   //--int i=0;
  5209.   var i=0;
  5210.  
  5211.  
  5212.  
  5213.  
  5214.   // We'll usually be right if we assume no carry
  5215.   alength=a.length; // physical lengths
  5216.   blength=b.length; // ..
  5217.   ap=avlen-1; // -> final (rightmost) digit
  5218.   bp=bvlen-1; // ..
  5219.   maxarr=bp;
  5220.   if (maxarr<ap)
  5221.    maxarr=ap;
  5222.   reb=null; // result byte array
  5223.   if (reuse)
  5224.    if ((maxarr+1)==alength)
  5225.     reb=a; // OK to reuse A
  5226.   if (reb==null){
  5227.    reb=this.createArrayWithZeros(maxarr+1); // need new array
  5228.    }
  5229.  
  5230.   quickm=false; // 1 if no multiply needed
  5231.   if (m==1)
  5232.    quickm=true; // most common
  5233.   else
  5234.    if (m==(-1))
  5235.     quickm=true; // also common
  5236.  
  5237.   digit=0; // digit, with carry or borrow
  5238.   {op=maxarr;op:for(;op>=0;op--){
  5239.    if (ap>=0)
  5240.     {
  5241.      if (ap<alength)
  5242.       digit=digit+a[ap]; // within A
  5243.      ap--;
  5244.     }
  5245.    if (bp>=0)
  5246.     {
  5247.      if (bp<blength)
  5248.       { // within B
  5249.        if (quickm)
  5250.         {
  5251.          if (m>0)
  5252.           digit=digit+b[bp]; // most common
  5253.          else
  5254.           digit=digit-b[bp]; // also common
  5255.         }
  5256.        else
  5257.         digit=digit+(b[bp]*m);
  5258.       }
  5259.      bp--;
  5260.     }
  5261.    /* result so far (digit) could be -90 through 99 */
  5262.    if (digit<10)
  5263.     if (digit>=0)
  5264.      {quick:do{ // 0-9
  5265.       reb[op]=digit;
  5266.       digit=0; // no carry
  5267.       continue op;
  5268.      }while(false);}/*quick*/
  5269.    dp90=digit+90;
  5270.    reb[op]=this.bytedig[dp90]; // this digit
  5271.    digit=this.bytecar[dp90]; // carry or borrow
  5272.    }
  5273.   }/*op*/
  5274.  
  5275.   if (digit==0)
  5276.    return reb; // no carry
  5277.   // following line will become an Assert, later
  5278.   // if digit<0 then signal ArithmeticException("internal.error ["digit"]")
  5279.  
  5280.   /* We have carry -- need to make space for the extra digit */
  5281.   newarr=null;
  5282.   if (reuse)
  5283.    if ((maxarr+2)==a.length)
  5284.     newarr=a; // OK to reuse A
  5285.   if (newarr==null)
  5286.    newarr=new Array(maxarr+2);
  5287.   newarr[0]=digit; // the carried digit ..
  5288.   // .. and all the rest [use local loop for short numbers]
  5289.   //--if (maxarr<10)
  5290.    {var $24=maxarr+1;i=0;i:for(;$24>0;$24--,i++){
  5291.     newarr[i+1]=reb[i];
  5292.     }
  5293.    }/*i*/
  5294.   //--else
  5295.    //--java.lang.System.arraycopy((java.lang.Object)reb,0,(java.lang.Object)newarr,1,maxarr+1);
  5296.   return newarr;
  5297.   }
  5298.  
  5299.  /* <sgml> Initializer for digit array properties (lookaside). </sgml>
  5300.     Returns the digit array, and initializes the carry array. */
  5301.  
  5302.  //--private static final byte[] diginit(){
  5303.  function diginit() {
  5304.   //--byte work[];
  5305.   var work;
  5306.   //--int op=0;
  5307.   var op=0;
  5308.   //--int digit=0;
  5309.   var digit=0;
  5310.   work=new Array((90+99)+1);
  5311.   {op=0;op:for(;op<=(90+99);op++){
  5312.    digit=op-90;
  5313.    if (digit>=0)
  5314.     {
  5315.      work[op]=(digit%10);
  5316.      BigDecimal.prototype.bytecar[op]=(div(digit,10)); // calculate carry
  5317.      continue op;
  5318.     }
  5319.    // borrowing...
  5320.    digit=digit+100; // yes, this is right [consider -50]
  5321.    work[op]=(digit%10);
  5322.    BigDecimal.prototype.bytecar[op]=((div(digit,10))-10); // calculate borrow [NB: - after %]
  5323.    }
  5324.   }/*op*/
  5325.   return work;
  5326.   }
  5327.  
  5328.  /* <sgml> Create a copy of BigDecimal object for local use.
  5329.     <p>This does NOT make a copy of the mantissa array.
  5330.     </sgml>
  5331.     Arg1 is the BigDecimal to clone (non-null)
  5332.     */
  5333.  
  5334.  //--private static final com.ibm.icu.math.BigDecimal clone(com.ibm.icu.math.BigDecimal dec){
  5335.  function clone(dec) {
  5336.   //--com.ibm.icu.math.BigDecimal copy;
  5337.   var copy;
  5338.   copy=new BigDecimal();
  5339.   copy.ind=dec.ind;
  5340.   copy.exp=dec.exp;
  5341.   copy.form=dec.form;
  5342.   copy.mant=dec.mant;
  5343.   return copy;
  5344.   }
  5345.  
  5346.  /* <sgml> Check one or two numbers for lost digits. </sgml>
  5347.     Arg1 is RHS (or null, if none)
  5348.     Arg2 is current DIGITS setting
  5349.     returns quietly or throws an exception */
  5350.  
  5351.  //--private void checkdigits(com.ibm.icu.math.BigDecimal rhs,int dig){
  5352.  function checkdigits(rhs, dig) {
  5353.   if (dig==0)
  5354.    return; // don't check if digits=0
  5355.   // first check lhs...
  5356.   if (this.mant.length>dig)
  5357.    if ((!(this.allzero(this.mant,dig))))
  5358.     throw "Too many digits: "+this.toString();
  5359.   if (rhs==null)
  5360.    return; // monadic
  5361.   if (rhs.mant.length>dig)
  5362.    if ((!(this.allzero(rhs.mant,dig))))
  5363.     throw "Too many digits: "+rhs.toString();
  5364.   return;
  5365.   }
  5366.  
  5367.  /* <sgml> Round to specified digits, if necessary. </sgml>
  5368.     Arg1 is requested MathContext [with length and rounding mode]
  5369.     returns this, for convenience */
  5370.  
  5371.  //--private com.ibm.icu.math.BigDecimal round(com.ibm.icu.math.MathContext set){
  5372.  //-- return round(set.digits,set.roundingMode);
  5373.  //-- }
  5374.  
  5375.  /* <sgml> Round to specified digits, if necessary.
  5376.     Arg1 is requested length (digits to round to)
  5377.             [may be <=0 when called from format, dodivide, etc.]
  5378.     Arg2 is rounding mode
  5379.     returns this, for convenience
  5381.     ind and exp are adjusted, but not cleared for a mantissa of zero
  5383.     The length of the mantissa returned will be Arg1, except when Arg1
  5384.     is 0, in which case the returned mantissa length will be 1.
  5385.     </sgml>
  5386.     */
  5387.  
  5388.  //private com.ibm.icu.math.BigDecimal round(int len,int mode){
  5389.  function round() {
  5390.   var len;
  5391.   var mode;
  5392.   if (round.arguments.length == 2)
  5393.    {
  5394.     len = round.arguments[0];
  5395.     mode = round.arguments[1];
  5396.    }
  5397.   else if (round.arguments.length == 1)
  5398.    {
  5399.     var set = round.arguments[0];
  5400.     len = set.digits;
  5401.     mode = set.roundingMode;
  5402.    }
  5403.   else
  5404.    {
  5405.     throw "round(): " + round.arguments.length + " arguments given; expected 1 or 2";
  5406.    }
  5407.   //int adjust;
  5408.   var adjust;
  5409.   //int sign;
  5410.   var sign;
  5411.   //byte oldmant[];
  5412.   var oldmant;
  5413.   //boolean reuse=false;
  5414.   var reuse=false;
  5415.   //--byte first=0;
  5416.   var first=0;
  5417.   //--int increment;
  5418.   var increment;
  5419.   //--byte newmant[]=null;
  5420.   var newmant=null;
  5421.   adjust=this.mant.length-len;
  5422.   if (adjust<=0)
  5423.    return this; // nowt to do
  5424.  
  5425.   this.exp=this.exp+adjust; // exponent of result
  5426.   sign=this.ind; // save [assumes -1, 0, 1]
  5427.   oldmant=this.mant; // save
  5428.   if (len>0)
  5429.    {
  5430.     // remove the unwanted digits
  5431.     this.mant=new Array(len);
  5432.     //--java.lang.System.arraycopy((java.lang.Object)oldmant,0,(java.lang.Object)mant,0,len);
  5433.     this.arraycopy(oldmant,0,this.mant,0,len);
  5434.     reuse=true; // can reuse mantissa
  5435.     first=oldmant[len]; // first of discarded digits
  5436.    }
  5437.   else
  5438.    {/* len<=0 */
  5439.     this.mant=this.ZERO.mant;
  5440.     this.ind=this.iszero;
  5441.     reuse=false; // cannot reuse mantissa
  5442.     if (len==0)
  5443.      first=oldmant[0];
  5444.     else
  5445.      first=0; // [virtual digit]
  5446.    }
  5447.  
  5448.   // decide rounding adjustment depending on mode, sign, and discarded digits
  5449.   increment=0; // bumper
  5450.   {modes:do{/*select*/
  5451.   if (mode==this.ROUND_HALF_UP)
  5452.    { // default first [most common]
  5453.     if (first>=5)
  5454.      increment=sign;
  5455.    }
  5456.   else if (mode==this.ROUND_UNNECESSARY)
  5457.    { // default for setScale()
  5458.     // discarding any non-zero digits is an error
  5459.     if ((!(this.allzero(oldmant,len))))
  5460.      throw "round(): Rounding necessary";
  5461.    }
  5462.   else if (mode==this.ROUND_HALF_DOWN)
  5463.    { // 0.5000 goes down
  5464.     if (first>5)
  5465.      increment=sign;
  5466.     else
  5467.      if (first==5)
  5468.       if ((!(this.allzero(oldmant,len+1))))
  5469.        increment=sign;
  5470.    }
  5471.   else if (mode==this.ROUND_HALF_EVEN)
  5472.    { // 0.5000 goes down if left digit even
  5473.     if (first>5)
  5474.      increment=sign;
  5475.     else
  5476.      if (first==5)
  5477.       {
  5478.        if ((!(this.allzero(oldmant,len+1))))
  5479.         increment=sign;
  5480.        else /* 0.5000 */
  5481.         if ((((this.mant[this.mant.length-1])%2))==1)
  5482.          increment=sign;
  5483.       }
  5484.    }
  5485.   else if (mode==this.ROUND_DOWN)
  5486.    {} // never increment
  5487.   else if (mode==this.ROUND_UP)
  5488.    { // increment if discarded non-zero
  5489.     if ((!(this.allzero(oldmant,len))))
  5490.      increment=sign;
  5491.    }
  5492.   else if (mode==this.ROUND_CEILING)
  5493.    { // more positive
  5494.     if (sign>0)
  5495.      if ((!(this.allzero(oldmant,len))))
  5496.       increment=sign;
  5497.    }
  5498.   else if (mode==this.ROUND_FLOOR)
  5499.    { // more negative
  5500.     if (sign<0)
  5501.      if ((!(this.allzero(oldmant,len))))
  5502.       increment=sign;
  5503.    }
  5504.   else{
  5505.    throw "round(): Bad round value: "+mode;
  5506.   }
  5507.   }while(false);}/*modes*/
  5508.  
  5509.   if (increment!=0)
  5510.    {bump:do{
  5511.     if (this.ind==this.iszero)
  5512.      {
  5513.       // we must not subtract from 0, but result is trivial anyway
  5514.       this.mant=this.ONE.mant;
  5515.       this.ind=increment;
  5516.      }
  5517.     else
  5518.      {
  5519.       // mantissa is non-0; we can safely add or subtract 1
  5520.       if (this.ind==this.isneg)
  5521.        increment=-increment;
  5522.       newmant=this.byteaddsub(this.mant,this.mant.length,this.ONE.mant,1,increment,reuse);
  5523.       if (newmant.length>this.mant.length)
  5524.        { // had a carry
  5525.         // drop rightmost digit and raise exponent
  5526.         this.exp++;
  5527.         // mant is already the correct length
  5528.         //java.lang.System.arraycopy((java.lang.Object)newmant,0,(java.lang.Object)mant,0,mant.length);
  5529.         this.arraycopy(newmant,0,this.mant,0,this.mant.length);
  5530.        }
  5531.       else
  5532.        this.mant=newmant;
  5533.      }
  5534.    }while(false);}/*bump*/
  5535.   // rounding can increase exponent significantly
  5536.   if (this.exp>this.MaxExp)
  5537.    throw "round(): Exponent Overflow: "+this.exp;
  5538.   return this;
  5539.   }
  5540.  
  5541.  /* <sgml> Test if rightmost digits are all 0.
  5542.     Arg1 is a mantissa array to test
  5543.     Arg2 is the offset of first digit to check
  5544.             [may be negative; if so, digits to left are 0's]
  5545.     returns 1 if all the digits starting at Arg2 are 0
  5547.     Arg2 may be beyond array bounds, in which case 1 is returned
  5548.     </sgml> */
  5549.  
  5550.  //--private static final boolean allzero(byte array[],int start){
  5551.  function allzero(array, start) {
  5552.   //--int i=0;
  5553.   var i=0;
  5554.   if (start<0)
  5555.    start=0;
  5556.   {var $25=array.length-1;i=start;i:for(;i<=$25;i++){
  5557.    if (array[i]!=0)
  5558.     return false;
  5559.    }
  5560.   }/*i*/
  5561.   return true;
  5562.   }
  5563.  
  5564.  /* <sgml> Carry out final checks and canonicalization
  5565.     <p>
  5566.     This finishes off the current number by:
  5567.       1. Rounding if necessary (NB: length includes leading zeros)
  5568.       2. Stripping trailing zeros (if requested and \PLAIN)
  5569.       3. Stripping leading zeros (always)
  5570.       4. Selecting exponential notation (if required)
  5571.       5. Converting a zero result to just '0' (if \PLAIN)
  5572.     In practice, these operations overlap and share code.
  5573.     It always sets form.
  5574.     </sgml>
  5575.     Arg1 is requested MathContext (length to round to, trigger, and FORM)
  5576.     Arg2 is 1 if trailing insignificant zeros should be removed after
  5577.          round (for division, etc.), provided that set.form isn't PLAIN.
  5578.    returns this, for convenience
  5579.    */
  5580.  
  5581.  //--private com.ibm.icu.math.BigDecimal finish(com.ibm.icu.math.MathContext set,boolean strip){
  5582.  function finish(set, strip) {
  5583.   //--int d=0;
  5584.   var d=0;
  5585.   //--int i=0;
  5586.   var i=0;
  5587.   //--byte newmant[]=null;
  5588.   var newmant=null;
  5589.   //--int mag=0;
  5590.   var mag=0;
  5591.   //--int sig=0;
  5592.   var sig=0;
  5593.   /* Round if mantissa too long and digits requested */
  5594.   if (set.digits!=0)
  5595.    if (this.mant.length>set.digits)
  5596.     this.round(set);
  5597.  
  5598.   /* If strip requested (and standard formatting), remove
  5599.      insignificant trailing zeros. */
  5600.   if (strip)
  5601.    if (set.form!=MathContext.prototype.PLAIN)
  5602.     {
  5603.      d=this.mant.length;
  5604.      /* see if we need to drop any trailing zeros */
  5605.      {i=d-1;i:for(;i>=1;i--){
  5606.       if (this.mant[i]!=0)
  5607.        break i;
  5608.       d--;
  5609.       this.exp++;
  5610.       }
  5611.      }/*i*/
  5612.      if (d<this.mant.length)
  5613.       {/* need to reduce */
  5614.        newmant=new Array(d);
  5615.        //--java.lang.System.arraycopy((java.lang.Object)this.mant,0,(java.lang.Object)newmant,0,d);
  5616.        this.arraycopy(this.mant,0,newmant,0,d);
  5617.        this.mant=newmant;
  5618.       }
  5619.     }
  5620.  
  5621.   this.form=MathContext.prototype.PLAIN; // preset
  5622.  
  5623.   /* Now check for leading- and all- zeros in mantissa */
  5624.   {var $26=this.mant.length;i=0;i:for(;$26>0;$26--,i++){
  5625.    if (this.mant[i]!=0)
  5626.     {
  5627.      // non-0 result; ind will be correct
  5628.      // remove leading zeros [e.g., after subtract]
  5629.      if (i>0)
  5630.       {delead:do{
  5631.        newmant=new Array(this.mant.length-i);
  5632.        //--java.lang.System.arraycopy((java.lang.Object)this.mant,i,(java.lang.Object)newmant,0,this.mant.length-i);
  5633.        this.arraycopy(this.mant,i,newmant,0,this.mant.length-i);
  5634.        this.mant=newmant;
  5635.       }while(false);}/*delead*/
  5636.      // now determine form if not PLAIN
  5637.      mag=this.exp+this.mant.length;
  5638.      if (mag>0)
  5639.       { // most common path
  5640.        if (mag>set.digits)
  5641.         if (set.digits!=0)
  5642.          this.form=set.form;
  5643.        if ((mag-1)<=this.MaxExp)
  5644.         return this; // no overflow; quick return
  5645.       }
  5646.      else
  5647.       if (mag<(-5))
  5648.        this.form=set.form;
  5649.      /* check for overflow */
  5650.      mag--;
  5651.      if ((mag<this.MinExp)||(mag>this.MaxExp))
  5652.       {overflow:do{
  5653.        // possible reprieve if form is engineering
  5654.        if (this.form==MathContext.prototype.ENGINEERING)
  5655.         {
  5656.          sig=mag%3; // leftover
  5657.          if (sig<0)
  5658.           sig=3+sig; // negative exponent
  5659.          mag=mag-sig; // exponent to use
  5660.          // 1999.06.29: second test here must be MaxExp
  5661.          if (mag>=this.MinExp)
  5662.           if (mag<=this.MaxExp)
  5663.            break overflow;
  5664.         }
  5665.        throw "finish(): Exponent Overflow: "+mag;
  5666.       }while(false);}/*overflow*/
  5667.      return this;
  5668.     }
  5669.    }
  5670.   }/*i*/
  5671.  
  5672.   // Drop through to here only if mantissa is all zeros
  5673.   this.ind=this.iszero;
  5674.   {/*select*/
  5675.   if (set.form!=MathContext.prototype.PLAIN)
  5676.    this.exp=0; // standard result; go to '0'
  5677.   else if (this.exp>0)
  5678.    this.exp=0; // +ve exponent also goes to '0'
  5679.   else{
  5680.    // a plain number with -ve exponent; preserve and check exponent
  5681.    if (this.exp<this.MinExp)
  5682.     throw "finish(): Exponent Overflow: "+this.exp;
  5683.   }
  5684.   }
  5685.   this.mant=this.ZERO.mant; // canonical mantissa
  5686.   return this;
  5687.   }
  5688.  
  5689.  function isGreaterThan(other) {
  5690.   return this.compareTo(other) > 0;
  5691.  };
  5692.  function isLessThan(other) {
  5693.   return this.compareTo(other) < 0;
  5694.  };
  5695.  function isGreaterThanOrEqualTo(other) {
  5696.   return this.compareTo(other) >= 0;
  5697.  };
  5698.  function isLessThanOrEqualTo(other) {
  5699.   return this.compareTo(other) <= 0;
  5700.  };
  5701.  function isPositive() {
  5702.   return this.compareTo(BigDecimal.prototype.ZERO) > 0;
  5703.  };
  5704.  function isNegative() {
  5705.   return this.compareTo(BigDecimal.prototype.ZERO) < 0;
  5706.  };
  5707.  function isZero() {
  5708.   return this.compareTo(BigDecimal.prototype.ZERO) === 0;
  5709.  };
  5710. return BigDecimal;
  5711. })(MathContext); // BigDecimal depends on MathContext
  5712.  
  5713. if (typeof define === "function" && define.amd != null) {
  5714. 	// AMD-loader compatible resource declaration
  5715. 	// require('bigdecimal') will return JS Object:
  5716. 	// {'BigDecimal':BigDecimalPointer, 'MathContext':MathContextPointer}
  5717. 	define({'BigDecimal':BigDecimal, 'MathContext':MathContext});
  5718. } else if (typeof this === "object"){
  5719. 	// global-polluting outcome.
  5720. 	this.BigDecimal = BigDecimal;
  5721. 	this.MathContext = MathContext;
  5722. }
  5723.  
  5724. }).call(this); // in browser 'this' will be 'window' or simulated window object in AMD-loading scenarios.


再来一份min版本的：

  1. /*
  2.  Copyright (c) 2012 Daniel Trebbien and other contributors
  3. Portions Copyright (c) 2003 STZ-IDA and PTV AG, Karlsruhe, Germany
  4. Portions Copyright (c) 1995-2001 International Business Machines Corporation and others
  6. All rights reserved.
  8. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, provided that the above copyright notice(s) and this permission notice appear in all copies of the Software and that both the above copyright notice(s) and this permission notice appear in supporting documentation.
  10. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  12. Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization of the copyright holder.
  13. */
  14. (function(){var y=function(){function h(){this.form=this.digits=0;this.lostDigits=!1;this.roundingMode=0;var v=this.DEFAULT_FORM,r=this.DEFAULT_LOSTDIGITS,f=this.DEFAULT_ROUNDINGMODE;if(4==h.arguments.length)v=h.arguments[1],r=h.arguments[2],f=h.arguments[3];else if(3==h.arguments.length)v=h.arguments[1],r=h.arguments[2];else if(2==h.arguments.length)v=h.arguments[1];else if(1!=h.arguments.length)throw"MathContext(): "+h.arguments.length+" arguments given; expected 1 to 4";var t=h.arguments[0];if(t!=
  15. this.DEFAULT_DIGITS){if(t<this.MIN_DIGITS)throw"MathContext(): Digits too small: "+t;if(t>this.MAX_DIGITS)throw"MathContext(): Digits too large: "+t;}if(v!=this.SCIENTIFIC&&v!=this.ENGINEERING&&v!=this.PLAIN)throw"MathContext() Bad form value: "+v;if(!this.isValidRound(f))throw"MathContext(): Bad roundingMode value: "+f;this.digits=t;this.form=v;this.lostDigits=r;this.roundingMode=f}h.prototype.getDigits=function(){return this.digits};h.prototype.getForm=function(){return this.form};h.prototype.getLostDigits=
  16. function(){return this.lostDigits};h.prototype.getRoundingMode=function(){return this.roundingMode};h.prototype.toString=function(){var h=null,r=0,f=null,h=this.form==this.SCIENTIFIC?"SCIENTIFIC":this.form==this.ENGINEERING?"ENGINEERING":"PLAIN",t=this.ROUNDS.length,r=0;a:for(;0<t;t--,r++)if(this.roundingMode==this.ROUNDS[r]){f=this.ROUNDWORDS[r];break a}return"digits="+this.digits+" form="+h+" lostDigits="+(this.lostDigits?"1":"0")+" roundingMode="+f};h.prototype.isValidRound=function(h){var r=0,
  17. f=this.ROUNDS.length,r=0;for(;0<f;f--,r++)if(h==this.ROUNDS[r])return!0;return!1};h.PLAIN=h.prototype.PLAIN=0;h.SCIENTIFIC=h.prototype.SCIENTIFIC=1;h.ENGINEERING=h.prototype.ENGINEERING=2;h.ROUND_CEILING=h.prototype.ROUND_CEILING=2;h.ROUND_DOWN=h.prototype.ROUND_DOWN=1;h.ROUND_FLOOR=h.prototype.ROUND_FLOOR=3;h.ROUND_HALF_DOWN=h.prototype.ROUND_HALF_DOWN=5;h.ROUND_HALF_EVEN=h.prototype.ROUND_HALF_EVEN=6;h.ROUND_HALF_UP=h.prototype.ROUND_HALF_UP=4;h.ROUND_UNNECESSARY=h.prototype.ROUND_UNNECESSARY=7;
  18. h.ROUND_UP=h.prototype.ROUND_UP=0;h.prototype.DEFAULT_FORM=h.prototype.SCIENTIFIC;h.prototype.DEFAULT_DIGITS=9;h.prototype.DEFAULT_LOSTDIGITS=!1;h.prototype.DEFAULT_ROUNDINGMODE=h.prototype.ROUND_HALF_UP;h.prototype.MIN_DIGITS=0;h.prototype.MAX_DIGITS=999999999;h.prototype.ROUNDS=[h.prototype.ROUND_HALF_UP,h.prototype.ROUND_UNNECESSARY,h.prototype.ROUND_CEILING,h.prototype.ROUND_DOWN,h.prototype.ROUND_FLOOR,h.prototype.ROUND_HALF_DOWN,h.prototype.ROUND_HALF_EVEN,h.prototype.ROUND_UP];h.prototype.ROUNDWORDS=
  19. "ROUND_HALF_UP ROUND_UNNECESSARY ROUND_CEILING ROUND_DOWN ROUND_FLOOR ROUND_HALF_DOWN ROUND_HALF_EVEN ROUND_UP".split(" ");h.prototype.DEFAULT=new h(h.prototype.DEFAULT_DIGITS,h.prototype.DEFAULT_FORM,h.prototype.DEFAULT_LOSTDIGITS,h.prototype.DEFAULT_ROUNDINGMODE);return h}(),L=function(h){function v(a,b){return(a-a%b)/b}function r(a){var b=Array(a),c;for(c=0;c<a;++c)b[c]=0;return b}function f(){this.ind=0;this.form=h.prototype.PLAIN;this.mant=null;this.exp=0;if(0!=f.arguments.length){var a,b,c;
  20. 1==f.arguments.length?(a=f.arguments[0],b=0,c=a.length):(a=f.arguments[0],b=f.arguments[1],c=f.arguments[2]);"string"==typeof a&&(a=a.split(""));var d,e,n,g,k,l=0,m=0;e=!1;var q=m=m=l=0,p=0;g=0;0>=c&&this.bad("BigDecimal(): ",a);this.ind=this.ispos;"-"==a[0]?(c--,0==c&&this.bad("BigDecimal(): ",a),this.ind=this.isneg,b++):"+"==a[0]&&(c--,0==c&&this.bad("BigDecimal(): ",a),b++);e=d=!1;n=0;k=g=-1;q=c;l=b;a:for(;0<q;q--,l++){m=a[l];if("0"<=m&&"9">=m){k=l;n++;continue a}if("."==m){0<=g&&this.bad("BigDecimal(): ",
  21. a);g=l-b;continue a}if("e"!=m&&"E"!=m){("0">m||"9"<m)&&this.bad("BigDecimal(): ",a);d=!0;k=l;n++;continue a}l-b>c-2&&this.bad("BigDecimal(): ",a);e=!1;"-"==a[l+1]?(e=!0,l+=2):l="+"==a[l+1]?l+2:l+1;m=c-(l-b);(0==m||9<m)&&this.bad("BigDecimal(): ",a);c=m;m=l;for(;0<c;c--,m++)q=a[m],"0">q&&this.bad("BigDecimal(): ",a),"9"<q?this.bad("BigDecimal(): ",a):p=q-0,this.exp=10*this.exp+p;e&&(this.exp=-this.exp);e=!0;break a}0==n&&this.bad("BigDecimal(): ",a);0<=g&&(this.exp=this.exp+g-n);p=k-1;l=b;a:for(;l<=
  22. p;l++)if(m=a[l],"0"==m)b++,g--,n--;else if("."==m)b++,g--;else break a;this.mant=Array(n);m=b;if(d)for(b=n,l=0;0<b;b--,l++)l==g&&m++,q=a[m],"9">=q?this.mant[l]=q-0:this.bad("BigDecimal(): ",a),m++;else for(b=n,l=0;0<b;b--,l++)l==g&&m++,this.mant[l]=a[m]-0,m++;0==this.mant[0]?(this.ind=this.iszero,0<this.exp&&(this.exp=0),e&&(this.mant=this.ZERO.mant,this.exp=0)):e&&(this.form=h.prototype.SCIENTIFIC,g=this.exp+this.mant.length-1,(g<this.MinExp||g>this.MaxExp)&&this.bad("BigDecimal(): ",a))}}function t(){var a;
  23. if(1==t.arguments.length)a=t.arguments[0];else if(0==t.arguments.length)a=this.plainMC;else throw"abs(): "+t.arguments.length+" arguments given; expected 0 or 1";return this.ind==this.isneg?this.negate(a):this.plus(a)}function z(){var a;if(2==z.arguments.length)a=z.arguments[1];else if(1==z.arguments.length)a=this.plainMC;else throw"add(): "+z.arguments.length+" arguments given; expected 1 or 2";var b=z.arguments[0],c,d,e,n,g,k,l,m=0;d=m=0;var m=null,q=m=0,p=0,r=0,t=0,s=0;a.lostDigits&&this.checkdigits(b,
  24. a.digits);c=this;if(0==c.ind&&a.form!=h.prototype.PLAIN)return b.plus(a);if(0==b.ind&&a.form!=h.prototype.PLAIN)return c.plus(a);d=a.digits;0<d&&(c.mant.length>d&&(c=this.clone(c).round(a)),b.mant.length>d&&(b=this.clone(b).round(a)));e=new f;n=c.mant;g=c.mant.length;k=b.mant;l=b.mant.length;if(c.exp==b.exp)e.exp=c.exp;else if(c.exp>b.exp){m=g+c.exp-b.exp;if(m>=l+d+1&&0<d)return e.mant=n,e.exp=c.exp,e.ind=c.ind,g<d&&(e.mant=this.extend(c.mant,d),e.exp-=d-g),e.finish(a,!1);e.exp=b.exp;m>d+1&&0<d&&
  25. (m=m-d-1,l-=m,e.exp+=m,m=d+1);m>g&&(g=m)}else{m=l+b.exp-c.exp;if(m>=g+d+1&&0<d)return e.mant=k,e.exp=b.exp,e.ind=b.ind,l<d&&(e.mant=this.extend(b.mant,d),e.exp-=d-l),e.finish(a,!1);e.exp=c.exp;m>d+1&&0<d&&(m=m-d-1,g-=m,e.exp+=m,m=d+1);m>l&&(l=m)}e.ind=c.ind==this.iszero?this.ispos:c.ind;if((c.ind==this.isneg?1:0)==(b.ind==this.isneg?1:0))d=1;else{do{d=-1;do if(b.ind!=this.iszero)if(g<l||c.ind==this.iszero)m=n,n=k,k=m,m=g,g=l,l=m,e.ind=-e.ind;else if(!(g>l))c:for(q=m=0,p=n.length-1,r=k.length-1;;){if(m<=
  26. p)t=n[m];else{if(q>r){if(a.form!=h.prototype.PLAIN)return this.ZERO;break c}t=0}s=q<=r?k[q]:0;if(t!=s){t<s&&(m=n,n=k,k=m,m=g,g=l,l=m,e.ind=-e.ind);break c}m++;q++}while(0)}while(0)}e.mant=this.byteaddsub(n,g,k,l,d,!1);return e.finish(a,!1)}function A(){var a;if(2==A.arguments.length)a=A.arguments[1];else if(1==A.arguments.length)a=this.plainMC;else throw"compareTo(): "+A.arguments.length+" arguments given; expected 1 or 2";var b=A.arguments[0],c=0,c=0;a.lostDigits&&this.checkdigits(b,a.digits);if(this.ind==
  27. b.ind&&this.exp==b.exp){c=this.mant.length;if(c<b.mant.length)return-this.ind;if(c>b.mant.length)return this.ind;if(c<=a.digits||0==a.digits){a=c;c=0;for(;0<a;a--,c++){if(this.mant[c]<b.mant[c])return-this.ind;if(this.mant[c]>b.mant[c])return this.ind}return 0}}else{if(this.ind<b.ind)return-1;if(this.ind>b.ind)return 1}b=this.clone(b);b.ind=-b.ind;return this.add(b,a).ind}function u(){var a,b=-1;if(2==u.arguments.length)a="number"==typeof u.arguments[1]?new h(0,h.prototype.PLAIN,!1,u.arguments[1]):
  28. u.arguments[1];else if(3==u.arguments.length){b=u.arguments[1];if(0>b)throw"divide(): Negative scale: "+b;a=new h(0,h.prototype.PLAIN,!1,u.arguments[2])}else if(1==u.arguments.length)a=this.plainMC;else throw"divide(): "+u.arguments.length+" arguments given; expected between 1 and 3";return this.dodivide("D",u.arguments[0],a,b)}function B(){var a;if(2==B.arguments.length)a=B.arguments[1];else if(1==B.arguments.length)a=this.plainMC;else throw"divideInteger(): "+B.arguments.length+" arguments given; expected 1 or 2";
  29. return this.dodivide("I",B.arguments[0],a,0)}function C(){var a;if(2==C.arguments.length)a=C.arguments[1];else if(1==C.arguments.length)a=this.plainMC;else throw"max(): "+C.arguments.length+" arguments given; expected 1 or 2";var b=C.arguments[0];return 0<=this.compareTo(b,a)?this.plus(a):b.plus(a)}function D(){var a;if(2==D.arguments.length)a=D.arguments[1];else if(1==D.arguments.length)a=this.plainMC;else throw"min(): "+D.arguments.length+" arguments given; expected 1 or 2";var b=D.arguments[0];
  30. return 0>=this.compareTo(b,a)?this.plus(a):b.plus(a)}function E(){var a;if(2==E.arguments.length)a=E.arguments[1];else if(1==E.arguments.length)a=this.plainMC;else throw"multiply(): "+E.arguments.length+" arguments given; expected 1 or 2";var b=E.arguments[0],c,d,e,h=e=null,g,k=0,l,m=0,q=0;a.lostDigits&&this.checkdigits(b,a.digits);c=this;d=0;e=a.digits;0<e?(c.mant.length>e&&(c=this.clone(c).round(a)),b.mant.length>e&&(b=this.clone(b).round(a))):(0<c.exp&&(d+=c.exp),0<b.exp&&(d+=b.exp));c.mant.length<
  31. b.mant.length?(e=c.mant,h=b.mant):(e=b.mant,h=c.mant);g=e.length+h.length-1;k=9<e[0]*h[0]?g+1:g;l=new f;var k=this.createArrayWithZeros(k),p=e.length,m=0;for(;0<p;p--,m++)q=e[m],0!=q&&(k=this.byteaddsub(k,k.length,h,g,q,!0)),g--;l.ind=c.ind*b.ind;l.exp=c.exp+b.exp-d;l.mant=0==d?k:this.extend(k,k.length+d);return l.finish(a,!1)}function J(){var a;if(1==J.arguments.length)a=J.arguments[0];else if(0==J.arguments.length)a=this.plainMC;else throw"negate(): "+J.arguments.length+" arguments given; expected 0 or 1";
  32. var b;a.lostDigits&&this.checkdigits(null,a.digits);b=this.clone(this);b.ind=-b.ind;return b.finish(a,!1)}function K(){var a;if(1==K.arguments.length)a=K.arguments[0];else if(0==K.arguments.length)a=this.plainMC;else throw"plus(): "+K.arguments.length+" arguments given; expected 0 or 1";a.lostDigits&&this.checkdigits(null,a.digits);return a.form==h.prototype.PLAIN&&this.form==h.prototype.PLAIN&&(this.mant.length<=a.digits||0==a.digits)?this:this.clone(this).finish(a,!1)}function F(){var a;if(2==F.arguments.length)a=
  33. F.arguments[1];else if(1==F.arguments.length)a=this.plainMC;else throw"pow(): "+F.arguments.length+" arguments given; expected 1 or 2";var b=F.arguments[0],c,d,e,f=e=0,g,k=0;a.lostDigits&&this.checkdigits(b,a.digits);c=b.intcheck(this.MinArg,this.MaxArg);d=this;e=a.digits;if(0==e){if(b.ind==this.isneg)throw"pow(): Negative power: "+b.toString();e=0}else{if(b.mant.length+b.exp>e)throw"pow(): Too many digits: "+b.toString();d.mant.length>e&&(d=this.clone(d).round(a));f=b.mant.length+b.exp;e=e+f+1}e=
  34. new h(e,a.form,!1,a.roundingMode);f=this.ONE;if(0==c)return f;0>c&&(c=-c);g=!1;k=1;a:for(;;k++){c<<=1;0>c&&(g=!0,f=f.multiply(d,e));if(31==k)break a;if(!g)continue a;f=f.multiply(f,e)}0>b.ind&&(f=this.ONE.divide(f,e));return f.finish(a,!0)}function G(){var a;if(2==G.arguments.length)a=G.arguments[1];else if(1==G.arguments.length)a=this.plainMC;else throw"remainder(): "+G.arguments.length+" arguments given; expected 1 or 2";return this.dodivide("R",G.arguments[0],a,-1)}function H(){var a;if(2==H.arguments.length)a=
  35. H.arguments[1];else if(1==H.arguments.length)a=this.plainMC;else throw"subtract(): "+H.arguments.length+" arguments given; expected 1 or 2";var b=H.arguments[0];a.lostDigits&&this.checkdigits(b,a.digits);b=this.clone(b);b.ind=-b.ind;return this.add(b,a)}function w(){var a,b,c,d;if(6==w.arguments.length)a=w.arguments[2],b=w.arguments[3],c=w.arguments[4],d=w.arguments[5];else if(2==w.arguments.length)b=a=-1,c=h.prototype.SCIENTIFIC,d=this.ROUND_HALF_UP;else throw"format(): "+w.arguments.length+" arguments given; expected 2 or 6";
  36. var e=w.arguments[0],f=w.arguments[1],g,k=0,k=k=0,l=null,m=l=k=0;g=0;k=null;m=l=0;(-1>e||0==e)&&this.badarg("format",1,e);-1>f&&this.badarg("format",2,f);(-1>a||0==a)&&this.badarg("format",3,a);-1>b&&this.badarg("format",4,b);c!=h.prototype.SCIENTIFIC&&c!=h.prototype.ENGINEERING&&(-1==c?c=h.prototype.SCIENTIFIC:this.badarg("format",5,c));if(d!=this.ROUND_HALF_UP)try{-1==d?d=this.ROUND_HALF_UP:new h(9,h.prototype.SCIENTIFIC,!1,d)}catch(q){this.badarg("format",6,d)}g=this.clone(this);-1==b?g.form=h.prototype.PLAIN:
  37. g.ind==this.iszero?g.form=h.prototype.PLAIN:(k=g.exp+g.mant.length,g.form=k>b?c:-5>k?c:h.prototype.PLAIN);if(0<=f)a:for(;;){g.form==h.prototype.PLAIN?k=-g.exp:g.form==h.prototype.SCIENTIFIC?k=g.mant.length-1:(k=(g.exp+g.mant.length-1)%3,0>k&&(k=3+k),k++,k=k>=g.mant.length?0:g.mant.length-k);if(k==f)break a;if(k<f){l=this.extend(g.mant,g.mant.length+f-k);g.mant=l;g.exp-=f-k;if(g.exp<this.MinExp)throw"format(): Exponent Overflow: "+g.exp;break a}k-=f;if(k>g.mant.length){g.mant=this.ZERO.mant;g.ind=
  38. this.iszero;g.exp=0;continue a}l=g.mant.length-k;m=g.exp;g.round(l,d);if(g.exp-m==k)break a}b=g.layout();if(0<e){c=b.length;g=0;a:for(;0<c;c--,g++){if("."==b[g])break a;if("E"==b[g])break a}g>e&&this.badarg("format",1,e);if(g<e){k=Array(b.length+e-g);e-=g;l=0;for(;0<e;e--,l++)k[l]=" ";this.arraycopy(b,0,k,l,b.length);b=k}}if(0<a){e=b.length-1;g=b.length-1;a:for(;0<e;e--,g--)if("E"==b[g])break a;if(0==g){k=Array(b.length+a+2);this.arraycopy(b,0,k,0,b.length);a+=2;l=b.length;for(;0<a;a--,l++)k[l]=" ";
  39. b=k}else if(m=b.length-g-2,m>a&&this.badarg("format",3,a),m<a){k=Array(b.length+a-m);this.arraycopy(b,0,k,0,g+2);a-=m;l=g+2;for(;0<a;a--,l++)k[l]="0";this.arraycopy(b,g+2,k,l,m);b=k}}return b.join("")}function I(){var a;if(2==I.arguments.length)a=I.arguments[1];else if(1==I.arguments.length)a=this.ROUND_UNNECESSARY;else throw"setScale(): "+I.arguments.length+" given; expected 1 or 2";var b=I.arguments[0],c,d;c=c=0;c=this.scale();if(c==b&&this.form==h.prototype.PLAIN)return this;d=this.clone(this);
  40. if(c<=b)c=0==c?d.exp+b:b-c,d.mant=this.extend(d.mant,d.mant.length+c),d.exp=-b;else{if(0>b)throw"setScale(): Negative scale: "+b;c=d.mant.length-(c-b);d=d.round(c,a);d.exp!=-b&&(d.mant=this.extend(d.mant,d.mant.length+1),d.exp-=1)}d.form=h.prototype.PLAIN;return d}function y(){var a,b=0,c=0;a=Array(190);b=0;a:for(;189>=b;b++){c=b-90;if(0<=c){a[b]=c%10;f.prototype.bytecar[b]=v(c,10);continue a}c+=100;a[b]=c%10;f.prototype.bytecar[b]=v(c,10)-10}return a}function x(){var a,b;if(2==x.arguments.length)a=
  41. x.arguments[0],b=x.arguments[1];else if(1==x.arguments.length)b=x.arguments[0],a=b.digits,b=b.roundingMode;else throw"round(): "+x.arguments.length+" arguments given; expected 1 or 2";var c,d,e=!1,f=0,g;c=null;c=this.mant.length-a;if(0>=c)return this;this.exp+=c;c=this.ind;d=this.mant;0<a?(this.mant=Array(a),this.arraycopy(d,0,this.mant,0,a),e=!0,f=d[a]):(this.mant=this.ZERO.mant,this.ind=this.iszero,e=!1,f=0==a?d[0]:0);g=0;if(b==this.ROUND_HALF_UP)5<=f&&(g=c);else if(b==this.ROUND_UNNECESSARY){if(!this.allzero(d,
  42. a))throw"round(): Rounding necessary";}else if(b==this.ROUND_HALF_DOWN)5<f?g=c:5==f&&(this.allzero(d,a+1)||(g=c));else if(b==this.ROUND_HALF_EVEN)5<f?g=c:5==f&&(this.allzero(d,a+1)?1==this.mant[this.mant.length-1]%2&&(g=c):g=c);else if(b!=this.ROUND_DOWN)if(b==this.ROUND_UP)this.allzero(d,a)||(g=c);else if(b==this.ROUND_CEILING)0<c&&(this.allzero(d,a)||(g=c));else if(b==this.ROUND_FLOOR)0>c&&(this.allzero(d,a)||(g=c));else throw"round(): Bad round value: "+b;0!=g&&(this.ind==this.iszero?(this.mant=
  43. this.ONE.mant,this.ind=g):(this.ind==this.isneg&&(g=-g),c=this.byteaddsub(this.mant,this.mant.length,this.ONE.mant,1,g,e),c.length>this.mant.length?(this.exp++,this.arraycopy(c,0,this.mant,0,this.mant.length)):this.mant=c));if(this.exp>this.MaxExp)throw"round(): Exponent Overflow: "+this.exp;return this}f.prototype.div=v;f.prototype.arraycopy=function(a,b,c,d,e){var f;if(d>b)for(f=e-1;0<=f;--f)c[f+d]=a[f+b];else for(f=0;f<e;++f)c[f+d]=a[f+b]};f.prototype.createArrayWithZeros=r;f.prototype.abs=t;f.prototype.add=
  44. z;f.prototype.compareTo=A;f.prototype.divide=u;f.prototype.divideInteger=B;f.prototype.max=C;f.prototype.min=D;f.prototype.multiply=E;f.prototype.negate=J;f.prototype.plus=K;f.prototype.pow=F;f.prototype.remainder=G;f.prototype.subtract=H;f.prototype.equals=function(a){var b=0,c=null,d=null;if(null==a||!(a instanceof f)||this.ind!=a.ind)return!1;if(this.mant.length==a.mant.length&&this.exp==a.exp&&this.form==a.form)for(c=this.mant.length,b=0;0<c;c--,b++){if(this.mant[b]!=a.mant[b])return!1}else{c=
  45. this.layout();d=a.layout();if(c.length!=d.length)return!1;a=c.length;b=0;for(;0<a;a--,b++)if(c[b]!=d[b])return!1}return!0};f.prototype.format=w;f.prototype.intValueExact=function(){var a,b=0,c,d=0;a=0;if(this.ind==this.iszero)return 0;a=this.mant.length-1;if(0>this.exp){a+=this.exp;if(!this.allzero(this.mant,a+1))throw"intValueExact(): Decimal part non-zero: "+this.toString();if(0>a)return 0;b=0}else{if(9<this.exp+a)throw"intValueExact(): Conversion overflow: "+this.toString();b=this.exp}c=0;var e=
  46. a+b,d=0;for(;d<=e;d++)c*=10,d<=a&&(c+=this.mant[d]);if(9==a+b&&(a=v(c,1E9),a!=this.mant[0])){if(-2147483648==c&&this.ind==this.isneg&&2==this.mant[0])return c;throw"intValueExact(): Conversion overflow: "+this.toString();}return this.ind==this.ispos?c:-c};f.prototype.movePointLeft=function(a){var b;b=this.clone(this);b.exp-=a;return b.finish(this.plainMC,!1)};f.prototype.movePointRight=function(a){var b;b=this.clone(this);b.exp+=a;return b.finish(this.plainMC,!1)};f.prototype.scale=function(){return 0<=
  47. this.exp?0:-this.exp};f.prototype.setScale=I;f.prototype.signum=function(){return this.ind};f.prototype.toString=function(){return this.layout().join("")};f.prototype.layout=function(){var a,b=0,b=null,c=0,d=0;a=0;var d=null,e,b=0;a=Array(this.mant.length);c=this.mant.length;b=0;for(;0<c;c--,b++)a[b]=this.mant[b]+"";if(this.form!=h.prototype.PLAIN){b="";this.ind==this.isneg&&(b+="-");c=this.exp+a.length-1;if(this.form==h.prototype.SCIENTIFIC)b+=a[0],1<a.length&&(b+="."),b+=a.slice(1).join("");else if(d=
  48. c%3,0>d&&(d=3+d),c-=d,d++,d>=a.length)for(b+=a.join(""),a=d-a.length;0<a;a--)b+="0";else b+=a.slice(0,d).join(""),b=b+"."+a.slice(d).join("");0!=c&&(0>c?(a="-",c=-c):a="+",b+="E",b+=a,b+=c);return b.split("")}if(0==this.exp){if(0<=this.ind)return a;d=Array(a.length+1);d[0]="-";this.arraycopy(a,0,d,1,a.length);return d}c=this.ind==this.isneg?1:0;e=this.exp+a.length;if(1>e){b=c+2-this.exp;d=Array(b);0!=c&&(d[0]="-");d[c]="0";d[c+1]=".";var f=-e,b=c+2;for(;0<f;f--,b++)d[b]="0";this.arraycopy(a,0,d,c+
  49. 2-e,a.length);return d}if(e>a.length){d=Array(c+e);0!=c&&(d[0]="-");this.arraycopy(a,0,d,c,a.length);e-=a.length;b=c+a.length;for(;0<e;e--,b++)d[b]="0";return d}b=c+1+a.length;d=Array(b);0!=c&&(d[0]="-");this.arraycopy(a,0,d,c,e);d[c+e]=".";this.arraycopy(a,e,d,c+e+1,a.length-e);return d};f.prototype.intcheck=function(a,b){var c;c=this.intValueExact();if(c<a||c>b)throw"intcheck(): Conversion overflow: "+c;return c};f.prototype.dodivide=function(a,b,c,d){var e,n,g,k,l,m,q,p,t,r=0,s=0,u=0;n=n=s=s=s=
  50. 0;e=null;e=e=0;e=null;c.lostDigits&&this.checkdigits(b,c.digits);e=this;if(0==b.ind)throw"dodivide(): Divide by 0";if(0==e.ind)return c.form!=h.prototype.PLAIN?this.ZERO:-1==d?e:e.setScale(d);n=c.digits;0<n?(e.mant.length>n&&(e=this.clone(e).round(c)),b.mant.length>n&&(b=this.clone(b).round(c))):(-1==d&&(d=e.scale()),n=e.mant.length,d!=-e.exp&&(n=n+d+e.exp),n=n-(b.mant.length-1)-b.exp,n<e.mant.length&&(n=e.mant.length),n<b.mant.length&&(n=b.mant.length));g=e.exp-b.exp+e.mant.length-b.mant.length;
  51. if(0>g&&"D"!=a)return"I"==a?this.ZERO:this.clone(e).finish(c,!1);k=new f;k.ind=e.ind*b.ind;k.exp=g;k.mant=this.createArrayWithZeros(n+1);l=n+n+1;g=this.extend(e.mant,l);m=l;q=b.mant;p=l;t=10*q[0]+1;1<q.length&&(t+=q[1]);l=0;a:for(;;){r=0;b:for(;;){if(m<p)break b;if(m==p){c:do{var w=m,s=0;for(;0<w;w--,s++){u=s<q.length?q[s]:0;if(g[s]<u)break b;if(g[s]>u)break c}r++;k.mant[l]=r;l++;g[0]=0;break a}while(0);s=g[0]}else s=10*g[0],1<m&&(s+=g[1]);s=v(10*s,t);0==s&&(s=1);r+=s;g=this.byteaddsub(g,m,q,p,-s,
  52. !0);if(0!=g[0])continue b;u=m-2;s=0;c:for(;s<=u;s++){if(0!=g[s])break c;m--}if(0==s)continue b;this.arraycopy(g,s,g,0,m)}if(0!=l||0!=r){k.mant[l]=r;l++;if(l==n+1)break a;if(0==g[0])break a}if(0<=d&&-k.exp>d)break a;if("D"!=a&&0>=k.exp)break a;k.exp-=1;p--}0==l&&(l=1);if("I"==a||"R"==a){if(l+k.exp>n)throw"dodivide(): Integer overflow";if("R"==a){do{if(0==k.mant[0])return this.clone(e).finish(c,!1);if(0==g[0])return this.ZERO;k.ind=e.ind;n=n+n+1-e.mant.length;k.exp=k.exp-n+e.exp;n=m;s=n-1;b:for(;1<=
  53. s&&k.exp<e.exp&&k.exp<b.exp;s--){if(0!=g[s])break b;n--;k.exp+=1}n<g.length&&(e=Array(n),this.arraycopy(g,0,e,0,n),g=e);k.mant=g;return k.finish(c,!1)}while(0)}}else 0!=g[0]&&(e=k.mant[l-1],0==e%5&&(k.mant[l-1]=e+1));if(0<=d)return l!=k.mant.length&&(k.exp-=k.mant.length-l),e=k.mant.length-(-k.exp-d),k.round(e,c.roundingMode),k.exp!=-d&&(k.mant=this.extend(k.mant,k.mant.length+1),k.exp-=1),k.finish(c,!0);if(l==k.mant.length)k.round(c);else{if(0==k.mant[0])return this.ZERO;e=Array(l);this.arraycopy(k.mant,
  54. 0,e,0,l);k.mant=e}return k.finish(c,!0)};f.prototype.bad=function(a,b){throw a+"Not a number: "+b;};f.prototype.badarg=function(a,b,c){throw"Bad argument "+b+" to "+a+": "+c;};f.prototype.extend=function(a,b){var c;if(a.length==b)return a;c=r(b);this.arraycopy(a,0,c,0,a.length);return c};f.prototype.byteaddsub=function(a,b,c,d,e,f){var g,h,l,m,q,p,r=0;g=p=0;g=a.length;h=c.length;b-=1;m=l=d-1;m<b&&(m=b);d=null;f&&m+1==g&&(d=a);null==d&&(d=this.createArrayWithZeros(m+1));q=!1;1==e?q=!0:-1==e&&(q=!0);
  55. p=0;r=m;a:for(;0<=r;r--){0<=b&&(b<g&&(p+=a[b]),b--);0<=l&&(l<h&&(p=q?0<e?p+c[l]:p-c[l]:p+c[l]*e),l--);if(10>p&&0<=p){do{d[r]=p;p=0;continue a}while(0)}p+=90;d[r]=this.bytedig[p];p=this.bytecar[p]}if(0==p)return d;c=null;f&&m+2==a.length&&(c=a);null==c&&(c=Array(m+2));c[0]=p;a=m+1;g=0;for(;0<a;a--,g++)c[g+1]=d[g];return c};f.prototype.diginit=y;f.prototype.clone=function(a){var b;b=new f;b.ind=a.ind;b.exp=a.exp;b.form=a.form;b.mant=a.mant;return b};f.prototype.checkdigits=function(a,b){if(0!=b){if(this.mant.length>
  56. b&&!this.allzero(this.mant,b))throw"Too many digits: "+this.toString();if(null!=a&&a.mant.length>b&&!this.allzero(a.mant,b))throw"Too many digits: "+a.toString();}};f.prototype.round=x;f.prototype.allzero=function(a,b){var c=0;0>b&&(b=0);var d=a.length-1,c=b;for(;c<=d;c++)if(0!=a[c])return!1;return!0};f.prototype.finish=function(a,b){var c=0,d=0,e=null,c=d=0;0!=a.digits&&this.mant.length>a.digits&&this.round(a);if(b&&a.form!=h.prototype.PLAIN){c=this.mant.length;d=c-1;a:for(;1<=d;d--){if(0!=this.mant[d])break a;
  57. c--;this.exp++}c<this.mant.length&&(e=Array(c),this.arraycopy(this.mant,0,e,0,c),this.mant=e)}this.form=h.prototype.PLAIN;c=this.mant.length;d=0;for(;0<c;c--,d++)if(0!=this.mant[d]){0<d&&(e=Array(this.mant.length-d),this.arraycopy(this.mant,d,e,0,this.mant.length-d),this.mant=e);d=this.exp+this.mant.length;if(0<d){if(d>a.digits&&0!=a.digits&&(this.form=a.form),d-1<=this.MaxExp)return this}else-5>d&&(this.form=a.form);d--;if(d<this.MinExp||d>this.MaxExp){b:do{if(this.form==h.prototype.ENGINEERING&&
  58. (c=d%3,0>c&&(c=3+c),d-=c,d>=this.MinExp&&d<=this.MaxExp))break b;throw"finish(): Exponent Overflow: "+d;}while(0)}return this}this.ind=this.iszero;if(a.form!=h.prototype.PLAIN)this.exp=0;else if(0<this.exp)this.exp=0;else if(this.exp<this.MinExp)throw"finish(): Exponent Overflow: "+this.exp;this.mant=this.ZERO.mant;return this};f.prototype.isGreaterThan=function(a){return 0<this.compareTo(a)};f.prototype.isLessThan=function(a){return 0>this.compareTo(a)};f.prototype.isGreaterThanOrEqualTo=function(a){return 0<=
  59. this.compareTo(a)};f.prototype.isLessThanOrEqualTo=function(a){return 0>=this.compareTo(a)};f.prototype.isPositive=function(){return 0<this.compareTo(f.prototype.ZERO)};f.prototype.isNegative=function(){return 0>this.compareTo(f.prototype.ZERO)};f.prototype.isZero=function(){return 0===this.compareTo(f.prototype.ZERO)};f.ROUND_CEILING=f.prototype.ROUND_CEILING=h.prototype.ROUND_CEILING;f.ROUND_DOWN=f.prototype.ROUND_DOWN=h.prototype.ROUND_DOWN;f.ROUND_FLOOR=f.prototype.ROUND_FLOOR=h.prototype.ROUND_FLOOR;
  60. f.ROUND_HALF_DOWN=f.prototype.ROUND_HALF_DOWN=h.prototype.ROUND_HALF_DOWN;f.ROUND_HALF_EVEN=f.prototype.ROUND_HALF_EVEN=h.prototype.ROUND_HALF_EVEN;f.ROUND_HALF_UP=f.prototype.ROUND_HALF_UP=h.prototype.ROUND_HALF_UP;f.ROUND_UNNECESSARY=f.prototype.ROUND_UNNECESSARY=h.prototype.ROUND_UNNECESSARY;f.ROUND_UP=f.prototype.ROUND_UP=h.prototype.ROUND_UP;f.prototype.ispos=1;f.prototype.iszero=0;f.prototype.isneg=-1;f.prototype.MinExp=-999999999;f.prototype.MaxExp=999999999;f.prototype.MinArg=-999999999;f.prototype.MaxArg=
  61. 999999999;f.prototype.plainMC=new h(0,h.prototype.PLAIN);f.prototype.bytecar=Array(190);f.prototype.bytedig=y();f.ZERO=f.prototype.ZERO=new f("0");f.ONE=f.prototype.ONE=new f("1");f.TEN=f.prototype.TEN=new f("10");return f}(y);"function"===typeof define&&null!=define.amd?define({BigDecimal:L,MathContext:y}):"object"===typeof this&&(this.BigDecimal=L,this.MathContext=y)}).call(this);










声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/423861
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号