internal RawNum ExtendedGcd(RawNum left, RawNum right, out OmgNum x, out OmgNum y)
{
if (left.IsZero())
{
x = 0.ToOmgNum();
y = 1.ToOmgNum();
RawNum gcd = OmgPool.GetRawZero();
gcd.CopyFrom(right);
return(gcd);
}
var divModRes = OmgOp.DivMod(right.OmgWrapper(), left.OmgWrapper());
RawNum gcdRes = ExtendedGcd(divModRes.mod.Raw, left, out OmgNum x2, out OmgNum y2);
divModRes.mod.Release();
OmgNum multRes = OmgOp.Multiply(divModRes.div, x2);
divModRes.div.Release();
x = OmgOp.Subtract(y2, multRes);
y2.Release();
multRes.Release();
y = x2;
return(gcdRes);
}
private OmgNum _MakeFastPow(OmgNum left, RawNum right, OmgNum mod)
{
if (right.IsZero())
{
var res = OmgPool.GetRawZero();
res.Digits.Add(1);
return(new OmgNum(res));
}
var rightCopy = OmgPool.GetRawZero();
rightCopy.CopyFrom(right);
bool even = (rightCopy.Digits[0] & 1) == 0;
if (even)
{
rightCopy.DivByTwo();
var p = _MakeFastPow(left, rightCopy, mod);
OmgNum powSquare = OmgOp.Multiply(p, p);
OmgNum powSquareModded = OmgOp.Mod(powSquare, mod);
powSquare.Release();
p.Release();
OmgPool.ReleaseNumber(rightCopy);
return(powSquareModded);
}
else
{
_SubOne(rightCopy);
var p = _MakeFastPow(left, rightCopy, mod);
OmgNum powPlusOne = OmgOp.Multiply(p, left);
OmgNum powPlusOneModded = OmgOp.Mod(powPlusOne, mod);
powPlusOne.Release();
p.Release();
OmgPool.ReleaseNumber(rightCopy);
return(powPlusOneModded);
}
}
internal RawNum FindGcd(RawNum left, RawNum right)
{
if (left.IsZero())
{
RawNum gcd = OmgPool.GetRawZero();
gcd.CopyFrom(right);
return(gcd);
}
var divModRes = OmgOp.DivMod(right.OmgWrapper(), left.OmgWrapper());
divModRes.div.Release();
RawNum gcdRes = FindGcd(divModRes.mod.Raw, left);
divModRes.mod.Release();
return(gcdRes);
}
internal RawNum Multiply(RawNum left, RawNum right)
{
m_multRaw = OmgPool.GetRawZero();
if (left.IsZero() || right.IsZero())
{
return(m_multRaw);
}
if (left.Size < right.Size)
{
_Swap(ref left, ref right);
}
_MakeMult(left, right);
while (m_multRaw.Size > 0 && m_multRaw.Digits[m_multRaw.Size - 1] == 0)
{
m_multRaw.Digits.RemoveAt(m_multRaw.Size - 1);
}
return(m_multRaw);
}
internal RawNum Pow(RawNum left, RawNum right, RawNum mod = null)
{
m_powRes = OmgPool.GetZero();
if (left.IsZero())
{
return(m_powRes.Raw);
}
if (right.IsZero())
{
m_powRes.Raw.Digits.Add(1);
return(m_powRes.Raw);
}
if (mod == null)
{
return(_MakeFastPow(new OmgNum(left), right).Raw);
}
else
{
return(_MakeFastPow(new OmgNum(left), right, new OmgNum(mod)).Raw);
}
}
internal RawNum MultiplyKaratsuba(RawNum left, RawNum right)
{
if (left.IsZero() || right.IsZero())
{
return(OmgPool.GetRawZero());
}
int n = Math.Min(left.Size, right.Size);
(RawNum head, RawNum tail)leftSep = _SeparateHead(left, n);
(RawNum head, RawNum tail)rightSep = _SeparateHead(right, n);
RawNum headsProd = Multiply(leftSep.head, rightSep.head);
RawNum tailsProd = Multiply(leftSep.tail, rightSep.tail);
RawNum headTail = Multiply(leftSep.head, rightSep.tail);
RawNum tailHead = Multiply(leftSep.tail, rightSep.head);
OmgNum midSum = OmgOp.Add(new OmgNum(headTail), new OmgNum(tailHead));
m_multRaw = OmgPool.GetRawZero();
m_multRaw.CopyFrom(tailsProd);
midSum.Raw.Digits.InsertRange(0, Enumerable.Repeat <uint>(0, n));
headsProd.Digits.InsertRange(0, Enumerable.Repeat <uint>(0, 2 * n));
OmgNum res = OmgOp.Add(new OmgNum(tailsProd), midSum);
OmgNum finalRes = OmgOp.Add(new OmgNum(headsProd), res);
midSum.Release();
res.Release();
OmgPool.ReleaseNumber(headTail);
OmgPool.ReleaseNumber(tailHead);
return(finalRes.Raw);
}