File: bestd.c

package info (click to toggle)
gmp-ecm 7.0.4+ds-5
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 4,728 kB
  • sloc: asm: 36,431; ansic: 34,057; xml: 885; python: 799; sh: 698; makefile: 348
file content (312 lines) | stat: -rw-r--r-- 10,874 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
/* Choice of best parameters for stage 2.

Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2010 Paul Zimmermann,
Alexander Kruppa, Dave Newman.

This file is part of the ECM Library.

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

The ECM Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
License for more details.

You should have received a copy of the GNU Lesser General Public License
along with the ECM Library; see the file COPYING.LIB.  If not, see
http://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */

#include <stdio.h>
#include <gmp.h>
#include "ecm-impl.h"

/*
  Compute (d, d2, k) such that:
  (0) k >= k0
  (1) d is a multiple of 6
  (2) k * d * (eulerphi(d)/2) * d2 / eulerphi(d2) >= B2 - B2min
  (3) gcd(d, d2) == 1
  (4) k is minimal, subject to previous conditions
  (5) if parameter po2 is != 0, rounds dF up to a power of 2
  Return non-zero iff an error occurred (too large step 2 bound).
 */

/* How we test whether given d,d2,dF,k,i0 parameters cover the desired 
   B2min-B2 range:

   In stage 2 we generate all values  p = f(i * d) +- f(j * d2)  with 

     1. gcd (i, d2) == 1, 
     2. gcd (j, d) == 1,
     3. j == 1 (mod 6),
     4. 6|d
     5. 1 <= j <= d - 5, (it's -5, not just -1, because of 3. and 4.)
     6. i0 <= i <= i1
     7. gcd (d, d2) == 1
   
   where f(x) is x^S or the S-th Dickson polynomial g_{S,-1}(x). Extra 
   factors included by S>1 are not considered in this analysis, we assume 
   S=1, f(x)=x so that  p = i * d +- j * d2.

   (Note: i values greater than stated in 3. may be generated if we have 
    to round up dF, for example to a power of 2. However, the root generation
    code can put anything it likes in those extra roots, so we make no 
    assumption here that this will extend the range of the i values.)
   
   Hence the values at the high end of the stage 2 range that are not 
   generated are
   
     p = (i1 + n) * d +- j * d2, n > 0

   and the smallest one of those is
   
     p = (i1 + 1) * d - (d - 5) * d2
       = d * (i1 - d2 + 1) + 5 * d2
   
   At the low end of stage 2, values not generated are
   
     p = (i0 - n) * d +- j * d2, n > 0   

   the largest one being
   
     p = (i0 - 1) * d + (d - 5) * d2
       = d * (i0 + d2 - 1) - 5*d2

   Thus, values p that are coprime do d*d2 and 
     d * (i0 + d2 - 1) - 5*d2 + 1 <= p <= d * (i1 - d2 + 1) + 5 * d2 - 1 
   are included in stage 2.

   
   The number of roots of G we compute is k * dF. For d2 == 1, this means 
   i1 = i0 + k * dF - 1  (-1 because both i0 and i1 are included).

   For d2 > 1, values j not coprime to d2 are skipped (see condition 1).
   The number of values in [1, i0] that are not coprime to d2 (with d2 prime) 
   is floor (i0 / d2); in [1, i1] it is floor (i1 / d2). 
   So we require that
   k * dF >= i1 - i0 + 1 - (floor (i1 / d2) - floor (i0 / d2))
   
   
*/

int
bestD (root_params_t *root_params, unsigned long *finalk, 
       unsigned long *finaldF, mpz_t B2min, mpz_t B2, int po2, int use_ntt, 
       double maxmem, int treefile, mpmod_t modulus)
{
/* the following list contains successive values of b with
   increasing values of eulerphi(b). It was generated by the following 
   Maple program:
l := [[1,1]]:
for b from 12 by 6 do
   d:=numtheory[phi](b)/2;
   while d <= l[nops(l)][2] do l:=subsop(nops(l)=NULL, l) od;
   n := nops(l);
   if b>1.1*l[n][1] then l := [op(l), [b,d]]; lprint(l) fi;
od:
*/
#define N 109
  static unsigned int l[N] = {12, 18, 30, 42, 60, 90, 120, 150, 210, 240, 270, 330, 420, 510, 630, 840, 1050, 1260, 1470, 1680, 1890, 2310, 2730, 3150, 3570, 3990, 4620, 5460, 6090, 6930, 8190, 9240, 10920, 12180, 13860, 16170, 18480, 20790, 23100, 30030, 34650, 39270, 43890, 48510, 60060, 66990, 78540, 90090, 99330, 120120, 133980, 150150, 180180, 210210, 240240, 270270, 300300, 334950, 371280, 420420, 510510, 570570, 600600, 630630, 746130, 870870, 1021020, 1141140, 1291290, 1531530, 1711710, 1891890, 2081310, 2312310, 2552550, 2852850, 3183180, 3573570, 3993990, 4594590, 5105100, 5705700, 6322470, 7147140, 7987980, 8978970, 10210200, 11741730, 13123110, 14804790, 16546530, 19399380, 21411390, 23993970, 26816790, 29609580, 33093060, 36606570, 40330290, 44414370, 49639590, 54624570, 60090030, 67897830, 77597520, 87297210, 96996900, 107056950, 118107990};
#define Npo2 23
  static unsigned int lpo2[Npo2] = {12, 30, 60, 120, 240, 510, 1020, 2310, 
                                 4620, 9240, 19110, 39270, 79170, 158340, 
                                 324870, 690690, 1345890, 2852850, 5705700, 
                                 11741730, 23130030, 48498450, 96996900};

  unsigned long i, d1 = 0, d2 = 0, dF = 0, phid, k, maxN;
  mpz_t j, t, i0, i1;
  int r = 0;

  if (mpz_cmp (B2, B2min) < 0)
    {
      /* No stage 2. Set relevant parameters to 0. Leave B2, B2min the same */
      *finalk = 0;
      *finaldF = 0;
      return 0;
    }
  
  mpz_init (i0);
  mpz_init (i1);
  mpz_init (j);
  mpz_init (t);
  k = *finalk; /* User specified k value passed in via finalk */

  /* Look for largest dF we can use while satisfying the maxmem parameter */
  maxN = (po2) ? Npo2 : N;
  if (maxmem != 0.)
  {
    for (i = 0; i < maxN; i++)
      {
        int lg_dF, sp_num = 0;
        double memory;
        
        d1 = (po2) ? lpo2[i] : l[i];
        phid = eulerphi (d1) / 2;
        dF = (po2) ? 1U << ceil_log2 (phid) : phid;
        lg_dF = ceil_log2 (dF);
        
        if (use_ntt)
          sp_num = (2 * mpz_sizeinbase (modulus->orig_modulus, 2) + lg_dF) / 
                 SP_NUMB_BITS + 4;
        
	memory = memory_use (dF, sp_num, (treefile) ? 0 : lg_dF, modulus);
        outputf (OUTPUT_DEVVERBOSE, 
                 "Estimated mem for dF = %.0d, sp_num = %d: %.0f\n", 
                 dF, sp_num, memory);
        if (memory > maxmem)
          break;
      }
    maxN = i;
  }      
  
  for (i = 0; i < maxN; i++)
    {
      d1 = (po2) ? lpo2[i] : l[i];
      phid = eulerphi (d1) / 2;
      dF = (po2) ? 1U << ceil_log2 (phid) : phid;
      /* Look for smallest prime < 25 that does not divide d1 */
      /* The caller can force d2 = 1 by setting root_params->d2 != 0 */
      d2 = 1;
      if (root_params->d2 == 0)
        for (d2 = 5; d2 < 25; d2 += 2)
          {
            if (d2 % 3 == 0)
              continue;
            if (d1 % d2 > 0)
              break;
          }

      if (d2 >= 25 || d2 - 1 > dF)
        d2 = 1;

#if 0
      /* The code to init roots of G can handle negative i0 now. */
      if (d2 > 1 && mpz_cmp_ui (B2min, (d1 - 1) * d2 - d1) <= 0) 
        d2 = 1; /* Would make i0 < 0 */
#endif
      
      mpz_set_ui (i0, d1 - 1);
      mpz_mul_ui (i0, i0, d2);
      mpz_set (j, B2);
      mpz_add (i1, j, i0); /* i1 = B2 + (d1 - 1) * d2 */
      mpz_set (j, B2min);
      mpz_sub (i0, j, i0); /* i0 = B2min - (d1 - 1) * d2 */
      mpz_cdiv_q_ui (i0, i0, d1); /* i0 = ceil ((B2min - (d1 - 1) * d2) / d1) */
      mpz_fdiv_q_ui (i1, i1, d1); /* i1 = floor ((B2 + (d1 - 1) * d2) / d1) */
      
      /* How many roots of G will we need ? */
      mpz_sub (j, i1, i0);
      mpz_add_ui (j, j, 1);

      /* Integer multiples of d2 are skipped (if d2 > 1) */
      if (d2 > 1)
        {
          mpz_fdiv_q_ui (t, i1, d2);
          mpz_sub (j, j, t);
          mpz_fdiv_q_ui (t, i0, d2);
          mpz_add (j, j, t); /* j -= floor (i1 / d2) - floor (i0 / d2) */
        }
      
      /* How many blocks will we need ? Divide lines by dF, rounding up */
      mpz_cdiv_q_ui (j, j, dF);
      
      if ((k != ECM_DEFAULT_K && mpz_cmp_ui (j, k) <= 0) || 
          (k == ECM_DEFAULT_K && mpz_cmp_ui (j, (po2) ? 6 : 2) <= 0))
        break;
    }

  if (i == maxN)
    {
      if (k != ECM_DEFAULT_K)
        {
          /* The user asked for a specific k and we couldn't satisfy the
             condition. Nothing we can do ... */
          outputf (OUTPUT_ERROR, "Error: too large step 2 bound, increase -k\n");
          r = ECM_ERROR;
          goto clear_and_exit;
        }
      else if (!mpz_fits_ulong_p (j))
        {
          /* Can't fit the number of blocks in an unsigned long. Nothing we
             can do ... */
          outputf (OUTPUT_ERROR, "Error: stage 2 interval too large, cannot "
                   "generate suitable parameters.\nTry a smaller B2 value.\n");
          r = ECM_ERROR;
          goto clear_and_exit;
        }
      if (maxN == 0)
        {
          /* We can't do a stage 2 at all with the memory the user allowed.
             Nothing we can do ... */
          outputf (OUTPUT_ERROR, "Error: stage 2 not possible with memory "
                   "allowed by -maxmem.\n");
          r = ECM_ERROR;
          goto clear_and_exit;
        }
      /* else: We can fit the number of blocks into an unsigned int, so we use 
         it. This may be a very large value for huge B2-B2min, the user
         is going to notice sooner or later */
    }
  
  /* If the user specified a number of blocks, we'll use that no matter what.
     Since j may be smaller than k, this may increase the B2 limit */
  if (k == ECM_DEFAULT_K)
    k = mpz_get_ui (j);

  /* Now that we have the number of blocks, compute real i1. There will be
     k * dF roots of G computed, starting at i0, skipping all that are not
     coprime to d2. While d2 is prime, that means: are not multiples of d2.
     Hence we want i1 so that 
       i1 - floor(i1 / d2) - i0 + ceil((i0 / d2) == k * dF
       i1 - floor(i1 / d2) == k * dF + i0 - ceil((i0 / d2)
  */
  
  mpz_set_ui (j, k);
  mpz_mul_ui (j, j, dF);
  if (d2 == 1)
    {
      mpz_add (i1, i0, j);
      mpz_sub_ui (i1, i1, 1);
    }
  else
    {
      mpz_add (j, j, i0);
      mpz_cdiv_q_ui (t, i0, d2);
      mpz_sub (j, j, t); /* j = k * dF + i0 - ceil((i0 / d2) */
      mpz_fdiv_qr_ui (j, t, j, d2 - 1);
      mpz_mul_ui (j, j, d2);
      mpz_add (i1, j, t);
    }

  root_params->d1 = d1;
  root_params->d2 = d2;
  mpz_set (root_params->i0, i0);
  *finaldF = dF;
  *finalk = k;

  /* We want B2' the largest integer that satisfies 
     i1 = floor ((B2' + (d1 - 1) * d2) / d1)
        = floor ((B2'-d2)/d1) + d2
     i1 - d2 = floor ((B2'-d2)/d1)
     (B2'-d2)/d1 < i1-d2+1
     B2'-d2 < (i1-d2+1) * d1
     B2' < (i1-d2+1) * d1 + d2
     B2' = (i1-d2+1) * d1 + d2 - 1
  */
  
  mpz_sub_ui (i1, i1, d2 - 1);
  mpz_mul_ui (B2, i1, d1);
  mpz_add_ui (B2, B2, d2 - 1);

clear_and_exit:
  mpz_clear (t);
  mpz_clear (j);
  mpz_clear (i1);
  mpz_clear (i0);

  return r;
}