/* reduces this DBIG mod a BIG, and returns the BIG */
public virtual BIG Mod(BIG c)
{
int k = 0;
Norm();
DBIG m = new DBIG(c);
DBIG r = new DBIG(0);
if (Comp(this, m) < 0)
{
return(new BIG(this));
}
do
{
m.Shl(1);
k++;
} while (Comp(this, m) >= 0);
while (k > 0)
{
m.Shr(1);
r.Copy(this);
r.Sub(m);
r.Norm();
CMove(r, (int)(1 - ((r.w[BIG.DNLEN - 1] >> (BIG.CHUNK - 1)) & 1)));
k--;
}
return(new BIG(this));
}
/* this*=y */
/* Now uses Lazy reduction */
public void Mul(FP2 y)
{
if ((long)(a.XES + b.XES) * (y.a.XES + y.b.XES) > (long)FP.FEXCESS)
{
if (a.XES > 1)
{
a.Reduce();
}
if (b.XES > 1)
{
b.Reduce();
}
}
DBIG pR = new DBIG(0);
BIG C = new BIG(a.x);
BIG D = new BIG(y.a.x);
pR.UCopy(new BIG(ROM.Modulus));
DBIG A = BIG.Mul(a.x, y.a.x);
DBIG B = BIG.Mul(b.x, y.b.x);
C.Add(b.x);
C.Norm();
D.Add(y.b.x);
D.Norm();
DBIG E = BIG.Mul(C, D);
DBIG F = new DBIG(A);
F.Add(B);
B.RSub(pR);
A.Add(B);
A.Norm();
E.Sub(F);
E.Norm();
a.x.Copy(FP.Mod(A));
a.XES = 3;
b.x.Copy(FP.Mod(E));
b.XES = 2;
}
/* return this/c */
public virtual BIG Div(BIG c)
{
int d, k = 0;
DBIG m = new DBIG(c);
DBIG dr = new DBIG(0);
BIG r = new BIG(0);
BIG a = new BIG(0);
BIG e = new BIG(1);
Norm();
while (Comp(this, m) >= 0)
{
e.FShl(1);
m.Shl(1);
k++;
}
while (k > 0)
{
m.Shr(1);
e.Shr(1);
dr.Copy(this);
dr.Sub(m);
dr.Norm();
d = (int)(1 - ((dr.w[BIG.DNLEN - 1] >> (BIG.CHUNK - 1)) & 1));
CMove(dr, d);
r.Copy(a);
r.Add(e);
r.Norm();
a.CMove(r, d);
k--;
}
return(a);
}
