public void GetDecimalsTest()
{
var val = new BigDecimal(10.01m);
var res = new BigDecimal(0.01m);
Assert.AreEqual(res, val.GetDecimals(), $"GetDecimals() does not work with value '{val}'.");
}
public void EqualsTest2()
{
object v1 = new BigDecimal(100.001);
object v2 = new BigDecimal(100.002);
Assert.IsFalse(BigDecimal.Equals(v1, v2));
}
public void Negative_Decimal_Same_In_And_Out()
{
// arrange
var expected = -1000000.00013M;
// act
var bigDec = new BigDecimal(expected);
var actual = (decimal)bigDec;
// assert
Assert.Equal(expected, actual);
}
public void Negative_ToString()
{
// arrange
var dec = -1000000.00013M;
var expected = dec.ToString("G");
// act
var bigDec = new BigDecimal(dec);
var actual = bigDec.ToString();
// assert
Assert.Equal(expected, actual);
}
public void Run(int iterations)
{
if (iterations%2 != 0) iterations++;
for (int i = 0; i < iterations; _divison += 2, i++)
{
_result -= one / _divison;
i++;
_divison += 2;
_result += one / _divison;
}
}
public void TestCtor()
{
BigDecimal d = new BigDecimal();
d = new BigDecimal(123);
d = new BigDecimal(123, 12);
try
{
d = new BigDecimal(123, -1);
Assert.Fail();
}
catch (ArgumentOutOfRangeException)
{
}
try
{
d = new BigDecimal(123, BigDecimal.MaxScale + 1);
Assert.Fail();
}
catch (ArgumentOutOfRangeException)
{
}
}
public static IEnumerable<int> Sqrt(BigDecimal value)
{
BigInteger log10 = BigDecimal.Log10Ceiling(value);
BigDecimal v = BigDecimal.Pow(100, (log10 - 1) / 2);
value /= v;
BigInteger p = 0;
BigInteger c = 0;
while (true)
{
c += (BigInteger)value;
int X = new Range(9, 0, -1, true)
.First(x => (20 * p + x) * x <= c);
c -= (20 * p + X) * X;
p *= 10;
p += X;
yield return X;
c *= 100;
value *= 100;
value %= 100;
}
}
public string Run()
{
long total = 0;
for (int i = 1; i <= 100; i++)
{
if (Math.Sqrt(i) % 1 == 0)
continue;
BigDecimal xn = new BigDecimal(1, 0);
BigDecimal xn1 = new BigDecimal(0, 0);
BigDecimal s = new BigDecimal(i, 0);
for (int q = 0; q < 11; q++)
{
xn1 = .5 * ((xn) + (s / xn));
xn = xn1;
}
string points = String.Concat(xn1.ToString().Take(100));
for (int x = 0; x < points.Length; x++)
{
total += points[x] - '0';
}
}
return total.ToString();
}
public void AddTest2()
{
var v1 = new BigDecimal(0.01m);
var v2 = new BigDecimal(0.00001m);
var res = BigDecimal.Add(v1, v2);
Assert.AreEqual(new BigDecimal(0.01001m), res);
}
public void AddTest4()
{
var v1 = new BigDecimal((BigInteger)ulong.MaxValue);
var v2 = BigDecimal.One;
var res = BigDecimal.Add(v1, v2);
var bigInt = new BigInteger(ulong.MaxValue) + 1;
Assert.AreEqual(new BigDecimal(bigInt), res);
}
public void BigDecimal_Test()
{
var d = new BigDecimal(new BigInteger(decimal.MaxValue), int.MaxValue);
var p = BigDecimal.Parse(d.ToString());
}
public void Parsing()
{
BigDecimal a = new BigDecimal(123),
b = new BigDecimal(123.456),
c = new BigDecimal(-123),
d = new BigDecimal(-123.456);
Assert.AreEqual(a, BigDecimal.Parse("123"));
Assert.AreEqual(a, BigDecimal.Parse("123.0"));
Assert.AreEqual(a, BigDecimal.Parse("123.00"));
Assert.AreEqual(a, BigDecimal.Parse("123.000"));
Assert.AreEqual(a, BigDecimal.Parse("123,0"));
Assert.AreEqual(a, BigDecimal.Parse("123,00"));
Assert.AreEqual(a, BigDecimal.Parse("123,000"));
Assert.AreEqual(b, BigDecimal.Parse("123.456"));
Assert.AreEqual(b, BigDecimal.Parse("123.4560"));
Assert.AreEqual(b, BigDecimal.Parse("123.45600"));
Assert.AreEqual(b, BigDecimal.Parse("123.456000"));
Assert.AreEqual(b, BigDecimal.Parse("123,456"));
Assert.AreEqual(b, BigDecimal.Parse("123,4560"));
Assert.AreEqual(b, BigDecimal.Parse("123,45600"));
Assert.AreEqual(b, BigDecimal.Parse("123,456000"));
Assert.AreEqual(a, BigDecimal.Parse("123", 0));
Assert.AreEqual(a, BigDecimal.Parse("123.0", 0));
Assert.AreEqual(a, BigDecimal.Parse("123.00", 0));
Assert.AreEqual(a, BigDecimal.Parse("123.000", 0));
Assert.AreEqual(a, BigDecimal.Parse("123,0", 0));
Assert.AreEqual(a, BigDecimal.Parse("123,00", 0));
Assert.AreEqual(a, BigDecimal.Parse("123,000", 0));
Assert.AreEqual(b, BigDecimal.Parse("123.456", 3));
Assert.AreEqual(b, BigDecimal.Parse("123.4560", 3));
Assert.AreEqual(b, BigDecimal.Parse("123.45600", 3));
Assert.AreEqual(b, BigDecimal.Parse("123.456000", 3));
Assert.AreEqual(b, BigDecimal.Parse("123,456", 3));
Assert.AreEqual(b, BigDecimal.Parse("123,4560", 3));
Assert.AreEqual(b, BigDecimal.Parse("123,45600", 3));
Assert.AreEqual(b, BigDecimal.Parse("123,456000", 3));
Assert.AreEqual(c, BigDecimal.Parse("-123"));
Assert.AreEqual(c, BigDecimal.Parse("-123.0"));
Assert.AreEqual(c, BigDecimal.Parse("-123.00"));
Assert.AreEqual(c, BigDecimal.Parse("-123.000"));
Assert.AreEqual(c, BigDecimal.Parse("-123,0"));
Assert.AreEqual(c, BigDecimal.Parse("-123,00"));
Assert.AreEqual(c, BigDecimal.Parse("-123,000"));
Assert.AreEqual(d, BigDecimal.Parse("-123.456"));
Assert.AreEqual(d, BigDecimal.Parse("-123.4560"));
Assert.AreEqual(d, BigDecimal.Parse("-123.45600"));
Assert.AreEqual(d, BigDecimal.Parse("-123.456000"));
Assert.AreEqual(d, BigDecimal.Parse("-123,456"));
Assert.AreEqual(d, BigDecimal.Parse("-123,4560"));
Assert.AreEqual(d, BigDecimal.Parse("-123,45600"));
Assert.AreEqual(d, BigDecimal.Parse("-123,456000"));
Assert.AreEqual(c, BigDecimal.Parse("-123", 0));
Assert.AreEqual(c, BigDecimal.Parse("-123.0", 0));
Assert.AreEqual(c, BigDecimal.Parse("-123.00", 0));
Assert.AreEqual(c, BigDecimal.Parse("-123.000", 0));
Assert.AreEqual(c, BigDecimal.Parse("-123,0", 0));
Assert.AreEqual(c, BigDecimal.Parse("-123,00", 0));
Assert.AreEqual(c, BigDecimal.Parse("-123,000", 0));
Assert.AreEqual(d, BigDecimal.Parse("-123.456", 3));
Assert.AreEqual(d, BigDecimal.Parse("-123.4560", 3));
Assert.AreEqual(d, BigDecimal.Parse("-123.45600", 3));
Assert.AreEqual(d, BigDecimal.Parse("-123.456000", 3));
Assert.AreEqual(d, BigDecimal.Parse("-123,456", 3));
Assert.AreEqual(d, BigDecimal.Parse("-123,4560", 3));
Assert.AreEqual(d, BigDecimal.Parse("-123,45600", 3));
Assert.AreEqual(d, BigDecimal.Parse("-123,456000", 3));
}
public void insertingSingleValuePrepared(Type tp)
{
string cassandraDataTypeName = convertTypeNameToCassandraEquivalent(tp);
string tableName = "table" + Guid.NewGuid().ToString("N");
ExecuteSyncNonQuery(Session, string.Format(@"CREATE TABLE {0}(
tweet_id uuid PRIMARY KEY,
value {1}
);", tableName, cassandraDataTypeName));
List<object[]> toInsert = new List<object[]>(1);
var val = RandomVal(tp);
if (tp == typeof (string))
val = "'" + val.ToString().Replace("'", "''") + "'";
var row1 = new object[2] { Guid.NewGuid(), val };
toInsert.Add(row1);
var prep = PrepareQuery(this.Session, string.Format("INSERT INTO {0}(tweet_id, value) VALUES ({1}, ?);", tableName, toInsert[0][0].ToString()));
ExecutePreparedQuery(this.Session, prep, new object[1] { toInsert[0][1] });
#if CASSANDRA_NET_40_OR_GREATER
if (tp == typeof(Decimal))
toInsert[0][1] = new BigDecimal((Decimal)toInsert[0][1]);
#endif
ExecuteSyncQuery(Session, string.Format("SELECT * FROM {0};", tableName), toInsert);
ExecuteSyncNonQuery(Session, string.Format("DROP TABLE {0};", tableName));
}
public void CompareTest2()
{
var v1 = new BigDecimal(1);
var v2 = new BigDecimal(2);
Assert.IsTrue(BigDecimal.Compare(v1, v2) < 0);
}
private static ushort SameScale(ref BigDecimal left, ref BigDecimal right) {
var newScale = Math.Max(left.scale, right.scale);
left = left.Upscale(newScale);
right = right.Upscale(newScale);
return newScale;
}
public void TestEquality()
{
BigDecimal a = new BigDecimal(14121976);
BigDecimal b = new BigDecimal(141219760000, 4);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
Assert.AreEqual(a, b);
a = new BigDecimal(14121976, 4);
b = new BigDecimal(1412.1976m);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
Assert.AreEqual(a, b);
a = new BigDecimal(-14121976, 4);
b = new BigDecimal(-1412.1976m);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
Assert.AreEqual(a, b);
}
public void BigDecimalDecimalTest3()
{
var d = -100.01m;
var tst = new BigDecimal(d);
Assert.AreEqual(d.ToString(), tst.ToString(), $"BigDecimal(decimal) '{d.ToString()}' does not work.");
}
public void OperatorDecimal2()
{
var v = new BigDecimal(1.25);
var d = (decimal)v;
Assert.IsTrue(d == 1.25m);
}
public void BigDecimalDecimalTest5()
{
string val = decimal.MinValue.ToString();
var tst = new BigDecimal(decimal.Parse(val));
Assert.AreEqual(val, tst.ToString(), $"BigDecimal(decimal) '{val}' does not work.");
}
public void OperatorDouble2()
{
var v = new BigDecimal(1.25);
var d = (double)v;
Assert.IsTrue(d == 1.25);
}
public void CompareTest6()
{
var v1 = new BigDecimal(-1.001m);
var v2 = new BigDecimal(-1.01m);
Assert.IsTrue(BigDecimal.Compare(v1, v2) > 0);
}
public void CompareTest3()
{
var v1 = new BigDecimal(1.01m);
var v2 = new BigDecimal(1.01m);
Assert.IsTrue(BigDecimal.Compare(v1, v2) == 0);
}
public void TestOperations()
{
BigDecimal a = new BigDecimal(14121976, 3);
BigDecimal b = new BigDecimal(19761214, 4);
// a + 0 = a
Assert.AreEqual((a + BigDecimal.Zero), a);
// a - a = 0
Assert.AreEqual(a - a, BigDecimal.Zero);
// a + b = b + a
Assert.AreEqual(a + b, b + a);
// a * 1 = a
Assert.AreEqual(a * BigDecimal.One, a);
// a * b = b * a
Assert.AreEqual(a * b, b * a);
// a * 0 = 0
Assert.AreEqual(a * BigDecimal.Zero, BigDecimal.Zero);
// -(-a) = a
Assert.AreEqual(-(-a), a);
// a + a = a * 2
Assert.AreEqual(a + a, a * new BigDecimal(2));
BigDecimal r = a - b;
Assert.AreEqual(r, new BigDecimal(121458546, 4));
Assert.IsTrue((a - b) > BigDecimal.Zero);
Assert.IsTrue((b - a) < BigDecimal.Zero);
}
public void NegateTest()
{
var v1= new BigDecimal(1.01m);
var v2 = new BigDecimal(-1.01m);
Assert.AreEqual(v2, BigDecimal.Negate(v1));
}
public void BigDecimalDoubleTest3()
{
var d = 1.25;
var tst = new BigDecimal(d);
Assert.AreEqual(d.ToString(), tst.ToString(), $"BigDecimal(double) '{d.ToString()}' does not work.");
}
public void SubtractTest2()
{
var v1 = new BigDecimal(0.01m);
var v2 = new BigDecimal(0.00001m);
var res = BigDecimal.Subtract(v1, v2);
Assert.AreEqual(new BigDecimal(0.00999m), res);
}
public void CompareTo()
{
BigInteger hugeInteger = BigInteger.Pow(long.MaxValue, 10);
BigDecimal hugeNegative = new BigDecimal(-hugeInteger, hugeInteger);
BigDecimal veryLargeNegative = new BigDecimal(long.MinValue, long.MaxValue);
BigDecimal largeNegative = new BigDecimal(long.MinValue, int.MaxValue);
BigDecimal mediumNegative = new BigDecimal(long.MinValue);
BigDecimal mediumNegativePlusOne = new BigDecimal(long.MinValue + 1);
BigDecimal zero = BigDecimal.Zero;
BigDecimal nine = new BigDecimal(9);
BigDecimal ten = new BigDecimal(10);
BigDecimal tenPointOne = new BigDecimal(101, -1);
BigDecimal eleven = new BigDecimal(11);
BigDecimal nineteen = new BigDecimal(19);
BigDecimal nineteenPointFive = new BigDecimal(195, -1);
BigDecimal twenty = new BigDecimal(20);
BigDecimal twentyFive = new BigDecimal(25);
BigDecimal thirty = new BigDecimal(30);
BigDecimal mediumNegativeMinusOne = new BigDecimal(long.MaxValue - 1);
BigDecimal mediumPositive = new BigDecimal(long.MaxValue);
BigDecimal largePositive = new BigDecimal(long.MaxValue, int.MaxValue);
BigDecimal veryLargePositive = new BigDecimal(long.MaxValue, long.MaxValue);
BigDecimal hugePositive = new BigDecimal(hugeInteger, hugeInteger);
var expected = new[]
{
hugeNegative,
veryLargeNegative,
largeNegative,
mediumNegative,
mediumNegativePlusOne,
zero,
nine,
ten,
tenPointOne,
eleven,
nineteen,
nineteenPointFive,
twenty,
twentyFive,
thirty,
mediumNegativeMinusOne,
mediumPositive,
largePositive,
veryLargePositive,
hugePositive
};
for (int i = 0; i < expected.Length; i++)
{
BigDecimal alpha = expected[i];
Assert.AreEqual(alpha, alpha);
Assert.AreEqual(0, alpha.CompareTo(alpha));
for (int j = i + 1; j < expected.Length; j++)
{
BigDecimal bravo = expected[j];
Assert.AreEqual(-1, alpha.CompareTo(bravo));
Assert.AreEqual(1, bravo.CompareTo(alpha));
}
}
Assert.IsTrue(expected.Shuffle().OrderBy(x => x).SequenceEqual(expected));
}
public void CompareToTest()
{
var v1 = new BigDecimal(100.001m);
var v2 = new BigDecimal(100.001m);
Assert.IsTrue(v1.CompareTo(v2) == 0);
}
public void Equals2Test2()
{
var v1 = new BigDecimal(100.001);
var v2 = new BigDecimal(100.002);
Assert.IsFalse(v1.Equals(v2));
}
public void AbsTest3()
{
var v1 = new BigDecimal(1.01m);
var v2 = new BigDecimal(1.01m);
Assert.AreEqual(v2, BigDecimal.Abs(v1));
}
