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 DecimalPowerLimitPrecisionTest()
{
BigDecimal bd = new BigDecimal(22, 1);
Assert.AreEqual(new BigDecimal(265599227, 5), BigDecimal.Pow(bd, 10, 5));
Assert.AreEqual(new BigDecimal(BigInteger.Parse("70542949868640404"), 10), BigDecimal.Pow(bd, 20, 10));
}
public string ToHexString()
{
var fullDecimal = Value * BigDecimal.Pow(10, (int)Token.Precision);
var bytes = ByteUtils.TrimLeadingZeroes(fullDecimal.GetWholePart().ToByteArray());
return(ByteUtils.ToHexString(bytes, Prefix.ZeroLowerX));
}
public void DecimalPowerTest1()
{
BigDecimal bd = new BigDecimal(21, 1);
Assert.AreEqual(new BigDecimal(441, 2), BigDecimal.Pow(bd, 2));
Assert.AreEqual(new BigDecimal(9261, 3), BigDecimal.Pow(bd, 3));
Assert.AreEqual(new BigDecimal(194481, 4), BigDecimal.Pow(bd, 4));
}
public void DecimalPowerTest2()
{
BigDecimal bd = new BigDecimal(212, 2);
Assert.AreEqual(new BigDecimal(44944, 4), BigDecimal.Pow(bd, 2));
Assert.AreEqual(new BigDecimal(9528128, 6), BigDecimal.Pow(bd, 3));
Assert.AreEqual(new BigDecimal(2019963136, 8), BigDecimal.Pow(bd, 4));
}
public void PowersOf2Test()
{
BigDecimal bd = new BigDecimal(2);
Assert.AreEqual(new BigDecimal(8), BigDecimal.Pow(bd, 3));
Assert.AreEqual(new BigDecimal(16), BigDecimal.Pow(bd, 4));
Assert.AreEqual(new BigDecimal(256), BigDecimal.Pow(BigDecimal.Pow(bd, 4), 2));
}
public SqlNumber Pow(SqlNumber exp)
{
if (State == NumericState.None)
{
return(new SqlNumber(innerValue.Pow(exp.innerValue)));
}
return(this);
}
public void OperatorDouble4()
{
var v = BigDecimal.Pow(10, -300);
var d = (double)v;
var ok = (double)Math.Pow(10, -300);
Assert.AreEqual(ok, d);
}
public void OperatorDouble5()
{
var v = (BigDecimal.Pow(10, 600) + 1) / BigDecimal.Pow(10, 300);
var d = (double)v;
var ok = (double)Math.Pow(10, 300);
Assert.AreEqual(ok, d);
}
public void OperatorDecimal4()
{
var v = BigDecimal.Pow(10, -25);
var d = (decimal)v;
var ok = (decimal)Math.Pow(10, -25);
Assert.AreEqual(ok, d);
}
public void OperatorDecimal5()
{
var v = (BigDecimal.Pow(10, 50) + 1) / BigDecimal.Pow(10, 25);
var d = (decimal)v;
var ok = (decimal)Math.Pow(10, 25);
Assert.AreEqual(ok, d);
}
public void Binary_functions_should_throw_for_null_argument()
{
var x1 = new BigDecimal(1.1);
((Action)(() => x1.Add(null))).ShouldThrow <NullReferenceException>();
((Action)(() => x1.Sub(null))).ShouldThrow <NullReferenceException>();
((Action)(() => x1.Mul(null))).ShouldThrow <NullReferenceException>();
((Action)(() => x1.Div(null))).ShouldThrow <NullReferenceException>();
((Action)(() => x1.Pow(null))).ShouldThrow <NullReferenceException>();
((Action)(() => x1.Dim(null))).ShouldThrow <NullReferenceException>();
}
object IPowerable.Pow(object right)
{
if (!(right is RealNumber))
{
throw new ArgumentException("Not a real number", nameof(right));
}
var v = (RealNumber)right;
//return new RealNumber(System.Math.Pow(Value,v.Value));
return(new RealNumber(BigDecimal.Pow(Value, (BigInteger)v.Value)));
}
public BigDecimal calDens(BigDecimal radius)
{
BigDecimal vol = BigDecimal.Parse("0.0");
BigDecimal num = BigDecimal.Parse("1.33333333333");
BigDecimal pi = BigDecimal.Parse(Math.PI.ToString());
BigDecimal mass = BigInteger.Parse("1990000000000000000000000000000");
BigDecimal dens = BigDecimal.Parse("0.0");
num = num.Multiply(pi);
vol = radius.Pow(3);
vol = num.Multiply(vol);
dens = mass / (vol);
//while (mass.compareTo(vol.toBigInteger()) < 0)
while (mass.CompareTo(((BigInteger)vol)) < 0)
{
if (type == ("Average_Star"))
{
mass = range(Average_Starmax, Average_Starmin);
}
if (type == ("Massive_Star"))
{
mass = range(Massive_Starmax, Massive_Starmin);
}
if (type == ("White_Dwarf"))
{
mass = range(White_Dwarfmax, White_Dwarfmin);
}
if (type == ("Neutron_Star"))
{
mass = range(Neutron_Starmax, Neutron_Starmin);
}
if (type == ("Black_hole"))
{
mass = range(Black_holemax, Black_holemin);
}
else
{
break;
}
}
dens = mass / (vol);
density = dens;
//if(density.compareTo(BigDecimal.Parse("1")) < 0 ){
// Console.WriteLine("its 0");
// System.exit(0);
//}
return(dens);
}
public async Task <string> Mint(string receiverAddress, decimal amount)
{
var account = new Account(privateKey, Chain.Ropsten);
var web3 = new Web3(account, nodeAddress);
var mintHandler = web3.Eth.GetContractTransactionHandler <MintFunction>();
var mint = new MintFunction()
{
To = receiverAddress,
TokenAmount = (new BigDecimal(amount) * BigDecimal.Pow(10, 18)).Mantissa
};
var receipt = await mintHandler.SendRequestAndWaitForReceiptAsync(contractAddress, mint);
return(receipt.TransactionHash);
}
public static byte[] ByteArrayAmount(BigDecimal value, int precision)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value), "amount is null");
}
if (precision < 0)
{
throw new ArgumentNullException(nameof(precision), "precision is invalid");
}
var bigDecimal = value * BigDecimal.Pow(10, precision);
var bigInt = bigDecimal.GetWholePart();
return(ByteUtils.TrimLeadingZeroes(bigInt.ToByteArray()));
}
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);
}
/// <summary>
/// Convert a decimal defaultDecimalStringToByteArray to a byte array. </summary>
/// <param name="amountString"> it is a decimal string. e.g. "42.42" </param>
/// <param name="precisionLevel"> the precision level, means 10 power 18 precision. </param>
public static byte[] DecimalStringToByteArray(string amountString, int precisionLevel)
{
if (string.IsNullOrWhiteSpace(amountString))
{
throw new ArgumentException("amount string is blank.", nameof(amountString));
}
if (precisionLevel < 0)
{
throw new ArgumentException("precision level is less than 0", nameof(precisionLevel));
}
BigDecimal amountDecimal = BigDecimal.Parse(amountString);
BigDecimal precisionDecimal = BigDecimal.Pow(10, precisionLevel);
BigDecimal realAmount = BigDecimal.Multiply(amountDecimal, precisionDecimal);
return(TrimLeadingZeroes(realAmount.GetWholePart().ToByteArray()));
}
private BigDecimal luminosityOfAStar(BigInteger dia, int surtemp)
{
BigDecimal radi = BigDecimal.Parse("0.0");
BigDecimal surfaceAreaOfTheStar = BigDecimal.Parse("0.0");
BigInteger two = BigDecimal.Parse("2");
dia = dia.Divide(two);
radi = BigDecimal.Parse(dia);
radi = radi.Pow(2);
surfaceAreaOfTheStar = radi * (BigDecimal.Parse((4 * Math.PI).ToString()));
BigDecimal luminosity = surfaceAreaOfTheStar * (BigDecimal.Parse(".0000000567"));
luminosity = luminosity * (BigDecimal.Parse(surtemp.ToString()).Pow(4));
setStarluminosity(luminosity);
return(luminosity);
}
public Number Pow(int exp)
{
if (State == NumberState.NegativeInfinity)
{
return(NegativeInfinity);
}
if (State == NumberState.PositiveInfinity)
{
return(PositiveInfinity);
}
if (State == NumberState.NotANumber)
{
return(NaN);
}
return(new Number(State, bigDecimal.Pow(exp)));
}
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));
}
public BigDecimal gPull(BigInteger mass, BigInteger planetMass)
{
BigDecimal mass2 = BigDecimal.Parse(mass);
Console.WriteLine("" + mass);
BigDecimal planetMass2 = BigDecimal.Parse(planetMass);
Console.WriteLine("" + mass);
BigDecimal distance = BigDecimal.Parse("0");
BigInteger gp = BigInteger.Parse("0");
BigDecimal G = BigDecimal.Parse("0.0000000000667");
distance = BigDecimal.Parse("149000000000");
gp = G.Multiply(mass2);
gp = gp.Multiply(planetMass2);
gp = gp.Divide(distance.Pow(2));
setgp(gp);
return(gp);
}
/// <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 static BigDecimal PowRound(BigDecimal x, int n)
{
/** Special cases: x^1=x and x^0 = 1
*/
if (n == 1)
return x;
if (n == 0)
return BigDecimal.One;
/* The relative error in the result is n times the relative error in the input.
* The estimation is slightly optimistic due to the integer rounding of the logarithm.
* Since the standard BigDecimal.pow can only handle positive n, we split the algorithm.
*/
var mc = new MathContext(x.Precision - (int) System.Math.Log10(System.Math.Abs(n)));
if (n > 0)
return x.Pow(n, mc);
return BigDecimal.One.Divide(x.Pow(-n), mc);
}
static void BigDecimalLog()
{
Console.WindowWidth = 122;
BigDecimal.SetPrecision(116);
Console.WriteLine("Constants:");
Console.WriteLine($"π = {BigDecimal.PI}");
Console.WriteLine($"e = {BigDecimal.E}");
Console.WriteLine($"φ = {BigDecimal.GoldenRatio}");
BigDecimal.SetPrecision(88);
BigDecimal x = BigDecimal.Exp(BigDecimal.E);
Console.WriteLine($"\nFunctions:");
Console.WriteLine($"x = {x}");
Console.WriteLine($"Function name | Value | Average time");
Console.WriteLine($"Ln(x) | {BigDecimal.Ln(x).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Ln(x)).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Ln(Ln(x)) | {BigDecimal.Ln(BigDecimal.Ln(x)).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Ln(BigDecimal.Ln(x))).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Exp(x) | {BigDecimal.Exp(x).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Exp(x)).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Pow(x, x) | {BigDecimal.Pow(x, x).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Pow(x, x)).TotalMilliseconds,10:0.000}ms");
x = BigDecimal.PI / 4;
Console.WriteLine($"\nx = {x}");
Console.WriteLine($"Function name | Value | Average time");
Console.WriteLine($"Sin(x) | {BigDecimal.Sin(x).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Sin(x)).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Cos(x) | {BigDecimal.Cos(x).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Cos(x)).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Tg(x) | {BigDecimal.Tg(x).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Tg(x)).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Ctg(x) | {BigDecimal.Ctg(x).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.Ctg(x)).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Arcsin(sin(x)) | {BigDecimal.ArcSin(BigDecimal.Sin(x)).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.ArcSin(BigDecimal.Sin(x))).TotalMilliseconds,10:0.000}ms");
Console.WriteLine($"Arccos(cos(x)) | {BigDecimal.ArcCos(BigDecimal.Cos(x)).ToString().PadRight(2, '.').PadRight(90, '0').Remove(89),89} | {MeasureTime(() => BigDecimal.ArcCos(BigDecimal.Cos(x))).TotalMilliseconds,10:0.000}ms");
decimal[] Decimals = new decimal[7]
{
decimal.MinusOne,
decimal.Zero,
decimal.One,
decimal.MinValue,
decimal.MaxValue,
new decimal(1, 0, 0, true, 28),
new decimal(1, 0, 0, false, 28)
};
BigDecimal.SetPrecision(32);
Console.WriteLine($"\n{"Convertation:",-15}| {typeof(decimal),-32} | {typeof(BigDecimal),-32} | {typeof(decimal),-32}");
foreach (decimal d in Decimals)
{
Console.WriteLine(BigDecimalConvertLog(d));
}
double[] Doubles = new double[5]
{
-1d, 0d, 1d,
// double.MinValue, // No support for scientific notation yet
// double.MaxValue, // Too long values
-double.Epsilon,
double.Epsilon
};
Console.WriteLine($"\n{"Convertation:",-15}| {typeof(double),-32} | {typeof(BigDecimal),-32} | {typeof(double),-32}");
foreach (double d in Doubles)
{
Console.WriteLine(BigDecimalConvertLog(d));
}
}
protected override void UpdateMinerTimer_Elapsed(object sender, ElapsedEventArgs e)
{
if (m_isGetMiningParameters)
{
return;
}
try
{
m_isGetMiningParameters = true;
var miningParameters = GetMiningParameters();
if (miningParameters == null)
{
OnGetMiningParameterStatus(this, false);
return;
}
CurrentChallenge = miningParameters.ChallengeByte32;
if (m_lastParameters == null || miningParameters.Challenge.Value != m_lastParameters.Challenge.Value)
{
Program.Print(string.Format("[INFO] New challenge detected {0}...", miningParameters.ChallengeByte32String));
OnNewChallenge(this, miningParameters.ChallengeByte32, MinerAddress);
if (m_challengeReceiveDateTime == DateTime.MinValue)
{
m_challengeReceiveDateTime = DateTime.Now;
}
}
if (m_lastParameters == null || miningParameters.MiningTarget.Value != m_lastParameters.MiningTarget.Value)
{
Program.Print(string.Format("[INFO] New target detected {0}...", miningParameters.MiningTargetByte32String));
OnNewTarget(this, miningParameters.MiningTarget);
}
if (m_lastParameters == null || miningParameters.MiningDifficulty.Value != m_lastParameters.MiningDifficulty.Value)
{
Program.Print(string.Format("[INFO] New difficulity detected ({0})...", miningParameters.MiningDifficulty.Value));
OnNewDifficulty?.Invoke(this, miningParameters.MiningDifficulty);
Difficulty = miningParameters.MiningDifficulty;
// Actual difficulty should have decimals
var calculatedDifficulty = BigDecimal.Exp(BigInteger.Log(MaxTarget.Value) - BigInteger.Log(miningParameters.MiningTarget.Value));
var calculatedDifficultyBigInteger = BigInteger.Parse(calculatedDifficulty.ToString().Split(",.".ToCharArray())[0]);
try // Perform rounding
{
if (uint.Parse(calculatedDifficulty.ToString().Split(",.".ToCharArray())[1].First().ToString()) >= 5)
{
calculatedDifficultyBigInteger++;
}
}
catch { }
if (Difficulty.Value != calculatedDifficultyBigInteger)
{
Difficulty = new HexBigInteger(calculatedDifficultyBigInteger);
var expValue = BigInteger.Log10(calculatedDifficultyBigInteger);
var calculatedTarget = BigInteger.Parse(
(BigDecimal.Parse(MaxTarget.Value.ToString()) * BigDecimal.Pow(10, expValue) / (calculatedDifficulty * BigDecimal.Pow(10, expValue))).
ToString().Split(",.".ToCharArray())[0]);
var calculatedTargetHex = new HexBigInteger(calculatedTarget);
Program.Print(string.Format("[INFO] Update target 0x{0}...", calculatedTarget.ToString("x64")));
OnNewTarget(this, calculatedTargetHex);
CurrentTarget = calculatedTargetHex;
}
}
IsPause = miningParameters.IsPause;
m_lastParameters = miningParameters;
OnStopSolvingCurrentChallenge(this, stopSolving: miningParameters.IsPause);
OnGetMiningParameterStatus(this, true);
}
catch (Exception ex)
{
HandleException(ex);
}
finally { m_isGetMiningParameters = false; }
}
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 PowTest2()
{
var res = BigDecimal.Pow(2.5, 5);
Assert.AreEqual(new BigDecimal(97.65625m), res, "BigDecimal.Pow() does not work.");
}
public static BigDecimal Hypot(int n, BigDecimal x)
{
/* compute n^2+x^2 in infinite precision
*/
BigDecimal z = (new BigDecimal(n)).Pow(2).Add(x.Pow(2));
/* Truncate to the precision set by x. Absolute error = in z (square of the result) is |2*x*xerr|,
* where the error is 1/2 of the ulp. Two intermediate protection digits.
* zerr is a signed value, but used only in conjunction with err2prec(), so this feature does not harm.
*/
double zerr = x.ToDouble()*x.Ulp().ToDouble();
var mc = new MathContext(2 + ErrorToPrecision(z.ToDouble(), zerr));
/* Pull square root */
z = Sqrt(z.Round(mc));
/* Final rounding. Absolute error in the square root is x*xerr/z, where zerr holds 2*x*xerr.
*/
mc = new MathContext(ErrorToPrecision(z.ToDouble(), 0.5*zerr/z.ToDouble()));
return z.Round(mc);
}
public static BigDecimal Hypot(BigDecimal x, BigDecimal y)
{
/* compute x^2+y^2
*/
BigDecimal z = x.Pow(2).Add(y.Pow(2));
/* truncate to the precision set by x and y. Absolute error = 2*x*xerr+2*y*yerr,
* where the two errors are 1/2 of the ulp's. Two intermediate protectio digits.
*/
BigDecimal zerr = x.Abs().Multiply(x.Ulp()).Add(y.Abs().Multiply(y.Ulp()));
var mc = new MathContext(2 + ErrorToPrecision(z, zerr));
/* Pull square root */
z = Sqrt(z.Round(mc));
/* Final rounding. Absolute error in the square root is (y*yerr+x*xerr)/z, where zerr holds 2*(x*xerr+y*yerr).
*/
mc = new MathContext(ErrorToPrecision(z.ToDouble(), 0.5*zerr.ToDouble()/z.ToDouble()));
return z.Round(mc);
}
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 static BigDecimal Root(int n, BigDecimal x)
{
if (x.CompareTo(BigDecimal.Zero) < 0)
throw new ArithmeticException("negative argument " + x + " of root");
if (n <= 0)
throw new ArithmeticException("negative power " + n + " of root");
if (n == 1)
return x;
/* start the computation from a double precision estimate */
var s = new BigDecimal(System.Math.Pow(x.ToDouble(), 1.0/n));
/* this creates nth with nominal precision of 1 digit
*/
var nth = new BigDecimal(n);
/* Specify an internal accuracy within the loop which is
* slightly larger than what is demanded by 'eps' below.
*/
BigDecimal xhighpr = ScalePrecision(x, 2);
var mc = new MathContext(2 + x.Precision);
/* Relative accuracy of the result is eps.
*/
double eps = x.Ulp().ToDouble()/(2*n*x.ToDouble());
for (;;) {
/* s = s -(s/n-x/n/s^(n-1)) = s-(s-x/s^(n-1))/n; test correction s/n-x/s for being
* smaller than the precision requested. The relative correction is (1-x/s^n)/n,
*/
BigDecimal c = xhighpr.Divide(s.Pow(n - 1), mc);
c = s.Subtract(c);
var locmc = new MathContext(c.Precision);
c = c.Divide(nth, locmc);
s = s.Subtract(c);
if (System.Math.Abs(c.ToDouble()/s.ToDouble()) < eps)
break;
}
return s.Round(new MathContext(ErrorToPrecision(eps)));
}
public BigInteger ToBigInteger()
{
var fullDecimal = Value * (BigDecimal.Pow(10, (int)Token.Precision));
return(fullDecimal.GetWholePart());
}
public void PowWithContext(string a, int aScale, int exp, string c, int cScale, int precision, RoundingMode roundingMode)
{
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
MathContext mc = new MathContext(precision, roundingMode);
BigDecimal result = aNumber.Pow(exp, mc);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(cScale, result.Scale, "incorrect scale");
}
public void Pow(string a, int aScale, int exp, string c, int cScale)
{
BigDecimal aNumber = new BigDecimal(BigInteger.Parse(a), aScale);
BigDecimal result = aNumber.Pow(exp);
Assert.AreEqual(c, result.ToString(), "incorrect value");
Assert.AreEqual(cScale, result.Scale, "incorrect scale");
}
public void PowTest()
{
var res = BigDecimal.Pow(2, 5);
Assert.AreEqual(new BigDecimal(32), res, "BigDecimal.Pow() does not work.");
}
public static BigDecimal PowRound(BigDecimal x, Rational q)
{
/** Special cases: x^1=x and x^0 = 1
*/
if (q.CompareTo(BigInteger.One) == 0)
return x;
if (q.Sign == 0)
return BigDecimal.One;
if (q.IsInteger) {
/* We are sure that the denominator is positive here, because normalize() has been
* called during constrution etc.
*/
return PowRound(x, q.Numerator);
}
/* Refuse to operate on the general negative basis. The integer q have already been handled above.
*/
if (x.CompareTo(BigDecimal.Zero) < 0)
throw new ArithmeticException("Cannot power negative " + x);
if (q.IsIntegerFraction) {
/* Newton method with first estimate in double precision.
* The disadvantage of this first line here is that the result must fit in the
* standard range of double precision numbers exponents.
*/
double estim = System.Math.Pow(x.ToDouble(), q.ToDouble());
var res = new BigDecimal(estim);
/* The error in x^q is q*x^(q-1)*Delta(x).
* The relative error is q*Delta(x)/x, q times the relative error of x.
*/
var reserr = new BigDecimal(0.5*q.Abs().ToDouble()
*x.Ulp().Divide(x.Abs(), MathContext.Decimal64).ToDouble());
/* The main point in branching the cases above is that this conversion
* will succeed for numerator and denominator of q.
*/
int qa = q.Numerator.ToInt32();
int qb = q.Denominator.ToInt32();
/* Newton iterations. */
BigDecimal xpowa = PowRound(x, qa);
for (;;) {
/* numerator and denominator of the Newton term. The major
* disadvantage of this implementation is that the updates of the powers
* of the new estimate are done in full precision calling BigDecimal.pow(),
* which becomes slow if the denominator of q is large.
*/
BigDecimal nu = res.Pow(qb).Subtract(xpowa);
BigDecimal de = MultiplyRound(res.Pow(qb - 1), q.Denominator);
/* estimated correction */
BigDecimal eps = nu.Divide(de, MathContext.Decimal64);
BigDecimal err = res.Multiply(reserr, MathContext.Decimal64);
int precDiv = 2 + ErrorToPrecision(eps, err);
if (precDiv <= 0) {
/* The case when the precision is already reached and any precision
* will do. */
eps = nu.Divide(de, MathContext.Decimal32);
} else {
eps = nu.Divide(de, new MathContext(precDiv));
}
res = SubtractRound(res, eps);
/* reached final precision if the relative error fell below reserr,
* |eps/res| < reserr
*/
if (eps.Divide(res, MathContext.Decimal64).Abs().CompareTo(reserr) < 0) {
/* delete the bits of extra precision kept in this
* working copy.
*/
return res.Round(new MathContext(ErrorToPrecision(reserr.ToDouble())));
}
}
}
/* The error in x^q is q*x^(q-1)*Delta(x) + Delta(q)*x^q*log(x).
* The relative error is q/x*Delta(x) + Delta(q)*log(x). Convert q to a floating point
* number such that its relative error becomes negligible: Delta(q)/q << Delta(x)/x/log(x) .
*/
int precq = 3 + ErrorToPrecision((x.Ulp().Divide(x, MathContext.Decimal64)).ToDouble()
/System.Math.Log(x.ToDouble()));
/* Perform the actual calculation as exponentiation of two floating point numbers.
*/
return Pow(x, q.ToBigDecimal(new MathContext(precq)));
}
