void PrintOutput(const vector<int>& vOutput)
{
cout << "output:" << endl;
cout << "(binary)";
for( UINT i=0; i<vOutput.size(); i++ )
{
cout << " " << (int) vOutput[i];
}
cout << endl;
ZZ out;
out.SetSize(vOutput.size());
cout << "(numeric:big-endian) ";
int size = vOutput.size();
for( int i=0; i<size; i++ )
{
if( bit(out,i) != vOutput[i] )
SwitchBit(out,i);
}
cout << out << endl;
cout << "(numeric:little-endian) ";
for( int i=0; i<size; i++ )
{
if( bit(out,i) != vOutput[size-i-1] )
SwitchBit(out,i);
}
cout << out << endl;
}
NTL_CLIENT
// given tau in F_q compute the 'trace of Frob_q' for the curve
// y^2=x^3+a4*x+a6 over the residue field F_q(tau). if D!=0, then
// curve is assumed to be smooth. otherwise, distinguishes between
// mult've and add've red'n and computes correct trace. (D=disc)
long trace_tau(zz_pE& tau, ell_surfaceInfoT::affine_model& model)
{
static zz_pE a4_tau, a6_tau, b, e;
// additive reduction
if (IsZero(eval(model.A, tau)))
return 0;
// split multiplicative reduction
if (IsZero(eval(model.M_sp, tau)))
return +1;
// non-split multiplicative reduction
if (IsZero(eval(model.M_ns, tau)))
return -1;
// good red'n
a4_tau = eval(model.a4, tau);
a6_tau = eval(model.a6, tau);
ell_pE::init(a4_tau, a6_tau);
long order = ell_pE::order();
static ZZ trace;
trace = zz_pE::cardinality()+1-order;
assert(trace.WideSinglePrecision());
return to_long(trace);
}
static void RowTransform(vec_ZZ& A, vec_ZZ& B, const ZZ& MU1)
// x = x - y*MU
{
static ZZ T, MU;
long k;
long n = A.length();
long i;
MU = MU1;
if (MU == 1) {
for (i = 1; i <= n; i++)
sub(A(i), A(i), B(i));
return;
}
if (MU == -1) {
for (i = 1; i <= n; i++)
add(A(i), A(i), B(i));
return;
}
if (MU == 0) return;
if (NumTwos(MU) >= NTL_ZZ_NBITS)
k = MakeOdd(MU);
else
k = 0;
if (MU.WideSinglePrecision()) {
long mu1;
conv(mu1, MU);
for (i = 1; i <= n; i++) {
mul(T, B(i), mu1);
if (k > 0) LeftShift(T, T, k);
sub(A(i), A(i), T);
}
}
else {
for (i = 1; i <= n; i++) {
mul(T, B(i), MU);
if (k > 0) LeftShift(T, T, k);
sub(A(i), A(i), T);
}
}
}
static
void reduce(long k, long l,
mat_ZZ& B, vec_long& P, vec_ZZ& D,
vec_vec_ZZ& lam, mat_ZZ* U)
{
static ZZ t1;
static ZZ r;
if (P(l) == 0) return;
add(t1, lam(k)(P(l)), lam(k)(P(l)));
abs(t1, t1);
if (t1 <= D[P(l)]) return;
long j;
long rr, small_r;
BalDiv(r, lam(k)(P(l)), D[P(l)]);
if (r.WideSinglePrecision()) {
small_r = 1;
rr = to_long(r);
}
else {
small_r = 0;
}
if (small_r) {
MulSubFrom(B(k), B(l), rr);
if (U) MulSubFrom((*U)(k), (*U)(l), rr);
for (j = 1; j <= l-1; j++)
if (P(j) != 0)
MulSubFrom(lam(k)(P(j)), lam(l)(P(j)), rr);
MulSubFrom(lam(k)(P(l)), D[P(l)], rr);
}
else {
MulSubFrom(B(k), B(l), r);
if (U) MulSubFrom((*U)(k), (*U)(l), r);
for (j = 1; j <= l-1; j++)
if (P(j) != 0)
MulSubFrom(lam(k)(P(j)), lam(l)(P(j)), r);
MulSubFrom(lam(k)(P(l)), D[P(l)], r);
}
}
int main() {
C<char, int> c;
c.i; // unresolved
C<int, char> c2;
c2.j; // unresolved
C<bool, bool*> c3;
c3.k; // unresolved
ZZ<int *> t;
t.boo();
return 0;
}
static
void BuildMatrix(vec_ZZVec& M, long n, const ZZ_pX& g, const ZZ_pXModulus& F,
long verbose)
{
long i, j, m;
ZZ_pXMultiplier G;
ZZ_pX h;
ZZ t;
sqr(t, ZZ_p::modulus());
mul(t, t, n);
long size = t.size();
M.SetLength(n);
for (i = 0; i < n; i++)
M[i].SetSize(n, size);
build(G, g, F);
set(h);
for (j = 0; j < n; j++) {
if (verbose && j % 10 == 0) cerr << "+";
m = deg(h);
for (i = 0; i < n; i++) {
if (i <= m)
M[i][j] = rep(h.rep[i]);
else
clear(M[i][j]);
}
if (j < n-1)
MulMod(h, h, G, F);
}
for (i = 0; i < n; i++)
AddMod(M[i][i], M[i][i], -1, ZZ_p::modulus());
}
PAlgebraModDerived<type>::PAlgebraModDerived(const PAlgebra& _zMStar, long _r)
: zMStar(_zMStar), r(_r)
{
long p = zMStar.getP();
long m = zMStar.getM();
// For dry-run, use a tiny m value for the PAlgebra tables
if (isDryRun()) m = (p==3)? 4 : 3;
assert(r > 0);
ZZ BigPPowR = power_ZZ(p, r);
assert(BigPPowR.SinglePrecision());
pPowR = to_long(BigPPowR);
long nSlots = zMStar.getNSlots();
RBak bak; bak.save();
SetModulus(p);
// Compute the factors Ft of Phi_m(X) mod p, for all t \in T
RX phimxmod;
conv(phimxmod, zMStar.getPhimX()); // Phi_m(X) mod p
vec_RX localFactors;
EDF(localFactors, phimxmod, zMStar.getOrdP()); // equal-degree factorization
RX* first = &localFactors[0];
RX* last = first + localFactors.length();
RX* smallest = min_element(first, last);
swap(*first, *smallest);
// We make the lexicographically smallest factor have index 0.
// The remaining factors are ordered according to their representives.
RXModulus F1(localFactors[0]);
for (long i=1; i<nSlots; i++) {
unsigned long t =zMStar.ith_rep(i); // Ft is minimal polynomial of x^{1/t} mod F1
unsigned long tInv = InvMod(t, m); // tInv = t^{-1} mod m
RX X2tInv = PowerXMod(tInv,F1); // X2tInv = X^{1/t} mod F1
IrredPolyMod(localFactors[i], X2tInv, F1);
}
/* Debugging sanity-check #1: we should have Ft= GCD(F1(X^t),Phi_m(X))
for (i=1; i<nSlots; i++) {
unsigned long t = T[i];
RX X2t = PowerXMod(t,phimxmod); // X2t = X^t mod Phi_m(X)
RX Ft = GCD(CompMod(F1,X2t,phimxmod),phimxmod);
if (Ft != localFactors[i]) {
cout << "Ft != F1(X^t) mod Phi_m(X), t=" << t << endl;
exit(0);
}
}*******************************************************************/
if (r == 1) {
build(PhimXMod, phimxmod);
factors = localFactors;
pPowRContext.save();
// Compute the CRT coefficients for the Ft's
crtCoeffs.SetLength(nSlots);
for (long i=0; i<nSlots; i++) {
RX te = phimxmod / factors[i]; // \prod_{j\ne i} Fj
te %= factors[i]; // \prod_{j\ne i} Fj mod Fi
InvMod(crtCoeffs[i], te, factors[i]); // \prod_{j\ne i} Fj^{-1} mod Fi
}
}
else {
PAlgebraLift(zMStar.getPhimX(), localFactors, factors, crtCoeffs, r);
RX phimxmod1;
conv(phimxmod1, zMStar.getPhimX());
build(PhimXMod, phimxmod1);
pPowRContext.save();
}
// set factorsOverZZ
factorsOverZZ.resize(nSlots);
for (long i = 0; i < nSlots; i++)
conv(factorsOverZZ[i], factors[i]);
genCrtTable();
genMaskTable();
}
ZZ operator /(const ZZ& z) const { return (*this) * z.inverse(); }
void operator /=(const ZZ& z) { (*this) *= z.inverse(); }
