I'll do another 3000 or so at 43M as well, this weekend.

I finished 68 at the 43 million mark and I finished 22 at the 110 million mark because I miscounted the zeros. I guess that is why there is the 11e6 method instead of needing to type 11000000. No factors.

The default B2=13494038602573560 for P-1 B1=1e10 uses 16GB of memory with default parameters (k=2). With 8GB of memory, the default B2 is 9924641473652116 (just about 1e16, memory estimate 8064MB) with k=6. With only 1GB, you get k=360 which is very inefficient. If you have a 32 bit machine, you might also get a problem finding enough NTT primes.

I think the runs with B1=1e9 I did are probably sufficient, but I'll try P-1 with B1=1e10 anyway, merely because it fits in 8GB so neatly... (Hey, we could start a "Worst reasons for factoring" list!) I won't do more P+1, though, I think it's not worthwhile.

Alex

I have queued 500 curves at B1=43e6 to run over the weekend on the office PC, and I will do a few curves (maybe some 200 to 300) at 110e6 at home on my laptop.

Ok, thanks for the info and the extra P-1 run, Alex. Is there any particular reason why it seems that B1 for P-1 is always 1ex (1e9, 1e10, etc.) while B1s for ECM are all different? (e.g. 5e4, 25e4, 43e6)

[B]10metreh:[/B] Basically it's because the ECM limits correspond to a specific factor size (eg 25e4 is 30 digits), but the P-1 limits don't, so the obvious powers of 10 are used.

No particular reason other than that people consider powers of ten "round" numbers.

For ECM, the set of standard B1 values is derived from an analysis which B1 produces the smallest expected time for finding a factor of a certain size, and early papers on ECM gave figures like B1=11000 for 20-digit factors, B1=50000 for 25 digits, etc. These values stuck and everyone keeps using them, mostly for the sake of easy bookkeeping. (Montgomery's thesis for example suggests slightly higher values.)

Alex

[quote=akruppa;178919]No particular reason other than that people consider powers of ten "round" numbers.

For ECM, the set of standard B1 values is derived from an analysis which B1 produces the smallest expected time for finding a factor of a certain size, and early papers on ECM gave figures like B1=11000 for 20-digit factors, B1=50000 for 25 digits, etc. These values stuck and everyone keeps using them, mostly for the sake of easy bookkeeping. (Montgomery's thesis for example suggests slightly higher values.)

Alex[/quote]
i did some experiments with gmp-ecm 6.2.2 a short while ago and the bounds we use are too low
for example t35 at B1=3M is faster than B1=1M (i didn't optimise that one)
i optimised t25 and t30


i noticed that B2scale of 0.5 was usually better(it was unless it meant a high k value)
[code]
Size B1 est-time curves needed B2scale
t25 5e4 1.84m 214 1
t25 7e4 1.71m 178 0.5
t30 25e4 17.56m 430 1
t30 40e4 16.89m 311 0.5
[/code]this is the normal and the best i found
in addition to being slightly faster there is a greater chance of finding higher factors with higher bounds

i havent tested much but the results were better for 64-bit linux(using GMP 4.2.4 i think) as well
the tests were done on 32-bit windows using a binary compiled with MPIR 1.0

i will post some results files in the morning
t35 needs more than 5 curves to be run at each level to get a reasonable minimum time and i dont have time to parse that much data manually

@Alex: What is the formula to calculate how many curves are needed for a certain set of B1, B2, size of factor to find?

[quote=Andi47;178974]@Alex: What is the formula to calculate how many curves are needed for a certain set of B1, B2, size of factor to find?[/quote]
Use the -v (verbose) option on GMP-ECM and it prints out those stats (among other things). First it prints the expected # of curves for factor sizes, then it runs the ECM curve, then it prints the expected time for the factor sizes. I recommend doing just one curve with -v on, because it's so verbose that a large number of curves would needlessly produce a humongous output.

[QUOTE=Mini-Geek;178992]Use the -v (verbose) option on GMP-ECM and it prints out those stats (among other things). First it prints the expected # of curves for factor sizes, then it runs the ECM curve, then it prints the expected time for the factor sizes. I recommend doing just one curve with -v on, because it's so verbose that a large number of curves would needlessly produce a humongous output.[/QUOTE]

I know about -v. What I want to know is the formula which -v uses.

[quote=Andi47;178995]I know about -v. What I want to know is the formula which -v uses.[/quote]
Oh. Does this help?
[code]static void
print_expcurves (mpz_t B2min, mpz_t effB2, unsigned long dF, unsigned long k,
int S, int clear)
{
double prob;
int i;
char sep;

if (!test_verbose (OUTPUT_VERBOSE))
return;

rhoinit (256, 10);
outputf (OUTPUT_VERBOSE, "Expected number of curves to find a factor "
"of n digits:\n20\t25\t30\t35\t40\t45\t50\t55\t60\t65\n");
for (i = 20; i <= 65; i += 5)
{
sep = (i < 65) ? '\t' : '\n';
prob = ecmprob (mpz_get_d (B2min), mpz_get_d (effB2),
pow (10., i - .5), (double) dF * dF * k, S);
if (prob > 1. / 10000000)
outputf (OUTPUT_VERBOSE, "%.0f%c", floor (1. / prob + .5), sep);
else if (prob > 0.)
outputf (OUTPUT_VERBOSE, "%.2g%c", floor (1. / prob + .5), sep);
else
outputf (OUTPUT_VERBOSE, "Inf%c", sep);
}

if (clear)
rhoinit (1, 0); /* Free memory of rhotable */
}
[/code]Edit: here's the code for the ecmprob that's called in the last one there.
[code]double
ecmprob (double B1, double B2, double N, double nr, int S)
{
double alpha, beta, stage1, stage2, brsu;

ASSERT(rhotable != NULL);

/* What to do if rhotable is not initialised and asserting is not enabled?
For now, bail out with 0. result. Not really pretty, either */
if (rhotable == NULL)
return 0.;

if (B1 < 2. || N <= 1.)
return 0.;

if (N / ECM_EXTRA_SMOOTHNESS <= B1)
return 1.;

#ifdef TESTDRIVE
printf ("B1 = %f, B2 = %f, N = %.0f, nr = %f, S = %d\n", B1, B2, N, nr, S);
#endif

alpha = log (N / ECM_EXTRA_SMOOTHNESS) / log (B1);
stage1 = dickmanlocal (alpha, N / ECM_EXTRA_SMOOTHNESS);
stage2 = 0.;
if (B2 > B1)
{
beta = log (B2) / log (B1);
stage2 = dickmanmu (alpha, beta, N / ECM_EXTRA_SMOOTHNESS);
}
brsu = 0.;
if (S < -1)
brsu = brsudickson (B1, B2, N / ECM_EXTRA_SMOOTHNESS, nr, -S * 2);
if (S > 1)
brsu = brsupower (B1, B2, N / ECM_EXTRA_SMOOTHNESS, nr, S * 2);

#ifdef TESTDRIVE
printf ("stage 1 : %f, stage 2 : %f, Brent-Suyama : %f\n", stage1, stage2, brsu);
#endif

return (stage1 + stage2 + brsu) > 0. ? (stage1 + stage2 + brsu) : 0.;
}
[/code]