| public static Cmp ( uint digits1, uint length1, uint digits2, uint length2 ) : int | ||
| digits1 | uint | First big integer digits. |
| length1 | uint | First big integer length. |
| digits2 | uint | Second big integer digits. |
| length2 | uint | Second big integer length. |
| return | int | |
/// <summary>
/// Compares 2 <see cref="IntX" /> objects.
/// Returns "-2" if any argument is null, "-1" if <paramref name="int1" /> < <paramref name="int2" />,
/// "0" if equal and "1" if >.
/// </summary>
/// <param name="int1">First big integer.</param>
/// <param name="int2">Second big integer.</param>
/// <param name="throwNullException">Raises or not <see cref="NullReferenceException" />.</param>
/// <returns>Comparsion result.</returns>
/// <exception cref="ArgumentNullException"><paramref name="int1" /> or <paramref name="int2" /> is a null reference and <paramref name="throwNullException" /> is set to true.</exception>
static public int Cmp(IntX int1, IntX int2, bool throwNullException)
{
// If one of the operands is null, throw exception or return -2
bool isNull1 = ReferenceEquals(int1, null);
bool isNull2 = ReferenceEquals(int2, null);
if (isNull1 || isNull2)
{
if (throwNullException)
{
throw new ArgumentNullException(isNull1 ? "int1" : "int2", Strings.CantBeNullCmp);
}
else
{
return(isNull1 && isNull2 ? 0 : -2);
}
}
// Compare sign
if (int1._negative && !int2._negative)
{
return(-1);
}
if (!int1._negative && int2._negative)
{
return(1);
}
// Compare presentation
return(DigitOpHelper.Cmp(int1._digits, int1._length, int2._digits, int2._length) * (int1._negative ? -1 : 1));
}
/// <summary>
/// Subtracts two big integers.
/// </summary>
/// <param name="int1">First big integer.</param>
/// <param name="int2">Second big integer.</param>
/// <returns>Resulting big integer.</returns>
static public IntX Sub(IntX int1, IntX int2)
{
// Process zero values in special way
if (int1._length == 0)
{
return(new IntX(int2._digits, true));
}
if (int2._length == 0)
{
return(new IntX(int1));
}
// Determine lower big int (without sign)
IntX smallerInt;
IntX biggerInt;
int compareResult = DigitOpHelper.Cmp(int1._digits, int1._length, int2._digits, int2._length);
if (compareResult == 0)
{
return(new IntX()); // integers are equal
}
if (compareResult < 0)
{
smallerInt = int1;
biggerInt = int2;
}
else
{
smallerInt = int2;
biggerInt = int1;
}
// Create new big int object
IntX newInt = new IntX(biggerInt._length, ReferenceEquals(int1, smallerInt) ^ int1._negative);
// Do actual subtraction
newInt._length = DigitOpHelper.Sub(
biggerInt._digits,
biggerInt._length,
smallerInt._digits,
smallerInt._length,
newInt._digits);
// Normalization may be needed
newInt.TryNormalize();
return(newInt);
}
/// <summary>
/// Divides one <see cref="IntX" /> by another.
/// </summary>
/// <param name="int1">First big integer.</param>
/// <param name="int2">Second big integer.</param>
/// <param name="modRes">Remainder big integer.</param>
/// <param name="resultFlags">Which operation results to return.</param>
/// <returns>Divident big integer.</returns>
/// <exception cref="ArgumentNullException"><paramref name="int1" /> or <paramref name="int2" /> is a null reference.</exception>
/// <exception cref="DivideByZeroException"><paramref name="int2" /> equals zero.</exception>
virtual public IntX DivMod(IntX int1, IntX int2, out IntX modRes, DivModResultFlags resultFlags)
{
// Null reference exceptions
if (ReferenceEquals(int1, null))
{
throw new ArgumentNullException("int1", Strings.CantBeNull);
}
else if (ReferenceEquals(int2, null))
{
throw new ArgumentNullException("int2", Strings.CantBeNull);
}
// Check if int2 equals zero
if (int2._length == 0)
{
throw new DivideByZeroException();
}
// Get flags
bool divNeeded = (resultFlags & DivModResultFlags.Div) != 0;
bool modNeeded = (resultFlags & DivModResultFlags.Mod) != 0;
// Special situation: check if int1 equals zero; in this case zero is always returned
if (int1._length == 0)
{
modRes = modNeeded ? new IntX() : null;
return(divNeeded ? new IntX() : null);
}
// Special situation: check if int2 equals one - nothing to divide in this case
if (int2._length == 1 && int2._digits[0] == 1)
{
modRes = modNeeded ? new IntX() : null;
return(divNeeded ? int2._negative ? -int1 : +int1 : null);
}
// Get resulting sign
bool resultNegative = int1._negative ^ int2._negative;
// Check if int1 > int2
int compareResult = DigitOpHelper.Cmp(int1._digits, int1._length, int2._digits, int2._length);
if (compareResult < 0)
{
modRes = modNeeded ? new IntX(int1) : null;
return(divNeeded ? new IntX() : null);
}
else if (compareResult == 0)
{
modRes = modNeeded ? new IntX() : null;
return(divNeeded ? new IntX(resultNegative ? -1 : 1) : null);
}
//
// Actually divide here (by Knuth algorithm)
//
// Prepare divident (if needed)
IntX divRes = null;
if (divNeeded)
{
divRes = new IntX(int1._length - int2._length + 1U, resultNegative);
}
// Prepare mod (if needed)
if (modNeeded)
{
modRes = new IntX(int1._length + 1U, int1._negative);
}
else
{
modRes = null;
}
// Call procedure itself
uint modLength = int1._length;
uint divLength = DivMod(
int1._digits,
modNeeded ? modRes._digits : null,
ref modLength,
int2._digits,
null,
int2._length,
divNeeded ? divRes._digits : null,
resultFlags,
compareResult);
// Maybe set new lengths and perform normalization
if (divNeeded)
{
divRes._length = divLength;
divRes.TryNormalize();
}
if (modNeeded)
{
modRes._length = modLength;
modRes.TryNormalize();
}
// Return div
return(divRes);
}
/// <summary>
/// Divides two big integers.
/// Also modifies <paramref name="digitsPtr1" /> and <paramref name="length1"/> (it will contain remainder).
/// </summary>
/// <param name="digitsPtr1">First big integer digits.</param>
/// <param name="digitsBufferPtr1">Buffer for first big integer digits. May also contain remainder.</param>
/// <param name="length1">First big integer length.</param>
/// <param name="digitsPtr2">Second big integer digits.</param>
/// <param name="digitsBufferPtr2">Buffer for second big integer digits. Only temporarily used.</param>
/// <param name="length2">Second big integer length.</param>
/// <param name="digitsResPtr">Resulting big integer digits.</param>
/// <param name="resultFlags">Which operation results to return.</param>
/// <param name="cmpResult">Big integers comparsion result (pass -2 if omitted).</param>
/// <returns>Resulting big integer length.</returns>
virtual unsafe public uint DivMod(
uint *digitsPtr1,
uint *digitsBufferPtr1,
ref uint length1,
uint *digitsPtr2,
uint *digitsBufferPtr2,
uint length2,
uint *digitsResPtr,
DivModResultFlags resultFlags,
int cmpResult)
{
// Base implementation covers some special cases
bool divNeeded = (resultFlags & DivModResultFlags.Div) != 0;
bool modNeeded = (resultFlags & DivModResultFlags.Mod) != 0;
//
// Special cases
//
// Case when length1 == 0
if (length1 == 0)
{
return(0);
}
// Case when both lengths are 1
if (length1 == 1 && length2 == 1)
{
if (divNeeded)
{
*digitsResPtr = *digitsPtr1 / *digitsPtr2;
if (*digitsResPtr == 0)
{
length2 = 0;
}
}
if (modNeeded)
{
*digitsBufferPtr1 = *digitsPtr1 % *digitsPtr2;
if (*digitsBufferPtr1 == 0)
{
length1 = 0;
}
}
return(length2);
}
// Compare digits first (if was not previously compared)
if (cmpResult == -2)
{
cmpResult = DigitOpHelper.Cmp(digitsPtr1, length1, digitsPtr2, length2);
}
// Case when first value is smaller then the second one - we will have remainder only
if (cmpResult < 0)
{
// Maybe we should copy first digits into remainder (if remainder is needed at all)
if (modNeeded)
{
DigitHelper.DigitsBlockCopy(digitsPtr1, digitsBufferPtr1, length1);
}
// Zero as division result
return(0);
}
// Case when values are equal
if (cmpResult == 0)
{
// Maybe remainder must be marked as empty
if (modNeeded)
{
length1 = 0;
}
// One as division result
if (divNeeded)
{
*digitsResPtr = 1;
}
return(1);
}
// Case when second length equals to 1
if (length2 == 1)
{
// Call method basing on fact if div is needed
uint modRes;
if (divNeeded)
{
length2 = DigitOpHelper.DivMod(digitsPtr1, length1, *digitsPtr2, digitsResPtr, out modRes);
}
else
{
modRes = DigitOpHelper.Mod(digitsPtr1, length1, *digitsPtr2);
}
// Maybe save mod result
if (modNeeded)
{
if (modRes != 0)
{
length1 = 1;
*digitsBufferPtr1 = modRes;
}
else
{
length1 = 0;
}
}
return(length2);
}
// This is regular case, not special
return(uint.MaxValue);
}
