void LargeVis::load_from_data(real *data, long long n_vert, long long n_di)
{
clean_data();
vec = data;
n_vertices = n_vert;
n_dim = n_di;
printf("Total vertices : %lld\tDimension : %lld\n", n_vertices, n_dim);
}
void LargeVis::load_from_graph(char *infile)
{
clean_data();
char *w1 = new char[1000];
char *w2 = new char[10000];
long long x, y, i, p;
real weight;
std::map<std::string, long long> dict;
n_vertices = 0;
FILE *fin = fopen(infile, "rb");
if (fin == NULL)
{
printf("\nFile not found!\n");
return;
}
printf("Reading input file %s ......%c", infile, 13);
while (fscanf(fin, "%s%s%f", w1, w2, &weight) == 3)
{
if (!dict.count(w1)) { dict[w1] = n_vertices++; names.push_back(w1); }
if (!dict.count(w2)) { dict[w2] = n_vertices++; names.push_back(w2); }
x = dict[w1];
y = dict[w2];
edge_from.push_back(x);
edge_to.push_back(y);
edge_weight.push_back(weight);
next.push_back(-1);
++n_edge;
if (n_edge % 5000 == 0)
{
printf("Reading input file %s ...... %lldK edges%c", infile, n_edge / 1000, 13);
fflush(stdout);
}
}
fclose(fin);
delete[] w1;
delete[] w2;
head = new long long[n_vertices];
for (i = 0; i < n_vertices; ++i) head[i] = -1;
for (p = 0; p < n_edge; ++p)
{
x = edge_from[p];
next[p] = head[x];
head[x] = p;
}
printf("\nTotal vertices : %lld\tTotal edges : %lld\n", n_vertices, n_edge);
}
void LargeVis::load_from_file(char *infile)
{
clean_data();
FILE *fin = fopen(infile, "rb");
if (fin == NULL)
{
printf("\nFile not found!\n");
return;
}
printf("Reading input file %s ......", infile); fflush(stdout);
fscanf(fin, "%lld%lld", &n_vertices, &n_dim);
vec = new real[n_vertices * n_dim];
for (long long i = 0; i < n_vertices; ++i)
{
for (long long j = 0; j < n_dim; ++j)
{
fscanf(fin, "%f", &vec[i * n_dim + j]);
}
}
fclose(fin);
printf(" Done.\n");
printf("Total vertices : %lld\tDimension : %lld\n", n_vertices, n_dim);
}
int main()
{
_newntl_gmp_hack = 0;
long n, k;
n = 200;
k = 10*newNTL_ZZ_NBITS;
ZZ p;
RandomLen(p, k);
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i;
long iter;
n = 1024;
k = 1024;
RandomLen(p, k);
ZZ_p::init(p);
ZZ_pX j1, j2, j3;
random(j1, n);
random(j2, n);
mul(j3, j1, j2);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
FFTMul(j3, j1, j2);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((2/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
FFTMul(j3, j1, j2);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e12);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int main()
{
#ifdef NTL_LONG_LONG
if (sizeof(NTL_LL_TYPE) < 2*sizeof(long)) {
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
SetSeed(ZZ(0));
long i, k;
k = 10*NTL_ZZ_NBITS;
for (i = 0; i < 10000; i++) {
ZZ a, b, c, d;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k);
long dd = RandomBnd(k);
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc); RandomLen(d, dd);
if ((a + b)*(c + d) != c*a + d*a + c*b + d*b) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
for (i = 0; i < 10000; i++) {
ZZ a, b, c;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k) + 2;
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc);
if ( ( a * b ) % c != ((a % c) * (b % c)) % c ) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
k = 1024;
ZZ x1, x2, x3;
double t;
long j;
RandomLen(x1, k);
RandomLen(x2, k);
long iter;
mul(x3, x1, x2);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((3/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e14);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
char* retrieve_obj(char* name = NULL) {
clean_data();
char *cnp = (char*)(void*)(*_odm_get_obj)(odm_class(), name, NULL, (name == NULL) ? ODM_NEXT : ODM_FIRST);
if (cnp != (char*)-1) { _data = cnp; }
return data();
}
~odmWrapper() {
if (_initialized) { (*_odm_terminate)(); clean_data(); }
}
int main()
{
long n, i, j, iter, s, k;
double t;
for (i = 0; i < 10000; i++) {
GF2X a, b, c, d;
long da = RandomBnd(5*NTL_BITS_PER_LONG);
long db = RandomBnd(5*NTL_BITS_PER_LONG);
long dc = RandomBnd(5*NTL_BITS_PER_LONG);
long dd = RandomBnd(5*NTL_BITS_PER_LONG);
random(a, da); random(b, db); random(c, dc); random(d, dd);
if ((a + b)*(c + d) != c*a + d*a + c*b + d*b) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
n = 16;
s = 56;
GF2X *a = new GF2X[s];
GF2X *b = new GF2X[s];
GF2X c;
for (k = 0; k < s; k++) {
random(a[k], (n + (k % 7))*NTL_BITS_PER_LONG);
random(b[k], (n + (k % 8))*NTL_BITS_PER_LONG);
}
for (k = 0; k < s; k++) mul(c, a[k], b[k]);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 1; j++) for (k = 0; k < s; k++) mul(c, a[k], b[k]);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((2/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 1; j++) for (k = 0; k < s; k++) mul(c, a[k], b[k]);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e14);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int main()
{
#ifdef NTL_SPMM_ULL
if (sizeof(NTL_ULL_TYPE) < 2*sizeof(long)) {
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
long n, k;
n = 200;
k = 10*NTL_ZZ_NBITS;
ZZ p;
RandomLen(p, k);
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i, j;
long iter;
const int nprimes = 30;
const long L = 12;
const long N = 1L << L;
long r;
for (r = 0; r < nprimes; r++) UseFFTPrime(r);
vec_long aa[nprimes], AA[nprimes];
for (r = 0; r < nprimes; r++) {
aa[r].SetLength(N);
AA[r].SetLength(N);
for (i = 0; i < N; i++)
aa[r][i] = RandomBnd(GetFFTPrime(r));
FFTFwd(AA[r].elts(), aa[r].elts(), L, r);
FFTRev1(AA[r].elts(), AA[r].elts(), L, r);
}
iter = 1;
do {
t = GetTime();
for (j = 0; j < iter; j++) {
for (r = 0; r < nprimes; r++) {
long *AAp = AA[r].elts();
long *aap = aa[r].elts();
long q = GetFFTPrime(r);
mulmod_t qinv = GetFFTPrimeInv(r);
FFTFwd(AAp, aap, L, r);
FFTRev1(AAp, aap, L, r);
for (i = 0; i < N; i++) AAp[i] = NormalizedMulMod(AAp[i], aap[i], q, qinv);
}
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((1.5/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (j = 0; j < iter; j++) {
for (r = 0; r < nprimes; r++) {
long *AAp = AA[r].elts();
long *aap = aa[r].elts();
long q = GetFFTPrime(r);
mulmod_t qinv = GetFFTPrimeInv(r);
FFTFwd(AAp, aap, L, r);
FFTRev1(AAp, aap, L, r);
for (i = 0; i < N; i++) AAp[i] = NormalizedMulMod(AAp[i], aap[i], q, qinv);
}
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e13);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int main()
{
#if (defined(NTL_CRT_ALTCODE) && !(defined(NTL_HAVE_LL_TYPE) && NTL_ZZ_NBITS == NTL_BITS_PER_LONG))
{
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
SetSeed(ZZ(0));
long n, k;
n = 1024;
k = 30*NTL_SP_NBITS;
ZZ p;
RandomLen(p, k);
if (!IsOdd(p)) p++;
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i;
long iter;
ZZ_pX a, b, c;
random(a, n);
random(b, n);
long da = deg(a);
long db = deg(b);
long dc = da + db;
long l = NextPowerOfTwo(dc+1);
FFTRep arep, brep, crep;
ToFFTRep(arep, a, l, 0, da);
ToFFTRep(brep, b, l, 0, db);
mul(crep, arep, brep);
ZZ_pXModRep modrep;
FromFFTRep(modrep, crep);
FromZZ_pXModRep(c, modrep, 0, dc);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
FromZZ_pXModRep(c, modrep, 0, dc);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((3/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
FromZZ_pXModRep(c, modrep, 0, dc);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e12);
// The following is just to test some tuning Wizard logic --
// be sure to get rid of this!!
#if (defined(NTL_CRT_ALTCODE))
// t *= 1.12;
#endif
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
