void CeilToZZ(ZZ& z, const RR& a)
{
if (a.e >= 0)
LeftShift(z, a.x, a.e);
else {
long sgn = sign(a.x);
RightShift(z, a.x, -a.e);
if (sgn > 0)
add(z, z, 1);
}
}
void conv(ZZ& z, const RR& a)
{
if (a.e >= 0)
LeftShift(z, a.x, a.e);
else {
long sgn = sign(a.x);
RightShift(z, a.x, -a.e);
if (sgn < 0)
sub(z, z, 1);
}
}
void add(RR& z, const RR& a, const RR& b)
{
NTL_TLS_LOCAL(RR, t);
if (IsZero(a.x)) {
xcopy(z, b);
return;
}
if (IsZero(b.x)) {
xcopy(z, a);
return;
}
if (a.e > b.e) {
if (a.e-b.e - max(RR::prec-NumBits(a.x),0) >= NumBits(b.x) + 2)
normalize(z, a, sign(b));
else {
LeftShift(t.x, a.x, a.e-b.e);
add(t.x, t.x, b.x);
t.e = b.e;
normalize(z, t);
}
}
else if (a.e < b.e) {
if (b.e-a.e - max(RR::prec-NumBits(b.x),0) >= NumBits(a.x) + 2)
normalize(z, b, sign(a));
else {
LeftShift(t.x, b.x, b.e-a.e);
add(t.x, t.x, a.x);
t.e = a.e;
normalize(z, t);
}
}
else {
add(t.x, a.x, b.x);
t.e = a.e;
normalize(z, t);
}
}
uint64_t physical_virtual(uint64_t physical_addr, analysisContext_t *context){
if (context->curMode == STOCK_VBOX_TYPE){ //TODO: function pointer
return FDP_physical_virtual(physical_addr, context);
}
uint64_t offset = physical_addr & 0xFFF;
uint64_t i;
for (i = 0; i<512; i++){
uint64_t PDPBA = readPhysical64(context->p_DirectoryTableBase + (i * 8), context) & 0x000FFFFFFFFFF000;
if (PDPBA>0 && PDPBA<context->physicalMemorySize - PAGE_SIZE){
uint64_t j;
for (j = 0; j<512; j++){
uint64_t PDBA = readPhysical64(PDPBA + (j * 8), context) & 0x000FFFFFFFFFF000;
if (PDBA && PDBA<context->physicalMemorySize - PAGE_SIZE){
uint64_t k;
for (k = 0; k<512; k++){
uint64_t PTBA = readPhysical64(PDBA + (k * 8), context) & 0x000FFFFFFFFFF000;
if (PTBA && PTBA<context->physicalMemorySize - PAGE_SIZE){
uint64_t l;
for (l = 0; l<512; l++){
uint64_t PPBA = readPhysical64(PTBA + (l * 8), context) & 0x000FFFFFFFFFF000;
if (PPBA && PPBA<context->physicalMemorySize - PAGE_SIZE){
if ((physical_addr & 0x000FFFFFFFFFF000) == (PPBA & 0x000FFFFFFFFFF000)){
uint64_t virtual_addr = (LeftShift(i, 39) | LeftShift(j, 30) | LeftShift(k, 21) | LeftShift(l, 12) | offset);
if (virtual_addr & 0x0000F00000000000){ //Canonical !
virtual_addr = virtual_addr | 0xFFFFF00000000000;
}
//printf("virtualAddr = 0x%p => physicalAddr = 0x%016lX\n", virtual_addr, (PPBA&0x000FFFFFFFFFF000)|offset);
return virtual_addr;
}
}
}
}
}
}
}
}
}
return 0;
}
void div(RR& z, const RR& a, const RR& b)
{
if (IsZero(b))
ArithmeticError("RR: division by zero");
if (IsZero(a)) {
clear(z);
return;
}
long la = NumBits(a.x);
long lb = NumBits(b.x);
long neg = (sign(a) != sign(b));
long k = RR::prec - la + lb + 1;
if (k < 0) k = 0;
NTL_TLS_LOCAL(RR, t);
NTL_ZZRegister(A);
NTL_ZZRegister(B);
NTL_ZZRegister(R);
abs(A, a.x);
LeftShift(A, A, k);
abs(B, b.x);
DivRem(t.x, R, A, B);
t.e = a.e - b.e - k;
normalize(z, t, !IsZero(R));
if (neg)
negate(z.x, z.x);
}
int main()
{
RR::SetPrecision(150);
long n, b, size;
cerr << "n: ";
cin >> n;
cerr << "b: ";
cin >> b;
cerr << "size: ";
cin >> size;
cerr << "prune: ";
long prune;
cin >> prune;
ZZ seed;
cerr << "seed: ";
cin >> seed;
if (seed != 0)
SetSeed(seed);
char alg;
cerr << "alg [fqQxr]: ";
cin >> alg;
double TotalTime = 0;
long TotalSucc = 0;
long iter;
for (iter = 1; iter <= 20; iter++) {
vec_ZZ a;
a.SetLength(n);
ZZ bound;
LeftShift(bound, to_ZZ(1), b);
long i;
for (i = 1; i <= n; i++) {
RandomBnd(a(i), bound);
a(i) += 1;
}
ZZ S;
do {
RandomLen(S, n+1);
} while (weight(S) != n/2+1);
ZZ s;
clear(s);
for (i = 1; i <= n; i++)
if (bit(S, i-1))
s += a(i);
mat_ZZ B(INIT_SIZE, n+1, n+3);
for (i = 1; i <= n; i++) {
B(i, i) = 2;
B(i, n+1) = a(i) * n;
B(i, n+3) = n;
}
for (i = 1; i <= n; i++)
B(n+1, i) = 1;
B(n+1, n+1) = s * n;
B(n+1, n+2) = 1;
B(n+1, n+3) = n;
B(n+1, n+3) *= n/2;
swap(B(1), B(n+1));
for (i = 2; i <= n; i++) {
long j = RandomBnd(n-i+2) + i;
swap(B(i), B(j));
}
double t;
LLLStatusInterval = 10;
t = GetTime();
switch (alg) {
case 'f':
BKZ_FP(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'q':
BKZ_QP(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'Q':
BKZ_QP1(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'x':
BKZ_XD(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'r':
BKZ_RR(B, 0.99, size, prune, SubsetSumSolution);
break;
default:
Error("invalid algorithm");
}
t = GetTime()-t;
long succ = 0;
for (i = 1; i <= n+1; i++)
if (SubsetSumSolution(B(i)))
succ = 1;
TotalTime += t;
TotalSucc += succ;
if (succ)
cerr << "+";
else
cerr << "-";
}
cerr << "\n";
cerr << "number of success: " << TotalSucc << "\n";
cerr << "average time: " << TotalTime/20 << "\n";
return 0;
}
static void RowTransform(vec_ZZ& A, vec_ZZ& B, const ZZ& MU1)
// x = x - y*MU
{
NTL_ZZRegister(T);
NTL_ZZRegister(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);
if (k > 0) {
for (i = 1; i <= n; i++) {
mul(T, B(i), mu1);
LeftShift(T, T, k);
sub(A(i), A(i), T);
}
}
else {
for (i = 1; i <= n; i++) {
MulSubFrom(A(i), B(i), mu1);
}
}
}
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);
}
}
}
void ZZ_p::DoInstall()
{
SmartPtr<ZZ_pTmpSpaceT> tmps = 0;
do { // NOTE: thread safe lazy init
Lazy<ZZ_pFFTInfoT>::Builder builder(ZZ_pInfo->FFTInfo);
if (!builder()) break;
UniquePtr<ZZ_pFFTInfoT> FFTInfo;
FFTInfo.make();
ZZ B, M, M1, M2, M3;
long n, i;
long q, t;
mulmod_t qinv;
sqr(B, ZZ_pInfo->p);
LeftShift(B, B, NTL_FFTMaxRoot+NTL_FFTFudge);
// FIXME: the following is quadratic time...would
// be nice to get a faster solution...
// One could estimate the # of primes by summing logs,
// then multiply using a tree-based multiply, then
// adjust up or down...
// Assuming IEEE floating point, the worst case estimate
// for error guarantees a correct answer +/- 1 for
// numprimes up to 2^25...for sure we won't be
// using that many primes...we can certainly put in
// a sanity check, though.
// If I want a more accuaruate summation (with using Kahan,
// which has some portability issues), I could represent
// numbers as x = a + f, where a is integer and f is the fractional
// part. Summing in this representation introduces an *absolute*
// error of 2 epsilon n, which is just as good as Kahan
// for this application.
// same strategy could also be used in the ZZX HomMul routine,
// if we ever want to make that subquadratic
set(M);
n = 0;
while (M <= B) {
UseFFTPrime(n);
q = GetFFTPrime(n);
n++;
mul(M, M, q);
}
FFTInfo->NumPrimes = n;
FFTInfo->MaxRoot = CalcMaxRoot(q);
double fn = double(n);
if (8.0*fn*(fn+48) > NTL_FDOUBLE_PRECISION)
ResourceError("modulus too big");
if (8.0*fn*(fn+48) <= NTL_FDOUBLE_PRECISION/double(NTL_SP_BOUND))
FFTInfo->QuickCRT = true;
else
FFTInfo->QuickCRT = false;
// FIXME: some of this stuff does not need to be initialized
// at all if FFTInfo->crt_struct.special()
FFTInfo->x.SetLength(n);
FFTInfo->u.SetLength(n);
FFTInfo->uqinv.SetLength(n);
FFTInfo->rem_struct.init(n, ZZ_pInfo->p, GetFFTPrime);
FFTInfo->crt_struct.init(n, ZZ_pInfo->p, GetFFTPrime);
if (!FFTInfo->crt_struct.special()) {
ZZ qq, rr;
DivRem(qq, rr, M, ZZ_pInfo->p);
NegateMod(FFTInfo->MinusMModP, rr, ZZ_pInfo->p);
for (i = 0; i < n; i++) {
q = GetFFTPrime(i);
qinv = GetFFTPrimeInv(i);
long tt = rem(qq, q);
mul(M2, ZZ_pInfo->p, tt);
add(M2, M2, rr);
div(M2, M2, q); // = (M/q) rem p
div(M1, M, q);
t = rem(M1, q);
t = InvMod(t, q);
mul(M3, M2, t);
rem(M3, M3, ZZ_pInfo->p);
FFTInfo->crt_struct.insert(i, M3);
FFTInfo->x[i] = ((double) t)/((double) q);
FFTInfo->u[i] = t;
FFTInfo->uqinv[i] = PrepMulModPrecon(FFTInfo->u[i], q, qinv);
}
}
tmps = MakeSmart<ZZ_pTmpSpaceT>();
tmps->crt_tmp_vec.fetch(FFTInfo->crt_struct);
tmps->rem_tmp_vec.fetch(FFTInfo->rem_struct);
builder.move(FFTInfo);
} while (0);
if (!tmps) {
const ZZ_pFFTInfoT *FFTInfo = ZZ_pInfo->FFTInfo.get();
tmps = MakeSmart<ZZ_pTmpSpaceT>();
tmps->crt_tmp_vec.fetch(FFTInfo->crt_struct);
tmps->rem_tmp_vec.fetch(FFTInfo->rem_struct);
}
ZZ_pTmpSpace = tmps;
}
static CYTHON_INLINE struct ZZX* ZZX_left_shift(struct ZZX* x, long n)
{
struct ZZX* y = new ZZX();
LeftShift(*y, *x, n);
return y;
}
newNTL_START_IMPL
zz_pInfoT::zz_pInfoT(long NewP, long maxroot)
{
ref_count = 1;
if (maxroot < 0) Error("zz_pContext: maxroot may not be negative");
if (NewP <= 1) Error("zz_pContext: p must be > 1");
if (NumBits(NewP) > newNTL_SP_NBITS) Error("zz_pContext: modulus too big");
ZZ P, B, M, M1, MinusM;
long n, i;
long q, t;
p = NewP;
pinv = 1/double(p);
index = -1;
conv(P, p);
sqr(B, P);
LeftShift(B, B, maxroot+newNTL_FFTFudge);
set(M);
n = 0;
while (M <= B) {
UseFFTPrime(n);
q = FFTPrime[n];
n++;
mul(M, M, q);
}
if (n > 4) Error("zz_pInit: too many primes");
NumPrimes = n;
PrimeCnt = n;
MaxRoot = CalcMaxRoot(q);
if (maxroot < MaxRoot)
MaxRoot = maxroot;
negate(MinusM, M);
MinusMModP = rem(MinusM, p);
if (!(CoeffModP = (long *) newNTL_MALLOC(n, sizeof(long), 0)))
Error("out of space");
if (!(x = (double *) newNTL_MALLOC(n, sizeof(double), 0)))
Error("out of space");
if (!(u = (long *) newNTL_MALLOC(n, sizeof(long), 0)))
Error("out of space");
for (i = 0; i < n; i++) {
q = FFTPrime[i];
div(M1, M, q);
t = rem(M1, q);
t = InvMod(t, q);
mul(M1, M1, t);
CoeffModP[i] = rem(M1, p);
x[i] = ((double) t)/((double) q);
u[i] = t;
}
}
void ZZ_pInfoT::init()
{
ZZ B, M, M1, M2, M3;
long n, i;
long q, t;
initialized = 1;
sqr(B, p);
LeftShift(B, B, NTL_FFTMaxRoot+NTL_FFTFudge);
set(M);
n = 0;
while (M <= B) {
UseFFTPrime(n);
q = FFTPrime[n];
n++;
mul(M, M, q);
}
NumPrimes = n;
MaxRoot = CalcMaxRoot(q);
double fn = double(n);
if (8.0*fn*(fn+32) > NTL_FDOUBLE_PRECISION)
Error("modulus too big");
if (8.0*fn*(fn+32) > NTL_FDOUBLE_PRECISION/double(NTL_SP_BOUND))
QuickCRT = 0;
else
QuickCRT = 1;
if (!(x = (double *) NTL_MALLOC(n, sizeof(double), 0)))
Error("out of space");
if (!(u = (long *) NTL_MALLOC(n, sizeof(long), 0)))
Error("out of space");
ZZ_p_rem_struct_init(&rem_struct, n, p, FFTPrime);
ZZ_p_crt_struct_init(&crt_struct, n, p, FFTPrime);
if (ZZ_p_crt_struct_special(crt_struct)) return;
ZZ qq, rr;
DivRem(qq, rr, M, p);
NegateMod(MinusMModP, rr, p);
for (i = 0; i < n; i++) {
q = FFTPrime[i];
long tt = rem(qq, q);
mul(M2, p, tt);
add(M2, M2, rr);
div(M2, M2, q); // = (M/q) rem p
div(M1, M, q);
t = rem(M1, q);
t = InvMod(t, q);
mul(M3, M2, t);
rem(M3, M3, p);
ZZ_p_crt_struct_insert(crt_struct, i, M3);
x[i] = ((double) t)/((double) q);
u[i] = t;
}
}
}
template <T1 t1, T2 t2, T1 result = LeftShift( t1, t2 )>
static constexpr bool isDefinedHelper(int)
{
return true ;
}
template <T1 t1, T2 t2>
static constexpr bool isDefinedHelper(...)
{
return false ;
}
};
template <unsigned int e1, int shift, unsigned int result = LeftShift(e1, shift)>
constexpr bool uLeftShiftDefinedHelper(int)
{
return true ;
}
template <unsigned int e1, int shift>
constexpr bool uLeftShiftDefinedHelper(...)
{
return false;
}
template <unsigned int e1, int shift>
constexpr bool uLeftShiftDefined()
{
NTL_START_IMPL
void CharPoly(ZZ_pX& f, const mat_ZZ_p& M)
{
long n = M.NumRows();
if (M.NumCols() != n)
Error("CharPoly: nonsquare matrix");
if (n == 0) {
set(f);
return;
}
ZZ_p t;
if (n == 1) {
SetX(f);
negate(t, M(1, 1));
SetCoeff(f, 0, t);
return;
}
mat_ZZ_p H;
H = M;
long i, j, m;
ZZ_p u, t1;
for (m = 2; m <= n-1; m++) {
i = m;
while (i <= n && IsZero(H(i, m-1)))
i++;
if (i <= n) {
t = H(i, m-1);
if (i > m) {
swap(H(i), H(m));
// swap columns i and m
for (j = 1; j <= n; j++)
swap(H(j, i), H(j, m));
}
for (i = m+1; i <= n; i++) {
div(u, H(i, m-1), t);
for (j = m; j <= n; j++) {
mul(t1, u, H(m, j));
sub(H(i, j), H(i, j), t1);
}
for (j = 1; j <= n; j++) {
mul(t1, u, H(j, i));
add(H(j, m), H(j, m), t1);
}
}
}
}
vec_ZZ_pX F;
F.SetLength(n+1);
ZZ_pX T;
T.SetMaxLength(n);
set(F[0]);
for (m = 1; m <= n; m++) {
LeftShift(F[m], F[m-1], 1);
mul(T, F[m-1], H(m, m));
sub(F[m], F[m], T);
set(t);
for (i = 1; i <= m-1; i++) {
mul(t, t, H(m-i+1, m-i));
mul(t1, t, H(m-i, m));
mul(T, F[m-i-1], t1);
sub(F[m], F[m], T);
}
}
f = F[n];
}
