Numbers ready for post-processing and free of reservation that I know: 691_73_minus1, 769_79_minus1.

Edit: I don't know if enough relations are ready to build a matrix for 827_83_minus1 but I suspect not. Anyway, all files are on the server.

[QUOTE=fivemack;300271]OK, collecting and running 2063,71- now[/QUOTE]

done; see gratuitous-factors thread

I think I'll do 2887^59-1 for kicks.

[COLOR=White]2887_59_minus1[/COLOR]

[QUOTE=Dubslow;301122]I think I'll do 2887^59-1 for kicks.
[/QUOTE]
[code]
PRP96 = 667142060462628651089823581931907744018028818409348980545584577585619416499900156281355988538713
PRP105 = 761808124988007465961759656409404692507269535875900478337560639070042291211807519491881740150449764948929[/code]
Posted to FDB.

PS You can remove the C158 as well, the matrix is built and being solved :smile:

[code]matrix includes 64 packed rows
matrix is 5629817 x 5630045 (1654.0 MB) with weight 427146264 (75.87/col)
sparse part has weight 377297341 (67.01/col)
using block size 65536 for processor cache size 8192 kB
dump interval = 2000
commencing Lanczos iteration (4 threads)
memory use: 1454.9 MB
linear algebra at 0.0%, ETA 27h49m630045 dimensions (0.0%, ETA 27h49m)
checkpointing every 210000 dimensions045 dimensions (0.0%, ETA 27h50m)
linear algebra completed 28599 of 5630045 dimensions (0.5%, ETA 27h44m)[/code]

[QUOTE=debrouxl;296104]
Yeah, the verbose mode I contributed to remdups4 yesterday will prove educational for me :smile:[/QUOTE]
[OT] Would you be willing to post that here (and/or in the subversion)? [/OT]

I can post the modified remdups4 here or elsewhere, but I (rightfully - many people can be considered to deserve it more than I do !) do not have access to the GGNFS SVN :smile:

The modified remdups4 currently reads as follows:
[code]/* remdups4.c
By Greg Childers
This is a standalone one-pass duplicate relations remover;
only syntax (a,b:<csv-of-factors>:<csv-of-factors>) is checked and incomplete lines are discarded;
validity of relations is not tested (nor is polynomial needed).
Hashing of (a,b) values was changed to accomodate for gnfs projects with huge skews (S.Batalov).
Verbose mode was added (Lionel Debroux)

This version is a filter (stdin, stdout):
you may redirect stdout to /dev/null and/or
you may use many input relation files (or pipe from zcat, bzcat).
However, this needs porting for Windows (use remdups.c instead or get CygWin).

No makefile needed:
cc -O3 -o remdups4 remdups4.c

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

You should have received a copy of the GNU General Public License along
with this program; see the file COPYING. If not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
*/

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef unsigned long uint32;
typedef long int32;
typedef unsigned long long uint64;

#define MDVAL (327673)
#define REPORT_EVERY_N_UNIQUE_RELS (500000)

static int strccnt(const char *s, int c)
{
const unsigned char *us = (const unsigned char *) s;
const unsigned char uc = c;
int n = 0;
if (!uc) return 1;
while (*us) if (*us++ == uc) n++;
return n;
}
int main(int argc, char **argv) {
char buf[512];
int mm,nn,av;
FILE *badfile;
uint64 ** arra;
int n[MDVAL]={0};
unsigned int numbad=0, numdups=0, numuniq=0, numskip=0, prevnumdups=0;
int DIM=1000;
time_t curtime;
long allocated=0;
int verbose = 0;

if (argc >= 2) {
if (!strcmp("-h", argv[1]) || !strcmp("--help", argv[1]))
goto usage;

DIM=atoi(argv[1]);
if (argc >= 3) {
if (!strcmp("-v", argv[2]) || !strcmp("--verbose", argv[2]))
verbose = 1;
}
} else {
usage:
fprintf(stderr,"\nusage: cat relations.file(s) | %s DIM [-v/--verbose] > out_file \n"
"\t DIM is a number (5 per million relations recommended)\n\n", argv[0]);
exit(-1);
}

badfile = fopen("badrels.txt", "a");
if (badfile == NULL) {
fprintf(stderr,"cannot open badfile\n");
exit(-1);
}
if (DIM<20) DIM=20;
#if 0
if (DIM>100000) {
printf("DIM should be between 20 and 100000!\n");
exit(1);
}
#endif
if (verbose) {
curtime = time(NULL);
fprintf(stderr, "Starting program at %s", ctime(&curtime));
}

/* initialize arrays */
arra = (uint64**)malloc(MDVAL * sizeof(uint64 *));
if(!arra) {
fprintf(stderr, "out of memory\n");
exit(1);
}
if (verbose) {
fprintf(stderr, "allocated %ld bytes for pointers\n", MDVAL * sizeof(uint64 *));
}
for(mm = 0; mm < MDVAL; mm++) {
#define CHUNK 2048
if((mm % CHUNK) == 0) {
arra[mm] = (uint64*)malloc(CHUNK * DIM * sizeof(uint64));
if(!arra[mm]) {
fprintf(stderr, "out of memory\n");
exit(1);
}
allocated += CHUNK * DIM * sizeof(uint64);
/* memset(arra[mm],0,CHUNK * DIM * sizeof(uint64)); */ /* unnecessary */
} else {
arra[mm] = arra[mm-1] + DIM;
}
}
if (verbose) {
fprintf(stderr, "allocated %ld bytes for arrays\n", allocated);
}

while (fgets(buf, sizeof(buf), stdin)) {
char *tmp;
uint64 a;
int32 i, p, cpos;

if (buf[0] == '#') {
printf("%s", buf);
continue;
}

if (buf[0] == 'N') {
printf("%s", buf);
continue;
}

for(tmp = buf; *tmp && isspace(*tmp); tmp++);

/* Hash used to be in a and b bins; it worked well for SNFS */
/* However, for gnfs, the bins were very shallow */
/* New hash value a is a hybrid of both a and b -SB 2009 */
cpos = 0;
if(*tmp=='-') {a=10; tmp++;} else a=0;
for( ; *tmp ; tmp++) {
if (isdigit(*tmp)) a=10*a+(*tmp-'0');
else if(*tmp==',' && !cpos) cpos = tmp-buf; /* must be only one comma between a,b */
else {
if(*tmp==':') {
if ((tmp-2>buf && tmp[-2]==',' && tmp[-1]=='0') || strccnt(tmp+1,':')==1)
break;
}
fprintf(badfile, "%s", buf);
numbad++;
goto skip_;
}
}
a=4*a+(cpos&3); /* the "comma position" */
p=a%MDVAL;
for (i=0;i<n[p];i++)
if (a==arra[p][i]) { numdups++; goto skip_; }
if (n[p]<DIM) arra[p][n[p]++]=a; /* Not quitting after a whole lot of work! Just stop extending the bin --SB. */
else numskip++;
numuniq++;
if(numuniq % REPORT_EVERY_N_UNIQUE_RELS == 0) {
if (!verbose) {
fprintf(stderr,"\r %.1fM relns \r", numuniq/1000000.0);
} else {
char buf2[32];
curtime = time(NULL);

strcpy(buf2, ctime(&curtime));
*(strchr(buf2, '\n')) = 0;
fprintf(stderr, "%s %.1fM unique relns %.2fM duplicate relns (+%.2fM, avg D/U ratio in block was %.1f%%)\n",
buf2,
numuniq/1000000.0,
numdups/1000000.0,
(numdups - prevnumdups)/1000000.0,
100.0*(numdups - prevnumdups)/(REPORT_EVERY_N_UNIQUE_RELS + numdups - prevnumdups));
prevnumdups = numdups;
}
}
for(tmp=buf;*tmp;tmp++) *tmp=tolower(*tmp); /* will compress better */
printf("%s", buf);
skip_: ;
}

if (!verbose) {
fprintf(stderr,"Found %d unique, %d duplicate, and %d bad relations.\n",numuniq, numdups, numbad);
} else {
fprintf(stderr,"Found %u unique, %u duplicate (%.1f%% of total), and %u bad relations.\n", numuniq, numdups, 100.0*numdups/(numuniq+numdups), numbad);
}
for (av=0,mm=1,nn=n[0];mm<MDVAL;mm++) {if (n[mm]>nn) nn=n[mm]; av+=n[mm];}
fprintf(stderr,"Largest dimension used: %d of %d\n",nn,DIM);
fprintf(stderr,"Average dimension used: %.1f of %d\n",((double)av)/MDVAL,DIM);
if(nn>=DIM) fprintf(stderr,"*** Some redundant relations may have been retained (increase DIM)\n");
if(numskip) fprintf(stderr,"*** %u (quasi-unique) relations were not hashed\n",numskip);
if(numbad) fprintf(badfile, "\n"); /* usually last reln line is truncated and ends up in the bad bin. We don't want them to stick together */
fclose(badfile);
if (verbose) {
curtime = time(NULL);
fprintf(stderr, "Terminating program at %s", ctime(&curtime));
}
return 0;
}
[/code]

This is slightly newer than what I sent to frmky and Batalov: the REPORT_EVERY_N_UNIQUE_RELS define appeared, and "(REPORT_EVERY_N_UNIQUE_RELS + numdups - prevnumdups)" used to be just "500000", computing wrong ratios.

There's a version of remdups which supports a Bloom filter (down the comments of [url]http://www.mersenneforum.org/showthread.php?t=13498[/url] ). It's a different memory consumption / CPU consumption tradeoff: it requires less memory but it's slower. I had forgotten about that version, although I had the diff somewhere, and I did not perform my verbose mode changes against that version.

If extra information is printed under verbose option and the old mode is still intact, then I'll merge it, no problem. (Just was busy.) EDIT: DONE

Sometimes one just wants to simply remdups with minimal output (because we've done hundreds of times, not much excitement to watch three pages of text ;)

I'll merge it. If you want access to SVN, it is under asl__'s control - you can PM him from within SourceForge. That's how I got access.

[quote]If extra information is printed under verbose option and the old mode is still intact[/quote]
Yup, leaving the old mode intact was a goal of mine, because:

[quote]Sometimes one just wants to simply remdups with minimal output (because we've done hundreds of times, not much excitement to watch three pages of text ;)[/quote]
Exactly :grin:
The verbose mode is useless to experts like you, but can be interesting to newcomers, or incompetents like me :smile:

[quote]I'll merge it. If you want access to SVN, it is under asl__'s control - you can PM him from within SourceForge. That's how I got access.[/quote]
OK, thanks for the information.
I'd say that a patch or two (which need peer review, anyway) in nearly three years does not warrant bothering the project admin for obtaining write access to the repository :smile:

Thanks guys. I have my own plans for remdups4, if I ever get CUDALucas debugged :yucky:

[COLOR=White]769_79_minus1[/COLOR]
M. Debroux, if you don't mind, I think I'd like to attempt a 30-bit LA job, 769^79-1. (The C158 finishes in four hours.)

[QUOTE=Dubslow;301168]PS You can remove the C158 as well, the matrix is built and being solved :smile:

[code]matrix includes 64 packed rows
matrix is 5629817 x 5630045 (1654.0 MB) with weight 427146264 (75.87/col)
sparse part has weight 377297341 (67.01/col)
using block size 65536 for processor cache size 8192 kB
dump interval = 2000
commencing Lanczos iteration (4 threads)
memory use: 1454.9 MB
linear algebra at 0.0%, ETA 27h49m630045 dimensions (0.0%, ETA 27h49m)
checkpointing every 210000 dimensions045 dimensions (0.0%, ETA 27h50m)
linear algebra completed 28599 of 5630045 dimensions (0.5%, ETA 27h44m)[/code][/QUOTE]
[code]matrix includes 64 packed rows
matrix is 5629817 x 5630045 (1654.0 MB) with weight 427146264 (75.87/col)
sparse part has weight 377297341 (67.01/col)
using block size 65536 for processor cache size 8192 kB
dump interval = 2000
commencing Lanczos iteration (4 threads)
memory use: 1454.9 MB
linear algebra at 0.0%, ETA 27h49m630045 dimensions (0.0%, ETA 27h49m)
checkpointing every 210000 dimensions045 dimensions (0.0%, ETA 27h50m)
linear algebra completed 5629816 of 5630045 dimensions (100.0%, ETA 0h 0m)
lanczos halted after 89037 iterations (dim = 5629816)
recovered 31 nontrivial dependencies
BLanczosTime: 99736
nfs: commencing msieve sqrt

commencing square root phase
reading relations for dependency 1
read 2814136 cycles
cycles contain 8563680 unique relations
read 8563680 relations
multiplying 8563680 relations
multiply complete, coefficients have about 444.28 million bits
initial square root is modulo 93714893
sqrtTime: 1287
NFS elapsed time = 102210.7807 seconds.


***factors found***

PRP68 = 12456452060561357788164860648297809606496173256616947478519007670123
PRP91 = 2767492705863193857090316620323534508832065620088404233967230679284730067336054045727447687

ans = 1

bill@Gravemind:~/yafu∰∂ [/code]
Very first dependency :smile: