public override void Move(int moveX, int moveY)
 {
     TerminateThreads();
     xorigin -= (BigDecimal)(moveX) * (xmax - xmin) / (BigDecimal)screenWidth;
     yorigin -= (BigDecimal)(moveY) * (ymax - ymin) / (BigDecimal)screenHeight;
     Draw(numIterations, numThreads);
 }

 public void TestBigDecimal() {
    BigDecimal decimal = new BigDecimal("1.1");
    BigDecimalTransform format = new BigDecimalTransform();
    String value = format.write(decimal);
    BigDecimal copy = format.read(value);
    AssertEquals(decimal, copy);
 }

		public PayPalItem (string name, BigDecimal price, string currency)
		{
			Name = name;
			//Quantity = quantity;
			Price = price;
			Currency = currency;
			//SKU = sku;
		}

 public void Add(string a, int aScale, string b, int bScale, string c, int cScale)
 {
     BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
     BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
     BigDecimal result = aNumber.Add(bNumber);
     Assert.AreEqual(c, result.ToString(), "incorrect value");
     Assert.AreEqual(cScale, result.Scale, "incorrect scale");
 }

 public virtual Number Calculate(BigDecimal num)
 {
     if (num == null)
     {
         return -0;
     }
     return num.Negate();
 }

        /// <summary>
        /// The mathematical constant e.
        /// </summary>
        /// <param name="precision">The precision.</param>
        /// <returns>The mathematical constant e.</returns>
        public static BigDecimal EBig(int precision)
        {
            if (_EBig.Precision < precision)
            {
                _EBig = BigDecimal.Exp(BigDecimal.One.WithPrecision(precision + 10));
            }

            return _EBig.WithPrecision(precision);
        }

 public void AddWithContext(string a, int aScale, string b, int bScale, string c, int cScale, int precision, RoundingMode mode)
 {
     BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
     BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
     MathContext mc = new MathContext(precision, mode);
     BigDecimal result = aNumber.Add(bNumber, mc);
     Assert.AreEqual(c, result.ToString(), "incorrect value");
     Assert.AreEqual(cScale, result.Scale, "incorrect scale");
 }

 public void Abs()
 {
     BigDecimal big = BigDecimal.Parse("-1234");
     BigDecimal bigabs = big.Abs();
     Assert.IsTrue(bigabs.ToString().Equals("1234"), "the absolute value of -1234 is not 1234");
     big = new BigDecimal(BigInteger.Parse("2345"), 2);
     bigabs = big.Abs();
     Assert.IsTrue(bigabs.ToString().Equals("23.45"), "the absolute value of 23.45 is not 23.45");
 }

 public void CompareToBigDecimal()
 {
     BigDecimal comp1 = BigDecimal.Parse("1.00");
     BigDecimal comp2 = new BigDecimal(1.000000D);
     Assert.IsTrue(comp1.CompareTo(comp2) == 0, "1.00 and 1.000000 should be equal");
     BigDecimal comp3 = BigDecimal.Parse("1.02");
     Assert.IsTrue(comp3.CompareTo(comp1) == 1, "1.02 should be bigger than 1.00");
     BigDecimal comp4 = new BigDecimal(0.98D);
     Assert.IsTrue(comp4.CompareTo(comp1) == -1, "0.98 should be less than 1.00");
 }

 public void AddBigDecimal()
 {
     BigDecimal add1 = BigDecimal.Parse("23.456");
     BigDecimal add2 = BigDecimal.Parse("3849.235");
     BigDecimal sum = add1.Add(add2);
     Assert.IsTrue(sum.UnscaledValue.ToString().Equals("3872691") && sum.Scale == 3,
                   "the sum of 23.456 + 3849.235 is wrong");
     Assert.IsTrue(sum.ToString().Equals("3872.691"), "the sum of 23.456 + 3849.235 is not printed correctly");
     BigDecimal add3 = new BigDecimal(12.34E02D);
     Assert.IsTrue((add1.Add(add3)).ToString().Equals("1257.456"), "the sum of 23.456 + 12.34E02 is not printed correctly");
 }

 public void Should_Allow_Custom_Primitive_Serializers()
 {
     var serializer = new Serializer(4, new [] {new BigDecimalSerializer()});
     var value = new BigDecimal(5, 1);
     var buffer = serializer.Serialize(value);
     CollectionAssert.AreEqual(new byte[] { 0, 0, 0, 5, 1 }, buffer);
     var deserializedValue = serializer.Deserialize(buffer, ColumnTypeCode.Decimal, null);
     Assert.IsInstanceOf<BigDecimal>(deserializedValue);
     var deserializedDecimal = (BigDecimal) deserializedValue;
     Assert.AreEqual("0.00001", deserializedDecimal.ToString());
     Assert.AreEqual(value.Scale, deserializedDecimal.Scale);
     Assert.AreEqual(value.UnscaledValue, deserializedDecimal.UnscaledValue);
     //Check that other serializers are still working
     CollectionAssert.AreEqual(new byte[] { 0, 0, 0, 10 }, serializer.Serialize(10));
     CollectionAssert.AreEqual(new byte[] { 0x61 }, serializer.Serialize("a"));
 }

        public override void Zoom(int posX, int posY, double factor)
        {
            BigDecimal xpos = xmin + ((BigDecimal)posX * (xmax - xmin) / (BigDecimal)screenWidth);
            BigDecimal ypos = ymin + ((BigDecimal)posY * (ymax - ymin) / (BigDecimal)screenHeight);
            BigDecimal xOffsetRatio = (xpos - xmin) / (xmax - xmin);
            BigDecimal yOffsetRatio = (ypos - ymin) / (ymax - ymin);

            BigDecimal newXextent = (xmax - xmin);
            newXextent *= factor;

            BigDecimal newYextent = (ymax - ymin);
            newYextent *= factor;

            TerminateThreads();
            xextent = newXextent;
            xorigin = xpos - xextent * xOffsetRatio;
            yorigin = ypos - newYextent * yOffsetRatio;
            Draw(numIterations, numThreads);
        }

 public void DivideAndRemainder1()
 {
     String a = "3736186567876876578956958765675671119238118911893939591735";
     int aScale = 45;
     String b = "134432345432345748766876876723342238476237823787879183470";
     int bScale = 70;
     String res = "277923185514690367474770683";
     int resScale = 0;
     String rem = "1.3032693871288309587558885943391070087960319452465789990E-15";
     int remScale = 70;
     BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
     BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
     BigDecimal remainder;
     BigDecimal quotient = aNumber.DivideAndRemainder(bNumber, out remainder);
     Assert.AreEqual(res, quotient.ToString(), "incorrect quotient value");
     Assert.AreEqual(resScale, quotient.Scale, "incorrect quotient scale");
     Assert.AreEqual(rem, remainder.ToString(), "incorrect remainder value");
     Assert.AreEqual(remScale, remainder.Scale, "incorrect remainder scale");
 }

 public void ConstructorDouble()
 {
     BigDecimal big = new BigDecimal(123E04);
     Assert.AreEqual("1230000", big.ToString(),
                     "the BigDecimal value taking a double argument is not initialized properly");
     big = new BigDecimal(1.2345E-12);
     Assert.AreEqual(1.2345E-12, big.ToDouble(), "the double representation is not correct");
     big = new BigDecimal(-12345E-3);
     Assert.AreEqual(-12.345, big.ToDouble(), "the double representation is not correct");
     big = new BigDecimal(5.1234567897654321e138);
     Assert.AreEqual(5.1234567897654321E138, big.ToDouble(), "the double representation is not correct");
     Assert.AreEqual(0, big.Scale, "the double representation is not correct");
     big = new BigDecimal(0.1);
     Assert.IsTrue(big.ToDouble() == 0.1, "the double representation of 0.1 bigDecimal is not correct");
     big = new BigDecimal(0.00345);
     Assert.IsTrue(big.ToDouble() == 0.00345, "the double representation of 0.00345 bigDecimal is not correct");
     // regression test for HARMONY-2429
     big = new BigDecimal(-0.0);
     Assert.IsTrue(big.Scale == 0, "the double representation of -0.0 bigDecimal is not correct");
 }

		public void TestToString() {
			BigDecimal d;

			// integers
			d = new BigDecimal(0, 0);
			Assert.AreEqual("0.", d.ToString());

			d = new BigDecimal(1, 0);
			Assert.AreEqual("1.", d.ToString());

			// with decimal point inside number
			d = new BigDecimal(1234, 2);
			Assert.AreEqual("12.34", d.ToString());

			// with decimal point before number
			d = new BigDecimal(1, 2);
			Assert.AreEqual("0.01", d.ToString());

			// really big number, with decimal point
			d = new BigDecimal(BigInteger.Parse("12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"), 20);
			Assert.AreEqual("123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.12345678901234567890", d.ToString());
		}

		/* 
    	 * This method shows use of optional payment details and item list.
     	*/
		private PayPalPayment getStuffToBuy(string paymentIntent) {
			//--- include an item list, payment amount details
			PayPalItem[] items =
			{
				new PayPalItem("sample item #1", new Java.Lang.Integer(2), new BigDecimal("87.50"), "USD",
					"sku-12345678"),
				new PayPalItem("free sample item #2", new Java.Lang.Integer(1), new BigDecimal("0.00"),
					"USD", "sku-zero-price"),
				new PayPalItem("sample item #3 with a longer name", new Java.Lang.Integer(6), new BigDecimal("37.99"),
					"USD", "sku-33333") 
			};
			BigDecimal subtotal = PayPalItem.GetItemTotal(items);
			BigDecimal shipping = new BigDecimal("7.21");
			BigDecimal tax = new BigDecimal("4.67");
			PayPalPaymentDetails paymentDetails = new PayPalPaymentDetails(shipping, subtotal, tax);
			BigDecimal amount = subtotal.Add(shipping).Add(tax);
			PayPalPayment payment = new PayPalPayment(amount, "USD", "sample item", paymentIntent);
			payment.Items(items).PaymentDetails(paymentDetails);

			//--- set other optional fields like invoice_number, custom field, and soft_descriptor
			payment.Custom("This is text that will be associated with the payment that the app can use.");

			return payment;
		}

 public static BigDecimal/*!*/ Truncate(RubyContext/*!*/ context, BigDecimal/*!*/ self, [Optional]int n) {
     return BigDecimal.LimitPrecision(GetConfig(context), self, n, BigDecimal.RoundingModes.Down);
 }

 public static bool IsFinite(BigDecimal/*!*/ self) {
     return BigDecimal.IsFinite(self);
 }

 public static BigDecimal/*!*/ Round(RubyContext/*!*/ context, BigDecimal/*!*/ self, [Optional]int n) {
     return BigDecimal.LimitPrecision(GetConfig(context), self, n, GetConfig(context).RoundingMode);
 }

 public static bool Equal(RubyContext/*!*/ context, BigDecimal/*!*/ self, double other) {
     return self.Equals(BigDecimal.Create(GetConfig(context), other));
 }