public void TestAbs()
{
TestCommon.CompareTestEqual(
ToCN(2),
ToCN(-2).Abs());
TestCommon.CompareTestEqual(
ToCN(2),
ToCN(2).Abs());
TestCommon.CompareTestEqual(
ToCN(2.5),
ToCN(-2.5).Abs());
{
CBORNumber objectTemp = ToCN(EDecimal.FromString("6.63"));
CBORNumber objectTemp2 = ToCN(EDecimal.FromString(
"-6.63")).Abs();
TestCommon.CompareTestEqual(objectTemp, objectTemp2);
}
{
CBORNumber objectTemp = ToCN(EFloat.FromString("2.75"));
CBORNumber objectTemp2 = ToCN(EFloat.FromString("-2.75")).Abs();
TestCommon.CompareTestEqual(objectTemp, objectTemp2);
}
{
CBORNumber objectTemp = ToCN(ERational.FromDouble(2.5));
CBORNumber objectTemp2 = ToCN(ERational.FromDouble(-2.5)).Abs();
TestCommon.CompareTestEqual(objectTemp, objectTemp2);
}
}
public CBORObject ValidateObject(CBORObject obj)
{
if (obj.Type != CBORType.Array)
{
throw new CBORException("Rational number must be an array");
}
if (obj.Count != 2)
{
throw new CBORException("Rational number requires exactly 2 items");
}
CBORObject first = obj[0];
CBORObject second = obj[1];
if (!first.IsIntegral)
{
throw new CBORException("Rational number requires integer numerator");
}
if (!second.IsIntegral)
{
throw new CBORException("Rational number requires integer denominator");
}
if (second.Sign <= 0)
{
throw new CBORException("Rational number requires denominator greater than 0");
}
EInteger denom = second.AsEInteger();
// NOTE: Discards tags. See comment in CBORTag2.
return(denom.Equals(EInteger.One) ?
CBORObject.FromObject(first.AsEInteger()) :
CBORObject.FromObject(
ERational.Create(
first.AsEInteger(),
denom)));
}
public void TestCreateNaN()
{
try {
ERational.CreateNaN(null);
Assert.Fail("Should have failed");
} catch (ArgumentNullException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
try {
ERational.CreateNaN(EInteger.FromString("-1"));
Assert.Fail("Should have failed");
} catch (ArgumentException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
try {
ERational.CreateNaN(null, false, false);
Assert.Fail("Should have failed");
} catch (ArgumentNullException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
ERational ef = ERational.CreateNaN(EInteger.Zero, false, true);
Assert.IsTrue(ef.IsNegative);
ef = ERational.CreateNaN(EInteger.Zero, false, false);
Assert.IsTrue(!ef.IsNegative);
}
public bool CanFitInDouble(object obj)
{
var ef = (ERational)obj;
return((!ef.IsFinite) || (ef.CompareTo(ERational.FromDouble(
ef.ToDouble())) == 0));
}
internal ExtendedRational(ERational er)
{
if (er == null)
{
throw new ArgumentNullException(nameof(er));
}
this.er = er;
}
public void MathComparisonTest()
{
var r = new ERational(142342, 432);
var f = EFloat.FromString("1.5", null);
Console.WriteLine("{0}, {1}", r, f);
Assert.IsTrue(r.CompareToBinary(f) > 0);
}
/// <include file='../docs.xml'
/// path='docs/doc[@name="M:PeterO.ExtendedRational.Create(System.Int32,System.Int32)"]/*'/>
public static ExtendedRational Create(
int numeratorSmall,
int denominatorSmall)
{
return(new ExtendedRational(
ERational.Create(
numeratorSmall,
denominatorSmall)));
}
public static void TestStringEqualRoundTrip(ERational obj)
{
string str = obj.ToString();
ERational newobj = ERational.FromString(str);
string str2 = newobj.ToString();
TestCommon.AssertEqualsHashCode(obj, newobj);
TestCommon.AssertEqualsHashCode(str, str2);
}
public void TestEquals()
{
ERational era = ERational.FromString("0/3920");
ERational erb = ERational.FromString("0/3920");
TestCommon.CompareTestEqualAndConsistent(
era,
erb);
}
public void TestCompareTo()
{
var r = new RandomGenerator();
for (var i = 0; i < 500; ++i)
{
ERational bigintA = RandomObjects.RandomERational(r);
ERational bigintB = RandomObjects.RandomERational(r);
ERational bigintC = RandomObjects.RandomERational(r);
TestCommon.CompareTestRelations(bigintA, bigintB, bigintC);
}
TestCommon.CompareTestLess(ERational.Zero, ERational.NaN);
ERational rat, rat2;
for (var i = 0; i < 100; ++i)
{
EInteger num = RandomObjects.RandomEInteger(r);
if (num.IsZero)
{
// Skip if number is 0; 0/1 and 0/2 are
// equal in that case
continue;
}
num = num.Abs();
rat = ERational.Create(num, EInteger.One);
rat2 = ERational.Create(num, (EInteger)2);
TestCommon.CompareTestLess(rat2, rat);
TestCommon.CompareTestGreater(rat, rat2);
}
TestCommon.CompareTestLess(
ERational.Create(EInteger.One, (EInteger)2),
ERational.Create((EInteger)4, EInteger.One));
for (var i = 0; i < 100; ++i)
{
EInteger num = RandomObjects.RandomEInteger(r);
EInteger den = RandomObjects.RandomEInteger(r);
if (den.IsZero)
{
den = EInteger.One;
}
rat = ERational.Create(num, den);
for (int j = 0; j < 10; ++j)
{
EInteger num2 = num;
EInteger den2 = den;
EInteger mult = RandomObjects.RandomEInteger(r);
if (mult.IsZero || mult.Equals(EInteger.One))
{
mult = (EInteger)2;
}
num2 *= (EInteger)mult;
den2 *= (EInteger)mult;
rat2 = ERational.Create(num2, den2);
TestCommon.CompareTestEqual(rat, rat2);
}
}
}
public static void TestStringEqualRoundTrip(EFloat obj)
{
Assert.AreEqual(
EDecimal.PositiveInfinity,
EDecimal.FromSingle(Single.PositiveInfinity));
Assert.AreEqual(
EDecimal.NegativeInfinity,
EDecimal.FromSingle(Single.NegativeInfinity));
Assert.AreEqual(
EFloat.PositiveInfinity,
EFloat.FromDouble(Double.PositiveInfinity));
Assert.AreEqual(
EFloat.NegativeInfinity,
EFloat.FromDouble(Double.NegativeInfinity));
Assert.AreEqual(
EFloat.PositiveInfinity,
EFloat.FromSingle(Single.PositiveInfinity));
Assert.AreEqual(
EFloat.NegativeInfinity,
EFloat.FromSingle(Single.NegativeInfinity));
Assert.AreEqual(
ERational.PositiveInfinity,
ERational.FromDouble(Double.PositiveInfinity));
Assert.AreEqual(
ERational.NegativeInfinity,
ERational.FromDouble(Double.NegativeInfinity));
Assert.AreEqual(
ERational.PositiveInfinity,
ERational.FromSingle(Single.PositiveInfinity));
Assert.AreEqual(
ERational.NegativeInfinity,
ERational.FromSingle(Single.NegativeInfinity));
Assert.AreEqual(
ERational.PositiveInfinity,
ERational.FromEDecimal(EDecimal.PositiveInfinity));
Assert.AreEqual(
ERational.NegativeInfinity,
ERational.FromEDecimal(EDecimal.NegativeInfinity));
Assert.AreEqual(
ERational.PositiveInfinity,
ERational.FromEFloat(EFloat.PositiveInfinity));
Assert.AreEqual(
ERational.NegativeInfinity,
ERational.FromEFloat(EFloat.NegativeInfinity));
Assert.IsTrue(Double.IsPositiveInfinity(ERational.PositiveInfinity.ToDouble()));
Assert.IsTrue(Double.IsNegativeInfinity(ERational.NegativeInfinity.ToDouble()));
Assert.IsTrue(Single.IsPositiveInfinity(ERational.PositiveInfinity.ToSingle()));
Assert.IsTrue(Single.IsNegativeInfinity(ERational.NegativeInfinity.ToSingle()));
}
/// <summary>Returns the sum of this number and another
/// number.</summary>
/// <param name='b'>The number to add with this one.</param>
/// <returns>The sum of this number and another number.</returns>
/// <exception cref='ArgumentNullException'>The parameter <paramref
/// name='b'/> is null.</exception>
public CBORNumber Add(CBORNumber b)
{
if (b == null)
{
throw new ArgumentNullException(nameof(b));
}
CBORNumber a = this;
object objA = a.value;
object objB = b.value;
Kind typeA = a.kind;
Kind typeB = b.kind;
if (typeA == Kind.Integer && typeB == Kind.Integer)
{
var valueA = (long)objA;
var valueB = (long)objB;
if ((valueA < 0 && valueB < Int64.MinValue - valueA) ||
(valueA > 0 && valueB > Int64.MaxValue - valueA))
{
// would overflow, convert to EInteger
return(CBORNumber.FromObject(
EInteger.FromInt64(valueA).Add(EInteger.FromInt64(valueB))));
}
return(new CBORNumber(Kind.Integer, valueA + valueB));
}
if (typeA == Kind.ERational ||
typeB == Kind.ERational)
{
ERational e1 =
GetNumberInterface(typeA).AsExtendedRational(objA);
ERational e2 = GetNumberInterface(typeB).AsExtendedRational(objB);
return(new CBORNumber(Kind.ERational, e1.Add(e2)));
}
if (typeA == Kind.EDecimal ||
typeB == Kind.EDecimal)
{
EDecimal e1 =
GetNumberInterface(typeA).AsExtendedDecimal(objA);
EDecimal e2 = GetNumberInterface(typeB).AsExtendedDecimal(objB);
return(new CBORNumber(Kind.EDecimal, e1.Add(e2)));
}
if (typeA == Kind.EFloat || typeB == Kind.EFloat ||
typeA == Kind.Double || typeB == Kind.Double)
{
EFloat e1 = GetNumberInterface(typeA).AsExtendedFloat(objA);
EFloat e2 = GetNumberInterface(typeB).AsExtendedFloat(objB);
return(new CBORNumber(Kind.EFloat, e1.Add(e2)));
}
else
{
EInteger b1 = GetNumberInterface(typeA).AsEInteger(objA);
EInteger b2 = GetNumberInterface(typeB).AsEInteger(objB);
return(new CBORNumber(Kind.EInteger, b1 + (EInteger)b2));
}
}
public static ERational RandomERational(IRandomGenExtended rand)
{
EInteger bigintA = RandomEInteger(rand);
EInteger bigintB = RandomEInteger(rand);
if (bigintB.IsZero)
{
bigintB = EInteger.One;
}
return(ERational.Create(bigintA, bigintB));
}
public void TestToString()
{
var fr = new RandomGenerator();
ERational dec;
for (var i = 0; i < 1000; ++i)
{
dec = RandomObjects.RandomERational(fr);
ExtraTest.TestStringEqualRoundTrip(dec);
}
dec = ERational.FromString("-0/500");
ExtraTest.TestStringEqualRoundTrip(dec);
}
/// <summary>Returns the remainder when this number is divided by
/// another number.</summary>
/// <param name='b'>The right-hand side (dividend) of the remainder
/// operation.</param>
/// <returns>The remainder when this number is divided by the other
/// number.</returns>
/// <exception cref='ArgumentNullException'>The parameter <paramref
/// name='b'/> is null.</exception>
public CBORNumber Remainder(CBORNumber b)
{
if (b == null)
{
throw new ArgumentNullException(nameof(b));
}
object objA = this.value;
object objB = b.value;
Kind typeA = this.kind;
Kind typeB = b.kind;
if (typeA == Kind.Integer && typeB == Kind.Integer)
{
var valueA = (long)objA;
var valueB = (long)objB;
return((valueA == Int64.MinValue && valueB == -1) ?
CBORNumber.FromObject(0) : CBORNumber.FromObject(valueA % valueB));
}
if (typeA == Kind.ERational ||
typeB == Kind.ERational)
{
ERational e1 =
GetNumberInterface(typeA).AsExtendedRational(objA);
ERational e2 = GetNumberInterface(typeB).AsExtendedRational(objB);
return(CBORNumber.FromObject(e1.Remainder(e2)));
}
if (typeA == Kind.EDecimal ||
typeB == Kind.EDecimal)
{
EDecimal e1 =
GetNumberInterface(typeA).AsExtendedDecimal(objA);
EDecimal e2 = GetNumberInterface(typeB).AsExtendedDecimal(objB);
return(CBORNumber.FromObject(e1.Remainder(e2, null)));
}
if (typeA == Kind.EFloat ||
typeB == Kind.EFloat || typeA == Kind.Double || typeB ==
Kind.Double)
{
EFloat e1 =
GetNumberInterface(typeA).AsExtendedFloat(objA);
EFloat e2 = GetNumberInterface(typeB).AsExtendedFloat(objB);
return(CBORNumber.FromObject(e1.Remainder(e2, null)));
}
else
{
EInteger b1 = GetNumberInterface(typeA).AsEInteger(objA);
EInteger b2 = GetNumberInterface(typeB).AsEInteger(objB);
return(CBORNumber.FromObject(b1 % (EInteger)b2));
}
}
public void TestToDouble()
{
// test for correct rounding
double dbl;
dbl = ERational.FromEDecimal(
EDecimal.FromString(
"1.972579273363468721491642554610734805464744567871093749999999999999"))
.ToDouble();
{
string stringTemp = EFloat.FromDouble(dbl).ToPlainString();
Assert.AreEqual(
"1.9725792733634686104693400920950807631015777587890625",
stringTemp);
}
}
public static void TestStringEqualRoundTrip(ERational obj)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
string str = obj.ToString();
ERational newobj = ERational.FromString(str);
if (str.Length < 100 || !obj.Equals(newobj))
{
TestCommon.AssertEqualsHashCode(obj, newobj);
string str2 = newobj.ToString();
TestCommon.AssertEqualsHashCode(str, str2);
}
}
public void TestCompareToDecimal()
{
var fr = new RandomGenerator();
for (var i = 0; i < 100; ++i)
{
ERational er = RandomObjects.RandomERational(fr);
int exp = -100000 + fr.UniformInt(200000);
EDecimal ed = EDecimal.Create(
RandomObjects.RandomEInteger(fr),
(EInteger)exp);
ERational er2 = ERational.FromEDecimal(ed);
int c2r = er.CompareTo(er2);
int c2d = er.CompareToDecimal(ed);
Assert.AreEqual(c2r, c2d);
}
}
/// <include file='../docs.xml'
/// path='docs/doc[@name="M:PeterO.ExtendedRational.Create(PeterO.BigInteger,PeterO.BigInteger)"]/*'/>
public static ExtendedRational Create(
BigInteger numerator,
BigInteger denominator)
{
if (numerator == null)
{
throw new ArgumentNullException(nameof(numerator));
}
if (denominator == null)
{
throw new ArgumentNullException(nameof(denominator));
}
return(new ExtendedRational(
ERational.Create(
numerator.Ei,
denominator.Ei)));
}
public void TestRemainder()
{
var fr = new RandomGenerator();
for (var i = 0; i < 100; ++i)
{
ERational er;
ERational er2;
er = ERational.Create(
RandomObjects.RandomEInteger(fr),
EInteger.One);
er2 = ERational.Create(
RandomObjects.RandomEInteger(fr),
EInteger.One);
if (er2.IsZero || !er2.IsFinite)
{
continue;
}
if (er.IsZero || !er.IsFinite)
{
// Code below will divide by "er",
// so skip if "er" is zero
continue;
}
ERational ermult = er.Multiply(er2);
ERational erdiv = ermult.Divide(er);
erdiv = ermult.Remainder(er);
if (!erdiv.IsZero)
{
Assert.Fail(ermult + "; " + er);
}
erdiv = ermult.Remainder(er2);
if (!erdiv.IsZero)
{
Assert.Fail(er + "; " + er2);
}
}
}
public void TestDivide()
{
var fr = new RandomGenerator();
for (var i = 0; i < 500; ++i)
{
ERational er = RandomObjects.RandomERational(fr);
ERational er2 = RandomObjects.RandomERational(fr);
if (er2.IsZero || !er2.IsFinite)
{
continue;
}
if (er.IsZero || !er.IsFinite)
{
continue;
}
ERational ermult = er.Multiply(er2);
ERational erdiv = ermult.Divide(er);
TestCommon.CompareTestEqual(erdiv, er2);
erdiv = ermult.Divide(er2);
TestCommon.CompareTestEqual(erdiv, er);
}
}
public ERational AsExtendedRational(object obj)
{
return(ERational.FromEFloat((EFloat)obj));
}
public static CBORObject Subtract(CBORObject a, CBORObject b)
{
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b == null)
{
throw new ArgumentNullException("b");
}
if (a.Type != CBORType.Number)
{
throw new ArgumentException("a.Type (" + a.Type +
") is not equal to " + CBORType.Number);
}
if (b.Type != CBORType.Number)
{
throw new ArgumentException("b.Type (" + b.Type +
") is not equal to " + CBORType.Number);
}
object objA = a.ThisItem;
object objB = b.ThisItem;
int typeA = a.ItemType;
int typeB = b.ItemType;
if (typeA == CBORObject.CBORObjectTypeInteger && typeB ==
CBORObject.CBORObjectTypeInteger)
{
var valueA = (long)objA;
var valueB = (long)objB;
if ((valueB < 0 && Int64.MaxValue + valueB < valueA) ||
(valueB > 0 && Int64.MinValue + valueB > valueA))
{
// would overflow, convert to EInteger
return(CBORObject.FromObject(((EInteger)valueA) -
(EInteger)valueB));
}
return(CBORObject.FromObject(valueA - valueB));
}
if (typeA == CBORObject.CBORObjectTypeExtendedRational ||
typeB == CBORObject.CBORObjectTypeExtendedRational)
{
ERational e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedRational(objA);
ERational e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedRational(objB);
return(CBORObject.FromObject(e1.Subtract(e2)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedDecimal ||
typeB == CBORObject.CBORObjectTypeExtendedDecimal)
{
EDecimal e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedDecimal(objA);
EDecimal e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedDecimal(objB);
return(CBORObject.FromObject(e1.Subtract(e2)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedFloat || typeB ==
CBORObject.CBORObjectTypeExtendedFloat ||
typeA == CBORObject.CBORObjectTypeDouble || typeB ==
CBORObject.CBORObjectTypeDouble ||
typeA == CBORObject.CBORObjectTypeSingle || typeB ==
CBORObject.CBORObjectTypeSingle)
{
EFloat e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedFloat(objA);
EFloat e2 = CBORObject.GetNumberInterface(typeB).AsExtendedFloat(objB);
return(CBORObject.FromObject(e1.Subtract(e2)));
}
else
{
EInteger b1 = CBORObject.GetNumberInterface(typeA).AsEInteger(objA);
EInteger b2 = CBORObject.GetNumberInterface(typeB).AsEInteger(objB);
return(CBORObject.FromObject(b1 - (EInteger)b2));
}
}
public static CBORObject Remainder(CBORObject a, CBORObject b)
{
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b == null)
{
throw new ArgumentNullException("b");
}
if (a.Type != CBORType.Number)
{
throw new ArgumentException("a.Type (" + a.Type +
") is not equal to " + CBORType.Number);
}
if (b.Type != CBORType.Number)
{
throw new ArgumentException("b.Type (" + b.Type +
") is not equal to " + CBORType.Number);
}
object objA = a.ThisItem;
object objB = b.ThisItem;
int typeA = a.ItemType;
int typeB = b.ItemType;
if (typeA == CBORObject.CBORObjectTypeInteger && typeB ==
CBORObject.CBORObjectTypeInteger)
{
var valueA = (long)objA;
var valueB = (long)objB;
return((valueA == Int64.MinValue && valueB == -1) ?
CBORObject.FromObject(0) : CBORObject.FromObject(valueA % valueB));
}
if (typeA == CBORObject.CBORObjectTypeExtendedRational ||
typeB == CBORObject.CBORObjectTypeExtendedRational)
{
ERational e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedRational(objA);
ERational e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedRational(objB);
return(CBORObject.FromObject(e1.Remainder(e2)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedDecimal ||
typeB == CBORObject.CBORObjectTypeExtendedDecimal)
{
EDecimal e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedDecimal(objA);
EDecimal e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedDecimal(objB);
return(CBORObject.FromObject(e1.Remainder(e2, null)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedFloat || typeB ==
CBORObject.CBORObjectTypeExtendedFloat ||
typeA == CBORObject.CBORObjectTypeDouble || typeB ==
CBORObject.CBORObjectTypeDouble ||
typeA == CBORObject.CBORObjectTypeSingle || typeB ==
CBORObject.CBORObjectTypeSingle)
{
EFloat e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedFloat(objA);
EFloat e2 = CBORObject.GetNumberInterface(typeB).AsExtendedFloat(objB);
return(CBORObject.FromObject(e1.Remainder(e2, null)));
}
else
{
EInteger b1 = CBORObject.GetNumberInterface(typeA).AsEInteger(objA);
EInteger b2 = CBORObject.GetNumberInterface(typeB).AsEInteger(objB);
return(CBORObject.FromObject(b1 % (EInteger)b2));
}
}
public static CBORObject Divide(CBORObject a, CBORObject b)
{
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b == null)
{
throw new ArgumentNullException("b");
}
if (a.Type != CBORType.Number)
{
throw new ArgumentException("a.Type (" + a.Type +
") is not equal to " + CBORType.Number);
}
if (b.Type != CBORType.Number)
{
throw new ArgumentException("b.Type (" + b.Type +
") is not equal to " + CBORType.Number);
}
object objA = a.ThisItem;
object objB = b.ThisItem;
int typeA = a.ItemType;
int typeB = b.ItemType;
if (typeA == CBORObject.CBORObjectTypeInteger && typeB ==
CBORObject.CBORObjectTypeInteger)
{
var valueA = (long)objA;
var valueB = (long)objB;
if (valueB == 0)
{
return((valueA == 0) ? CBORObject.NaN : ((valueA < 0) ?
CBORObject.NegativeInfinity : CBORObject.PositiveInfinity));
}
if (valueA == Int64.MinValue && valueB == -1)
{
return(CBORObject.FromObject(valueA).Negate());
}
long quo = valueA / valueB;
long rem = valueA - (quo * valueB);
return((rem == 0) ? CBORObject.FromObject(quo) :
CBORObject.FromObject(
ERational.Create(
(EInteger)valueA,
(EInteger)valueB)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedRational ||
typeB == CBORObject.CBORObjectTypeExtendedRational)
{
ERational e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedRational(objA);
ERational e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedRational(objB);
return(CBORObject.FromObject(e1.Divide(e2)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedDecimal ||
typeB == CBORObject.CBORObjectTypeExtendedDecimal)
{
EDecimal e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedDecimal(objA);
EDecimal e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedDecimal(objB);
if (e1.IsZero && e2.IsZero)
{
return(CBORObject.NaN);
}
EDecimal eret = e1.Divide(e2, null);
// If either operand is infinity or NaN, the result
// is already exact. Likewise if the result is a finite number.
if (!e1.IsFinite || !e2.IsFinite || eret.IsFinite)
{
return(CBORObject.FromObject(eret));
}
ERational er1 =
CBORObject.GetNumberInterface(typeA).AsExtendedRational(objA);
ERational er2 =
CBORObject.GetNumberInterface(typeB).AsExtendedRational(objB);
return(CBORObject.FromObject(er1.Divide(er2)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedFloat || typeB ==
CBORObject.CBORObjectTypeExtendedFloat ||
typeA == CBORObject.CBORObjectTypeDouble || typeB ==
CBORObject.CBORObjectTypeDouble ||
typeA == CBORObject.CBORObjectTypeSingle || typeB ==
CBORObject.CBORObjectTypeSingle)
{
EFloat e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedFloat(objA);
EFloat e2 = CBORObject.GetNumberInterface(typeB).AsExtendedFloat(objB);
if (e1.IsZero && e2.IsZero)
{
return(CBORObject.NaN);
}
EFloat eret = e1.Divide(e2, null);
// If either operand is infinity or NaN, the result
// is already exact. Likewise if the result is a finite number.
if (!e1.IsFinite || !e2.IsFinite || eret.IsFinite)
{
return(CBORObject.FromObject(eret));
}
ERational er1 =
CBORObject.GetNumberInterface(typeA).AsExtendedRational(objA);
ERational er2 =
CBORObject.GetNumberInterface(typeB).AsExtendedRational(objB);
return(CBORObject.FromObject(er1.Divide(er2)));
}
else
{
EInteger b1 = CBORObject.GetNumberInterface(typeA).AsEInteger(objA);
EInteger b2 = CBORObject.GetNumberInterface(typeB).AsEInteger(objB);
if (b2.IsZero)
{
return(b1.IsZero ? CBORObject.NaN : ((b1.Sign < 0) ?
CBORObject.NegativeInfinity : CBORObject.PositiveInfinity));
}
EInteger bigrem;
EInteger bigquo;
{
EInteger[] divrem = b1.DivRem(b2);
bigquo = divrem[0];
bigrem = divrem[1];
}
return(bigrem.IsZero ? CBORObject.FromObject(bigquo) :
CBORObject.FromObject(ERational.Create(b1, b2)));
}
}
public static CBORObject Multiply(CBORObject a, CBORObject b)
{
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b == null)
{
throw new ArgumentNullException("b");
}
if (a.Type != CBORType.Number)
{
throw new ArgumentException("a.Type (" + a.Type +
") is not equal to " + CBORType.Number);
}
if (b.Type != CBORType.Number)
{
throw new ArgumentException("b.Type (" + b.Type +
") is not equal to " + CBORType.Number);
}
object objA = a.ThisItem;
object objB = b.ThisItem;
int typeA = a.ItemType;
int typeB = b.ItemType;
if (typeA == CBORObject.CBORObjectTypeInteger && typeB ==
CBORObject.CBORObjectTypeInteger)
{
var valueA = (long)objA;
var valueB = (long)objB;
bool apos = valueA > 0L;
bool bpos = valueB > 0L;
if (
(apos && ((!bpos && (Int64.MinValue / valueA) > valueB) ||
(bpos && valueA > (Int64.MaxValue / valueB)))) ||
(!apos && ((!bpos && valueA != 0L &&
(Int64.MaxValue / valueA) > valueB) ||
(bpos && valueA < (Int64.MinValue / valueB)))))
{
// would overflow, convert to EInteger
var bvalueA = (EInteger)valueA;
var bvalueB = (EInteger)valueB;
return(CBORObject.FromObject(bvalueA * (EInteger)bvalueB));
}
return(CBORObject.FromObject(valueA * valueB));
}
if (typeA == CBORObject.CBORObjectTypeExtendedRational ||
typeB == CBORObject.CBORObjectTypeExtendedRational)
{
ERational e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedRational(objA);
ERational e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedRational(objB);
return(CBORObject.FromObject(e1.Multiply(e2)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedDecimal ||
typeB == CBORObject.CBORObjectTypeExtendedDecimal)
{
EDecimal e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedDecimal(objA);
EDecimal e2 =
CBORObject.GetNumberInterface(typeB).AsExtendedDecimal(objB);
return(CBORObject.FromObject(e1.Multiply(e2)));
}
if (typeA == CBORObject.CBORObjectTypeExtendedFloat || typeB ==
CBORObject.CBORObjectTypeExtendedFloat ||
typeA == CBORObject.CBORObjectTypeDouble || typeB ==
CBORObject.CBORObjectTypeDouble ||
typeA == CBORObject.CBORObjectTypeSingle || typeB ==
CBORObject.CBORObjectTypeSingle)
{
EFloat e1 =
CBORObject.GetNumberInterface(typeA).AsExtendedFloat(objA);
EFloat e2 = CBORObject.GetNumberInterface(typeB).AsExtendedFloat(objB);
return(CBORObject.FromObject(e1.Multiply(e2)));
}
else
{
EInteger b1 = CBORObject.GetNumberInterface(typeA).AsEInteger(objA);
EInteger b2 = CBORObject.GetNumberInterface(typeB).AsEInteger(objB);
return(CBORObject.FromObject(b1 * (EInteger)b2));
}
}
public ERational AsERational(object obj)
{
return(ERational.FromEDecimal((EDecimal)obj));
}
public ERational AsERational(object obj)
{
return(ERational.FromInt64((long)obj));
}
private static decimal ExtendedRationalToDecimal(ERational
extendedNumber)
{
return((decimal)extendedNumber);
}
public static ExtendedRational ToLegacy(ERational er)
{
return(ExtendedRational.ToLegacy(er));
}
