/// <summary>Divide numerator by denominator.</summary>
/// <remarks>Divide numerator by denominator. If impossible in exact mode, use rounding.
/// </remarks>
protected internal virtual BigDecimal TryDivide(BigDecimal numerator, BigDecimal
denominator)
{
try
{
return(numerator.Divide(denominator));
}
catch (ArithmeticException)
{
return(numerator.Divide(denominator, BigDecimal.RoundHalfUp));
}
}
public BigDecimal ToBigDecimal(BigDecimal.Context c)
{
BigDecimal numerator = BigDecimal.Create(this.numerator);
BigDecimal denominator = BigDecimal.Create(this.denominator);
return(numerator.Divide(denominator, c));
}
public static BigDecimal CalculateRate(BigDecimal rate, TimeSpan timeSpan)
{
BigDecimal seconds = GetSeconds(timeSpan);
BigDecimal log = Ln(rate);
return(seconds.Divide(log, MathContext.Decimal64));
}
public static Number operator %(Number a, Number b)
{
BigDecimal rem;
BigDecimal.Divide(new BigDecimal.Config(), a.value, b.value, 0, out rem);
return(rem);
}
static BigDecimal CalcTerm(int n)
{
Console.Write('.');
BigDecimal neg1 = new BigDecimal(-1);
neg1 = neg1.Pow(n);
neg1 = neg1.Multiply(fact(4 * n));
BigDecimal t1b = new BigDecimal(4);
t1b = t1b.Pow(n);
t1b = t1b.Multiply(fact(n));
t1b = t1b.Pow(4);
neg1 = neg1.Divide(t1b, acc, RoundingMode.HalfUp);
BigDecimal t2 = new BigDecimal(21460);
t2 = t2.Multiply(n);
t2 = t2.Add(1123);
BigDecimal t2b = new BigDecimal(882);
t2b = t2b.Pow(2 * n);
t2 = t2.Divide(t2b, acc, RoundingMode.HalfUp);
return(neg1.Multiply(t2));
}
public void starinfo()
{
Console.WriteLine("======[Star]======");
Console.WriteLine("name :" + getType());
Console.WriteLine("Diameter :" + getDiameter() + " m");
Console.WriteLine("Mass :" + getMass() + " Kg");
Console.WriteLine("Temp :" + getSurfaceTemperature() + " K");
BigDecimal dia = BigDecimal.Parse(diameter);
this.density = base.calDens(dia.Divide(2));
Console.WriteLine("Density : " + base.getdensity() + " Kg / m³");
BigDecimal lum = luminosityOfAStar(getDiameter(), getSurfaceTemperature());
volume(getDiameter());
Console.WriteLine("Volume : " + getVolume().ToBigIntegerExact() + " m³");
Console.WriteLine("luminosity :" + getStarluminosity().ToBigIntegerExact() + " watts");
BigDecimal eng = StarsEnergy(this.mass, this.massUsedUp, this.massAtCenter);
Console.WriteLine("Energy :" + getEnergy().ToBigIntegerExact() + " J");
StarsLifeSpan(lum.ToBigIntegerExact(), eng.ToBigIntegerExact());
Console.WriteLine("Life Span: " + getAge() + " Years");
gPull(mass, BigInteger.Parse("5972000000000000000000000"));
Console.WriteLine("Gravitaional Pull: " + getgp() + " Newtons");
if (base.getSpin() == null)
{
Console.WriteLine("Spin: Null Km/S");
return;
}
Console.WriteLine("Spin: " + base.getSpin() + " Km/S");
}
private static BigDecimal Calculate(string[] a, char c)
{
BigDecimal value = BigDecimal.Parse(a[0].Trim());
for (int i = 1; i < a.Length; i++)
{
if (c == '+')
{
value = value.Add(BigDecimal.Parse(a[i].Trim()));
}
else if (c == '-')
{
value = value.Subtract(BigDecimal.Parse(a[i].Trim()));
}
else if (c == '*')
{
value = value.Multiply(BigDecimal.Parse(a[i].Trim()));
}
else
{
value = value.Divide(BigDecimal.Parse(a[i].Trim()), 5, RoundingMode.HalfEven);
}
}
return(value);
}
/// <summary>
/// Phân số tối giản.
/// </summary>
public void Minimalism()
{
BigDecimal n = Minimalism(this.Numerator, this.Denominator);
Numerator = Numerator.Divide(n.Abs());
Denominator = Denominator.SetScale(5, RoundingMode.HalfEven);
Denominator = Denominator.Divide(n.Abs());
}
public void Divide(string result, string left, string right)
{
var resultDecimal = BigDecimal.Parse(result, CultureInfo.InvariantCulture);
var leftDecimal = BigDecimal.Parse(left, CultureInfo.InvariantCulture);
var rightDecimal = BigDecimal.Parse(right, CultureInfo.InvariantCulture);
Assert.Equal(resultDecimal, BigDecimal.Divide(leftDecimal, rightDecimal));
}
public static BigDecimal /*!*/ Div(RubyContext /*!*/ context, BigDecimal /*!*/ self, BigDecimal /*!*/ other, int n)
{
if (n < 0)
{
throw RubyExceptions.CreateArgumentError("argument must be positive");
}
BigDecimal remainder;
return(BigDecimal.Divide(GetConfig(context), self, other, n, out remainder));
}
/// <exclude/>
/// <summary>
/// Convert a time in the Universal Time Scale into another time scale. The
/// division used to do the conversion rounds down.
/// NOTE: This is an internal routine used by the tool that generates the to
/// and from limits. Use it at your own risk.
/// </summary>
///
/// <param name="universalTime">the time in the Universal Time scale</param>
/// <param name="timeScale">the time scale to convert to</param>
/// <returns>the time in the given time scale</returns>
public static BigDecimal ToBigDecimalTrunc(BigDecimal universalTime,
int timeScale)
{
UniversalTimeScale.TimeScaleData data = GetTimeScaleData(timeScale);
BigDecimal units_0 = new BigDecimal(data.units);
BigDecimal epochOffset_1 = new BigDecimal(data.epochOffset);
return(universalTime.Divide(units_0, IBM.ICU.Math.BigDecimal.ROUND_DOWN).Subtract(
epochOffset_1));
}
public void Divide_ParametersFromData_Pass()
{
var left = new BigDecimal(TestContext.DataRow[0].ToString());
var right = new BigDecimal(TestContext.DataRow[1].ToString());
var expected = TestContext.DataRow[2].ToString();
string message = TestContext.DataRow[3].ToString();
var actual = left.Divide(right, RoundingMode.Up);
Assert.AreEqual(expected, actual.ToString(), message);
}
public static BigDecimal /*!*/ Div(RubyContext /*!*/ context, BigDecimal /*!*/ self, BigDecimal /*!*/ other)
{
if (BigDecimal.IsFinite(other))
{
BigDecimal.Config config = GetConfig(context);
BigDecimal remainder;
BigDecimal result = BigDecimal.Divide(config, self, other, 0, out remainder);
if (BigDecimal.IsFinite(result))
{
return(BigDecimal.IntegerPart(config, result));
}
}
return(BigDecimal.NaN);
}
public void Red_Super_Giant()
{
Random ran = new Random();
diameter = range(BigInteger.Parse("1000000000000"), BigInteger.Parse("2000000000000"));
mass = range(Red_Super_Giantmax, Red_Super_Giantmin);
surfaceTemperature = ran.Next(1000, 3500);
this.massUsedUp = BigDecimal.Parse("0.00147441058");
this.massAtCenter = BigDecimal.Parse(".4");
BigDecimal dia = BigDecimal.Parse(diameter);
spin = BigInteger.Parse("1");
density = calDens(dia.Divide(num2));
}
public void White_Dwarf()
{
Random ran = new Random();
diameter = range(BigInteger.Parse("6000000"), BigInteger.Parse("12000000"));
mass = range(White_Dwarfmax, White_Dwarfmin);
surfaceTemperature = ran.Next(500000, 100000);
this.massUsedUp = BigDecimal.Parse(".007");
this.massAtCenter = BigDecimal.Parse("1");
BigDecimal dia = BigDecimal.Parse(diameter);
spin = BigInteger.Parse("2000");
density = calDens(dia.Divide(num2));
}
public void Massive_Star()
{
Random ran = new Random();
diameter = range(BigInteger.Parse("5000000000"), BigInteger.Parse("100000000000"));
mass = range(Massive_Starmax, Massive_Starmin);
surfaceTemperature = ran.Next(30000, 60000);
this.massUsedUp = BigDecimal.Parse(".007");
this.massAtCenter = BigDecimal.Parse(".24");
BigDecimal dia = BigDecimal.Parse(diameter);
spin = range(BigInteger.Parse("200"), BigInteger.Parse("350"));
density = calDens(dia.Divide(num2));
}
public void Black_hole()
{
Random ran = new Random();
diameter = range(BigInteger.Parse("100000000000"), BigInteger.Parse("10000000000000000"));
mass = range(Black_holemax, Black_holemin);
surfaceTemperature = 1;
this.massUsedUp = BigDecimal.Parse(".007");
this.massAtCenter = BigDecimal.Parse("1");
BigDecimal dia = BigDecimal.Parse(diameter);
spin = range(BigInteger.Parse("50000"), BigInteger.Parse("251825"));
density = calDens(dia.Divide(num2));
}
public Number Divide(Number number)
{
if (numberState == 0)
{
if (number.numberState == 0)
{
BigDecimal divBy = number.bigDecimal;
if (divBy.CompareTo(BdZero) != 0)
{
return(new Number(NumberState.None, bigDecimal.Divide(divBy, 10, RoundingMode.HalfUp)));
}
}
}
// Return NaN if we can't divide
return(new Number(NumberState.NotANumber, null));
}
public BigDecimal volume(BigInteger diameter)
{
BigDecimal vol = BigDecimal.Parse("0");
BigDecimal radi = BigDecimal.Parse(diameter);
BigDecimal two = BigDecimal.Parse("2.0");
BigDecimal FOT = BigDecimal.Parse("1.33333333333");
BigDecimal PI = BigDecimal.Parse(Math.PI.ToString());
radi = radi.Divide(two);
vol = FOT * (PI);
vol = vol * (radi.Pow(3));
setVolume(vol);
return(vol);
}
public static String FormatBytes(long bytes)
{
long inputBytes = bytes;
BigDecimal bigBytes = new BigDecimal(bytes);
NumberFormat numberFormat = new DecimalFormat();
numberFormat.MaximumFractionDigits = 1;
int index;
for (index = 0; index < BYTES_UNIT_LIST.Length; index++)
{
if (inputBytes < CONVERSION_BASE)
{
break;
}
inputBytes /= CONVERSION_BASE;
}
return(numberFormat.Format(bigBytes.Divide(new BigDecimal(BASE_LIST[index]))) + " " + BYTES_UNIT_LIST[index]);
}
private static BigDecimal SqrtNewtonRaphson(BigDecimal c, BigDecimal xn, BigDecimal precision)
{
BigDecimal fx = xn.Pow(2).Add(c.Negate());
BigDecimal fpx = xn.Multiply(new BigDecimal(2));
BigDecimal xn1 = fx.Divide(fpx, 2 * SqrtDig.ToInt32(), RoundingMode.HalfDown);
xn1 = xn.Add(xn1.Negate());
//----
BigDecimal currentSquare = xn1.Pow(2);
BigDecimal currentPrecision = currentSquare.Subtract(c);
currentPrecision = currentPrecision.Abs();
if (currentPrecision.CompareTo(precision) <= -1)
{
return(xn1);
}
return(SqrtNewtonRaphson(c, xn1, precision));
}
/// <summary>
/// Convert <seealso cref="BigInteger"/> value to <seealso cref="BigDecimal"/> value. </summary>
/// <param name="bgInt"> <seealso cref="BigInteger"/> value </param>
/// <param name="precision"> the precision value for VET and VeThor it is 18, means 10 power 18 </param>
/// <param name="scale"> the remain digits number of fractional part. </param>
/// <returns> <seealso cref="BigDecimal"/> value. </returns>
public static BigDecimal BigIntToBigDecimal(BigInteger bgInt, int precision, int scale)
{
if (bgInt == null || precision < 0 || scale < 0)
{
return(null);
}
var integer2 = new System.Numerics.BigInteger(bgInt.ToByteArray());
if (scale < precision)
{
integer2 /= (int)Math.Pow(10, scale);
precision = precision - scale;
}
var dec = new BigDecimal(integer2);
var precisionDecimal = BigDecimal.Pow(10, precision);
var value = BigDecimal.Divide(dec, precisionDecimal);
return(value);
}
public SqlNumber Divide(SqlNumber value)
{
if (State == NumericState.None)
{
if (value.State == NumericState.None)
{
if (IsNull || value.IsNull)
{
return(Null);
}
BigDecimal divBy = value.innerValue;
if (divBy.CompareTo(BigDecimal.Zero) != 0)
{
return(new SqlNumber(NumericState.None, innerValue.Divide(divBy, 10, RoundingMode.HalfUp)));
}
}
}
// Return NaN if we can't divide
return(new SqlNumber(NumericState.NotANumber, null));
}
public void DivideBigDecimalScaleRoundingModeFloor()
{
String a = "3736186567876876578956958765675671119238118911893939591735";
int aScale = 100;
String b = "74723342238476237823787879183470";
int bScale = 15;
int newScale = 45;
RoundingMode rm = RoundingMode.Floor;
String c = "0E-45";
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, newScale, rm);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(newScale, result.Scale, "incorrect scale");
}
public static int ErrorToPrecision(BigDecimal x, BigDecimal xerr)
{
return ErrorToPrecision(xerr.Divide(x, MathContext.Decimal64).ToDouble());
}
private void Poisson(byte[] discreteRow)
{
var descreteTable = GetDiscreteTable(discreteRow);
float expectedValue = GetDiscreteRowExpectedValue(discreteRow);
float result = 0f;
var gridTable = (DataGridView)tabPage2.Controls["dataGridtab2"];
gridTable.Columns.Add("a", "Штат");
gridTable.Columns.Add("b", "Частота");
gridTable.Columns.Add("c", "Теоритическая частота");
gridTable.Columns.Add("d", "Хи-наблюдаемое");
foreach (DataGridViewColumn column in gridTable.Columns)
{
column.SortMode = DataGridViewColumnSortMode.NotSortable;
}
gridTable.Rows.Add(descreteTable.GetLength(1) + 3);
BigDecimal[] P = new BigDecimal[descreteTable.GetLength(1)];
decimal[] theoreticalFrequency = new Decimal[descreteTable.GetLength(1)];
decimal collectionSize = (decimal)descreteTable[3, descreteTable.GetLength(1) - 1];
for (int i = 0; i < descreteTable.GetLength(1); i++)
{
double x = Math.Pow(expectedValue, i) * Math.Exp(-expectedValue);
P[i] = BigDecimal.Divide(x, Factorial(i));
theoreticalFrequency[i] = collectionSize * (decimal)P[i];
gridTable.Rows[i].Cells[0].Value = descreteTable[0, i];
gridTable.Rows[i].Cells[1].Value = descreteTable[1, i];
gridTable.Rows[i].Cells[2].Value = (double)theoreticalFrequency[i];
}
float Hi = 0F;
for (int i = 0; i < descreteTable.GetLength(1); i++)
{
float currHi = 0;
decimal frequency = (int)descreteTable[1, i];
currHi = (float)(Math.Pow((double)(frequency - theoreticalFrequency[i]), 2) / (double)theoreticalFrequency[i]);
Hi += currHi;
gridTable.Rows[i].Cells[3].Value = currHi;
}
int d = descreteTable.GetLength(1) > 32 ? 30 : descreteTable.GetLength(1) - 1 - 1;
double J = Math.Abs(Hi - d) / Math.Sqrt(2 * descreteTable.GetLength(1) + 2.4);
double R = Math.Abs(Hi - d) / Math.Sqrt(2 * d);
gridTable.Rows[descreteTable.GetLength(1)].Cells[0].Value = "Критерий Ястремского (надо <= 3):";
gridTable.Rows[descreteTable.GetLength(1)].Cells[1].Value = J;
gridTable.Rows[descreteTable.GetLength(1) + 1].Cells[0].Value = "Критерий Романовского (надо <= 3):";
gridTable.Rows[descreteTable.GetLength(1) + 1].Cells[1].Value = R;
gridTable.Rows[descreteTable.GetLength(1)].Cells[2].Value = "Критерий Пирсона:";
gridTable.Rows[descreteTable.GetLength(1)].Cells[3].Value = Hi;
gridTable.Rows[descreteTable.GetLength(1) + 1].Cells[2].Value = "По таблице критических значений:";
gridTable.Rows[descreteTable.GetLength(1) + 1].Cells[3].Value = hisqr[d];
gridTable.Rows[descreteTable.GetLength(1) + 2].Cells[0].Value = "Вывод:";
gridTable.Rows[descreteTable.GetLength(1) + 2].Cells[1].Value = J < 3 || R < 3 ? "Гипотеза подтверждена" : "Гипотеза не подтверждена";
gridTable.Rows[descreteTable.GetLength(1) + 2].Cells[3].Value = Hi >= hisqr[d] ? "Гипотеза не подтверждена" : "Гипотеза подтверждена";
var cell = gridTable.Rows[descreteTable.GetLength(1) + 2].Cells[3];
cell.Style.Font = new Font(FontFamily.GenericMonospace, 8, FontStyle.Bold);
cell = gridTable.Rows[descreteTable.GetLength(1) + 2].Cells[1];
cell.Style.Font = new Font(FontFamily.GenericMonospace, 8, FontStyle.Bold);
}
public static BigDecimal DivideRound(BigDecimal x, BigDecimal y)
{
/* The estimation of the relative error in the result is |err(y)/y|+|err(x)/x|
*/
var mc = new MathContext(System.Math.Min(x.Precision, y.Precision));
BigDecimal resul = x.Divide(y, mc);
/* If x and y are precise integer values that may have common factors,
* the method above will truncate trailing zeros, which may result in
* a smaller apparent accuracy than starte... add missing trailing zeros now.
*/
return ScalePrecision(resul, mc);
}
public static BigDecimal DivideRound(BigDecimal x, int n)
{
// The estimation of the relative error in the result is |err(x)/x|
var mc = new MathContext(x.Precision);
return x.Divide(new BigDecimal(n), mc);
}
public void DivideBigDecimalScaleMathContextHALF_UP()
{
String a = "3736186567876876578956958765675671119238118911893939591735";
int aScale = 45;
String b = "134432345432345748766876876723342238476237823787879183470";
int bScale = 70;
int precision = 21;
RoundingMode rm = RoundingMode.HalfUp;
MathContext mc = new MathContext(precision, rm);
String c = "2.77923185514690367475E+26";
int resScale = -6;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, mc);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public void DivideByZero()
{
String a = "1231212478987482988429808779810457634781384756794987";
int aScale = 15;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = BigDecimal.ValueOf(0L);
Assert.Throws<ArithmeticException>(() => aNumber.Divide(bNumber), "ArithmeticException has not been caught");
}
public void DivideTest2()
{
var res = BigDecimal.Divide(new BigDecimal(10), new BigDecimal(8));
Assert.AreEqual(new BigDecimal(1.25m), res);
}
public void TestTruncateOnAllArithmeticOperations()
{
var savePrecision = BigDecimal.Precision;
BigDecimal mod1 = BigDecimal.Parse("3141592653589793238462643383279502");
BigDecimal mod2 = BigDecimal.Parse("27182818284590452");
BigDecimal neg1 = BigDecimal.Parse("-3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647");
BigDecimal lrg1 = BigDecimal.Parse("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647");
BigDecimal lrg2 = BigDecimal.Parse("2.718281828459045235360287471352662497757247093699959574966967");
var expected1 = "5.859874482";
var expected2 = "0.4233108251";
var expected3 = "8.5397342226";
var expected4 = "0.8652559794";
var expected5 = "9.869604401";
var expected6 = "148.4131591";
var expected7 = "8003077319547306";
var expected8 = "-3.1415926535";
var expected9 = "3";
var expected10 = "4";
var expected11 = "3.1415926535";
var actual1 = "";
var actual2 = "";
var actual3 = "";
var actual4 = "";
var actual5 = "";
var actual6 = "";
var actual7 = "";
var actual8 = "";
var actual9 = "";
var actual10 = "";
var actual11 = "";
try
{
BigDecimal.Precision = 10;
BigDecimal.AlwaysTruncate = true;
TestContext.WriteLine($"E = {BigDecimal.E}");
TestContext.WriteLine($"{new BigDecimal(lrg1.Mantissa, lrg1.Exponent)}");
TestContext.WriteLine($"{new BigDecimal(lrg2.Mantissa, lrg2.Exponent)}");
BigDecimal result1 = BigDecimal.Add(lrg1, lrg2);
BigDecimal result2 = BigDecimal.Subtract(lrg1, lrg2);
BigDecimal result3 = BigDecimal.Multiply(lrg1, lrg2);
BigDecimal result4 = BigDecimal.Divide(lrg2, lrg1);
BigDecimal result5 = BigDecimal.Pow(lrg1, 2);
BigDecimal result6 = BigDecimal.Exp(new BigInteger(5));
BigDecimal result7 = BigDecimal.Mod(mod1, mod2);
BigDecimal result8 = BigDecimal.Negate(lrg1);
BigDecimal result9 = BigDecimal.Floor(lrg1);
BigDecimal result10 = BigDecimal.Ceiling(lrg1);
BigDecimal result11 = BigDecimal.Abs(lrg1);
actual1 = result1.ToString();
actual2 = result2.ToString();
actual3 = result3.ToString();
actual4 = result4.ToString();
actual5 = result5.ToString();
actual6 = result6.ToString();
actual7 = result7.ToString();
actual8 = result8.ToString();
actual9 = result9.ToString();
actual10 = result10.ToString();
actual11 = result11.ToString();
}
finally
{
BigDecimal.Precision = savePrecision;
BigDecimal.AlwaysTruncate = false;
}
Assert.AreEqual(expected1, actual1, $"Test Truncate On All Arithmetic Operations - #1: ");
Assert.AreEqual(expected2, actual2, $"Test Truncate On All Arithmetic Operations - #2: ");
Assert.AreEqual(expected3, actual3, $"Test Truncate On All Arithmetic Operations - #3: ");
Assert.AreEqual(expected4, actual4, $"Test Truncate On All Arithmetic Operations - #4: ");
Assert.AreEqual(expected5, actual5, $"Test Truncate On All Arithmetic Operations - #5: ");
StringAssert.StartsWith(expected6, actual6, $"Test Truncate On All Arithmetic Operations - #6: ");
Assert.AreEqual(expected7, actual7, $"Test Truncate On All Arithmetic Operations - #7: ");
Assert.AreEqual(expected8, actual8, $"Test Truncate On All Arithmetic Operations - #8: ");
Assert.AreEqual(expected9, actual9, $"Test Truncate On All Arithmetic Operations - #9: ");
Assert.AreEqual(expected10, actual10, $"Test Truncate On All Arithmetic Operations - #10: ");
Assert.AreEqual(expected11, actual11, $"Test Truncate On All Arithmetic Operations - #11: ");
Assert.AreEqual(5000, BigDecimal.Precision, "Restore Precision to 5000");
}
public void DivideExpLessZero()
{
// Divide: local variable exponent is less than zero
const string a = "1231212478987482988429808779810457634781384756794987";
const int aScale = 15;
const string b = "747233429293018787918347987234564568";
const int bScale = 10;
string c = "1.64770E+10";
const int resScale = -5;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, resScale, RoundingMode.Ceiling);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public void DivideTest()
{
var res = BigDecimal.Divide(new BigDecimal(10), new BigDecimal(2));
Assert.AreEqual(new BigDecimal(5), res);
}
public void DivideBigDecimalScaleRoundingModeHalfEven()
{
String a = "3736186567876876578956958765675671119238118911893939591735";
int aScale = 5;
String b = "74723342238476237823787879183470";
int bScale = 15;
int newScale = 7;
RoundingMode rm = RoundingMode.HalfEven;
String c = "500002603731642864013619132621009722.1803810";
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, newScale, rm);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(newScale, result.Scale, "incorrect scale");
}
public void DivideBigDecimalScaleRoundingModeHalfUp()
{
String a = "3736186567876876578956958765675671119238118911893939591735";
int aScale = -51;
String b = "74723342238476237823787879183470";
int bScale = 45;
int newScale = 3;
RoundingMode rm = RoundingMode.HalfUp;
String c = "50000260373164286401361913262100972218038099522752460421" +
"05959924024355721031761947728703598332749334086415670525" +
"3761096961.670";
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, newScale, rm);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(newScale, result.Scale, "incorrect scale");
}
public void DivideBigDecimalScaleRoundingModeUp()
{
String a = "-37361671119238118911893939591735";
int aScale = 10;
String b = "74723342238476237823787879183470";
int bScale = -15;
int newScale = 31;
RoundingMode rm = RoundingMode.Up;
String c = "-5.00000E-26";
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, newScale, rm);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(newScale, result.Scale, "incorrect scale");
}
static void CalcPi(int t)
{
Console.WriteLine("You have entered " + t + " iterations");
Console.WriteLine("Calculating constant...");
acc = t * 20;
BigDecimal c = new BigDecimal(1);
c = c.Divide(882, acc, RoundingMode.HalfUp);
Console.WriteLine("Calculating summation...");
Console.ForegroundColor = ConsoleColor.Blue;
BigDecimal sumTerm = new BigDecimal(0, acc);
Parallel.For(0, t, i =>
{
BigDecimal a = CalcTerm(i);
lock (l0ck)
{
sumTerm = sumTerm.Add(a);
}
});
Console.ForegroundColor = ConsoleColor.White;
Console.Write('\n');
c = c.Multiply(sumTerm);
BigDecimal pi1 = new BigDecimal(1);
pi1 = pi1.Divide(c, acc, RoundingMode.HalfUp);
pi1 = pi1.Multiply(4);
string pi = pi1.ToString();
Console.WriteLine("Printing reliable digits...");
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("π≈");
//Check digits of pi against source
int idx = 0; int digits = 1;
StreamReader sr = new StreamReader(File.OpenRead("pi.txt"));
while (!sr.EndOfStream && (idx < pi.Length))
{
char ch = (char)sr.Read();
if (ch == pi[idx])
{
Console.Write(pi[idx]);
digits++;
}
idx++;
}
Console.ForegroundColor = ConsoleColor.White;
Console.Write('\n');
Console.WriteLine("Calculated " + digits + " digits of pi.");
}
public void DivideExpGreaterZero()
{
// Divide: local variable exponent is greater than zero
String a = "1231212478987482988429808779810457634781384756794987";
int aScale = -15;
String b = "747233429293018787918347987234564568";
int bScale = 20;
String c = "1.647694590099337641891395686052735285121058381E+50";
int resScale = -5;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, resScale, RoundingMode.Ceiling);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public void DivideBigDecimalScaleMathContextUp()
{
String a = "3736186567876876578956958765675671119238118911893939591735";
int aScale = 15;
String b = "748766876876723342238476237823787879183470";
int bScale = 10;
int precision = 21;
RoundingMode rm = RoundingMode.Up;
MathContext mc = new MathContext(precision, rm);
String c = "49897861180.2562512996";
int resScale = 10;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, mc);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public static BigDecimal Sqrt(BigDecimal x, MathContext mc)
{
if (x.CompareTo(BigDecimal.Zero) < 0)
throw new ArithmeticException("negative argument " + x + " of square root");
if (x.Abs().Subtract(new BigDecimal(System.Math.Pow(10d, -mc.Precision))).CompareTo(BigDecimal.Zero) < 0)
return ScalePrecision(BigDecimal.Zero, mc);
/* start the computation from a double precision estimate */
var s = new BigDecimal(System.Math.Sqrt(x.ToDouble()), mc);
BigDecimal half = BigDecimal.ValueOf(2);
/* increase the local accuracy by 2 digits */
var locmc = new MathContext(mc.Precision + 2, mc.RoundingMode);
/* relative accuracy requested is 10^(-precision)
*/
double eps = System.Math.Pow(10.0, -mc.Precision);
while (true) {
/* s = s -(s/2-x/2s); test correction s-x/s for being
* smaller than the precision requested. The relative correction is 1-x/s^2,
* (actually half of this, which we use for a little bit of additional protection).
*/
if (System.Math.Abs(BigDecimal.One.Subtract(x.Divide(s.Pow(2, locmc), locmc)).ToDouble()) < eps)
break;
s = s.Add(x.Divide(s, locmc)).Divide(half, locmc);
}
return s;
}
public void DivideTest3()
{
var res = BigDecimal.Divide(new BigDecimal(101.0008m), new BigDecimal(0.05m));
Assert.AreEqual(new BigDecimal(2020.016m), res);
}
public void DivideRemainderIsZero()
{
String a = "8311389578904553209874735431110";
int aScale = -15;
String b = "237468273682987234567849583746";
int bScale = 20;
String c = "3.5000000000000000000000000000000E+36";
int resScale = -5;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, resScale, RoundingMode.Ceiling);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public void DivideRoundHalfEvenPos()
{
String a = "92948782094488478231212478987482988429808779810457634781384756794987";
int aScale = -24;
String b = "7472334223847623782375469293018787918347987234564568";
int bScale = 13;
String c = "1.24390557635720517122423359799284E+53";
int resScale = -21;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, resScale, RoundingMode.HalfEven);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public void DivideExceptionRoundingMode()
{
String a = "1231212478987482988429808779810457634781384756794987";
const int aScale = 15;
String b = "747233429293018787918347987234564568";
const int bScale = 10;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
Assert.Throws<ArithmeticException>(() => aNumber.Divide(bNumber, RoundingMode.Unnecessary));
}
public static BigDecimal /*!*/ Divide(RubyContext /*!*/ context, BigDecimal /*!*/ self, BigDecimal /*!*/ other)
{
BigDecimal remainder;
return(BigDecimal.Divide(GetConfig(context), self, other, 0, out remainder));
}
public void DivideBigDecimalII()
{
BigDecimal divd1 = new BigDecimal(value2, 4);
BigDecimal divd2 = BigDecimal.Parse("0.0023");
BigDecimal divd3 = divd1.Divide(divd2, 3, RoundingMode.HalfUp);
Assert.IsTrue(divd3.ToString().Equals("536285217.391") && divd3.Scale == 3, "1233456/0.0023 is not correct");
divd2 = new BigDecimal(1345.5E-02D);
divd3 = divd1.Divide(divd2, 0, RoundingMode.Down);
Assert.IsTrue(divd3.ToString().Equals("91672") && divd3.Scale == 0,
"1233456/13.455 is not correct or does not have the correct scale");
divd2 = new BigDecimal(0000D);
Assert.Throws<ArithmeticException>(() => divd1.Divide(divd2, 4, RoundingMode.Down));
}
public void DivideRoundHalfUpNeg1()
{
String a = "-92948782094488478231212478987482988798104576347813847567949855464535634534563456";
int aScale = -24;
String b = "74723342238476237823754692930187879183479";
int bScale = 13;
String c = "-1.2439055763572051712242335979928354832010167729111113605E+76";
int resScale = -21;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, resScale, RoundingMode.HalfUp);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public void DivideRoundHalfUpNeg2()
{
String a = "-37361671119238118911893939591735";
int aScale = 10;
String b = "74723342238476237823787879183470";
int bScale = 15;
String c = "-1E+5";
int resScale = -5;
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal bNumber = new BigDecimal(BigInteger.Parse(b), bScale);
BigDecimal result = aNumber.Divide(bNumber, resScale, RoundingMode.HalfUp);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(resScale, result.Scale, "incorrect scale");
}
public void DivideBigDecimalI()
{
BigDecimal divd1 = new BigDecimal(value, 2);
BigDecimal divd2 = BigDecimal.Parse("2.335");
BigDecimal divd3 = divd1.Divide(divd2, RoundingMode.Up);
Assert.IsTrue(divd3.ToString().Equals("52873.27") && divd3.Scale == divd1.Scale, "123459.08/2.335 is not correct");
Assert.IsTrue(divd3.UnscaledValue.ToString().Equals("5287327"),
"the unscaledValue representation of 123459.08/2.335 is not correct");
divd2 = new BigDecimal(123.4D);
divd3 = divd1.Divide(divd2, RoundingMode.Down);
Assert.IsTrue(divd3.ToString().Equals("1000.47") && divd3.Scale == 2, "123459.08/123.4 is not correct");
divd2 = new BigDecimal(000D);
Assert.Throws<ArithmeticException>(() => divd1.Divide(divd2, RoundingMode.Down));
}
