340 lines
6.3 KiB
C++
340 lines
6.3 KiB
C++
/*
|
|
* MIRACL C++ Implementation file GF2m12x.cpp
|
|
*
|
|
* AUTHOR : M. Scott
|
|
*
|
|
* PURPOSE : Implementation of class GF2m12x (12-th extension over 2^m)
|
|
* uses irreducible polynomial x^12+x^FA+x^FB+x^FC+1
|
|
*
|
|
* WARNING: This class has been cobbled together for a specific use with
|
|
* the MIRACL library. It is not complete, and may not work in other
|
|
* applications
|
|
*
|
|
*/
|
|
|
|
#include "gf2m12x.h"
|
|
|
|
using namespace std;
|
|
|
|
void GF2m12x::get(GF2m* a)
|
|
{for (int i=0;i<FM;i++) a[i]=x[i];}
|
|
|
|
void GF2m12x::get(GF2m& a)
|
|
{a=x[0];}
|
|
|
|
int GF2m12x::degree()
|
|
{
|
|
for (int i=FM-1;i>=1;i--)
|
|
{
|
|
if (!x[i].iszero()) return i;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
GF2m12x& GF2m12x::powq()
|
|
{
|
|
GF2m t[2*FM],m;
|
|
int i,j,r=(get_mip()->M)%FM;
|
|
if (r==0) return *this;
|
|
|
|
for (j=0;j<r;j++)
|
|
{
|
|
for (i=0;i<FM;i++)
|
|
{
|
|
t[2*i]=x[i];
|
|
}
|
|
for (i=2*FM-2;i>=FM;i--)
|
|
{ // reduce mod x^FM+x^FA+x^FB+x^FC+1
|
|
m=t[i]; if (m.iszero()) continue;
|
|
t[i]=0;
|
|
t[i-FM]+=m;
|
|
t[i-(FM-FA)]+=m;
|
|
#ifdef FB
|
|
t[i-(FM-FB)]+=m;
|
|
t[i-(FM-FC)]+=m;
|
|
#endif
|
|
}
|
|
for (i=0;i<FM;i++)
|
|
{
|
|
x[i]=t[i];
|
|
t[i]=0;
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
GF2m12x& GF2m12x::operator*=(const GF2m12x& b)
|
|
{
|
|
int i;
|
|
GF2m t[2*FM],m;
|
|
if (this==&b)
|
|
{ // squaring
|
|
for (i=0;i<FM;i++)
|
|
{
|
|
t[2*i]=x[i]*x[i];
|
|
}
|
|
|
|
for (i=2*FM-2;i>=FM;i--)
|
|
{ // reduce mod x^FM+x^FA+x^FB+x^FC+1
|
|
m=t[i]; if (m.iszero()) continue;
|
|
t[i]=0;
|
|
t[i-FM]+=m;
|
|
t[i-(FM-FA)]+=m;
|
|
#ifdef FB
|
|
t[i-(FM-FB)]+=m;
|
|
t[i-(FM-FC)]+=m;
|
|
#endif
|
|
|
|
}
|
|
for (i=0;i<FM;i++)
|
|
{
|
|
x[i]=t[i];
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
else
|
|
{ // Use Karatsuba
|
|
|
|
int i;
|
|
|
|
big A[FM],B[FM],C[2*FM],T[2*FM];
|
|
GF2m12x bb=b;
|
|
|
|
char *memc=(char *)memalloc(4*FM);
|
|
|
|
for (i=0;i<2*FM;i++)
|
|
{
|
|
C[i]=mirvar_mem(memc,i);
|
|
T[i]=mirvar_mem(memc,i+2*FM);
|
|
}
|
|
|
|
for (i=0;i<FM;i++)
|
|
{
|
|
A[i]=getbig(x[i]);
|
|
B[i]=getbig(bb.x[i]);
|
|
}
|
|
|
|
karmul2_poly(FM,T,A,B,C);
|
|
|
|
for (i=0;i<2*FM;i++)
|
|
{
|
|
t[i]=C[i];
|
|
}
|
|
for (i=2*FM-2;i>=FM;i--)
|
|
{
|
|
m=t[i]; t[i]=0;
|
|
t[i-FM]+=m;
|
|
t[i-(FM-FA)]+=m;
|
|
#ifdef FB
|
|
t[i-(FM-FB)]+=m;
|
|
t[i-(FM-FC)]+=m;
|
|
#endif
|
|
}
|
|
|
|
for (i=0;i<FM;i++)
|
|
{
|
|
x[i]=t[i];
|
|
}
|
|
|
|
memkill(memc,4*FM);
|
|
|
|
return *this;
|
|
}
|
|
|
|
}
|
|
|
|
GF2m12x& GF2m12x::operator*=(const GF2m& b)
|
|
{
|
|
for (int i=0;i<FM;i++) x[i]*=b;
|
|
return *this;
|
|
}
|
|
|
|
GF2m12x& GF2m12x::operator/=(const GF2m& b)
|
|
{
|
|
GF2m ib=(GF2m)1/b;
|
|
for (int i=0;i<FM;i++) x[i]*=ib;
|
|
return *this;
|
|
}
|
|
|
|
//
|
|
// Lim & Hwang - just one field inversion
|
|
//
|
|
|
|
void GF2m12x::invert()
|
|
{
|
|
int degF,degG,degB,degC,degM,d,i,j;
|
|
GF2m alpha,beta,gamma,BB[FM+1],FF[FM+1],CC[FM+1],GG[FM+1];
|
|
|
|
GF2m *B=BB,*C=CC,*F=FF,*G=GG,*T;
|
|
|
|
C[0]=1;
|
|
F[FM]=F[FA]=F[0]=1; // f(x)
|
|
|
|
#ifdef FB
|
|
F[FB]=F[FC]=1;
|
|
#endif
|
|
|
|
|
|
degF=FM; degG=degree(); degC=0; degB=-1;
|
|
|
|
if (degG==0)
|
|
{
|
|
x[0]=(GF2m)1/x[0];
|
|
return;
|
|
}
|
|
|
|
for (i=0;i<FM;i++)
|
|
{
|
|
G[i]=x[i];
|
|
x[i]=0;
|
|
}
|
|
while (degF!=0)
|
|
{
|
|
if (degF<degG)
|
|
{ // swap
|
|
T=F; F=G; G=T; d=degF; degF=degG; degG=d;
|
|
T=B; B=C; C=T; d=degB; degB=degC; degC=d;
|
|
}
|
|
j=degF-degG;
|
|
alpha=G[degG]*G[degG];
|
|
beta=F[degF]*G[degG];
|
|
gamma=G[degG]*F[degF-1] + F[degF]*G[degG-1];
|
|
|
|
for (i=0;i<=degF;i++ )
|
|
{
|
|
F[i]*=alpha;
|
|
if (i>=j-1) F[i]+=gamma*G[i-j+1];
|
|
if (i>=j) F[i]+=beta*G[i-j];
|
|
}
|
|
for (i=0;i<=degB || i<=degC+j;i++)
|
|
{
|
|
B[i]*=alpha;
|
|
if (i>=j-1) B[i]+=gamma*C[i-j+1];
|
|
if (i>=j) B[i]+=beta*C[i-j];
|
|
}
|
|
while (degF>=0 && F[degF]==0) degF--;
|
|
|
|
if (degF==degG)
|
|
{
|
|
alpha=F[degF];
|
|
for (i=0;i<=degF;i++)
|
|
{
|
|
F[i]*=G[degF];
|
|
F[i]+=alpha*G[i];
|
|
}
|
|
|
|
for (i=0;i<=FM-degF;i++)
|
|
{
|
|
B[i]*=G[degF];
|
|
B[i]+=alpha*C[i];
|
|
}
|
|
while (degF>=0 && F[degF]==0) degF--;
|
|
}
|
|
degB=FM-1; while (degB>=0 && B[degB]==0) degB--;
|
|
}
|
|
alpha=(GF2m)1/F[0];
|
|
for (i=0;i<=degB;i++)
|
|
x[i]=alpha*B[i];
|
|
return;
|
|
}
|
|
|
|
GF2m12x& GF2m12x::operator/=(const GF2m12x& a)
|
|
{
|
|
GF2m12x b=a;
|
|
b.invert();
|
|
*this *= b;
|
|
return *this;
|
|
}
|
|
|
|
GF2m12x operator+(const GF2m12x& a,const GF2m12x& b)
|
|
{ GF2m12x r=a; r+=b; return r;}
|
|
|
|
GF2m12x operator+(const GF2m12x& a,const GF2m& b)
|
|
{ GF2m12x r=a; r+=b; return r;}
|
|
|
|
GF2m12x operator+(const GF2m& a,const GF2m12x& b)
|
|
{ GF2m12x r=b; r+=a; return r;}
|
|
|
|
GF2m12x operator*(const GF2m12x& a,const GF2m12x& b)
|
|
{
|
|
GF2m12x r=a;
|
|
if (&a!=&b) r*=b;
|
|
else r*=r;
|
|
return r;
|
|
}
|
|
|
|
GF2m12x operator/(const GF2m12x& a,const GF2m12x& b)
|
|
{
|
|
GF2m12x r=a;
|
|
r/=b;
|
|
return r;
|
|
}
|
|
|
|
GF2m12x operator*(const GF2m12x& a,const GF2m& b)
|
|
{ GF2m12x r=a; r*=b; return r;}
|
|
GF2m12x operator*(const GF2m& a,const GF2m12x& b)
|
|
{ GF2m12x r=b; r*=a; return r;}
|
|
|
|
GF2m12x randx12(void)
|
|
{
|
|
int m=get_mip()->M;
|
|
GF2m12x r;
|
|
for (int i=0;i<FM;i++) r.x[i]=rand(m,2);
|
|
return r;
|
|
}
|
|
|
|
GF2m12x pow(const GF2m12x& a,const Big& k)
|
|
{
|
|
int i,j,nb,n,nbw,nzs;
|
|
GF2m12x u,u2,t[16];
|
|
if (k.iszero()) return (GF2m12x)1;
|
|
u=a;
|
|
if (k.isone()) return u;
|
|
|
|
//
|
|
// Prepare table for windowing
|
|
//
|
|
u2=(u*u);
|
|
t[0]=u;
|
|
|
|
for (i=1;i<16;i++)
|
|
t[i]=u2*t[i-1];
|
|
|
|
// Left to right method - with windows
|
|
|
|
nb=bits(k);
|
|
if (nb>1) for (i=nb-2;i>=0;)
|
|
{
|
|
n=window(k,i,&nbw,&nzs,5);
|
|
for (j=0;j<nbw;j++) u*=u;
|
|
if (n>0) u*=t[n/2];
|
|
i-=nbw;
|
|
if (nzs)
|
|
{
|
|
for (j=0;j<nzs;j++) u*=u;
|
|
i-=nzs;
|
|
}
|
|
}
|
|
return u;
|
|
}
|
|
|
|
ostream& operator<<(ostream& os,const GF2m12x& x)
|
|
{
|
|
GF2m12x u=x;
|
|
GF2m a[FM];
|
|
|
|
u.get(a);
|
|
|
|
os << "[";
|
|
for (int i=0;i<FM-1;i++)
|
|
{
|
|
os << (Big)a[i] << ",";
|
|
}
|
|
|
|
os << (Big)a[FM-1] << "]";
|
|
|
|
return os;
|
|
}
|