lidia-fixes.patch

   1 --- lidia-2.2.0/src/base/include/LiDIA/matrix/sparse_ring_matrix_kernel.cc.orig 2006-03-06 13:24:06.000000000 +0100
   2 +++ lidia-2.2.0/src/base/include/LiDIA/matrix/sparse_ring_matrix_kernel.cc      2008-01-03 22:57:26.038735205 +0100
   3 @@ -154,7 +154,7 @@ sparse_ring_matrix_kernel< T >::add (MR<
   4         lidia_size_t counter;
   5
   6         if (a == RES.Zero)
   7 -               assign(RES, M);
   8 +               SBMK< T >::assign(RES, M);
   9         else
  10                 for (i = 0; i < RES.rows; i++) {
  11                         // Memory allocation
  12 @@ -220,7 +220,7 @@ sparse_ring_matrix_kernel< T >::add (MR<
  13         lidia_size_t counter;
  14
  15         if (a == RES.Zero)
  16 -               assign(RES, M);
  17 +               SBMK< T >::assign(RES, M);
  18         else
  19                 for (i = 0; i < RES.rows; i++) {
  20                         // Memory allocation
  21 @@ -371,7 +371,7 @@ sparse_ring_matrix_kernel< T >::subtract
  22         lidia_size_t counter;
  23
  24         if (a == RES.Zero)
  25 -               assign(RES, M);
  26 +               SBMK< T >::assign(RES, M);
  27         else
  28                 for (i = 0; i < RES.rows; i++) {
  29                         // Memory allocation
  30 @@ -437,7 +437,7 @@ sparse_ring_matrix_kernel< T >::subtract
  31         lidia_size_t counter;
  32
  33         if (a == RES.Zero)
  34 -               assign(RES, M);
  35 +               SBMK< T >::assign(RES, M);
  36         else
  37                 for (i = 0; i < RES.rows; i++) {
  38                         // Memory allocation
  39 --- lidia-2.2.0/src/base/include/LiDIA/ring_matrix.h.orig       2006-03-06 13:24:06.000000000 +0100
  40 +++ lidia-2.2.0/src/base/include/LiDIA/ring_matrix.h    2008-01-03 21:42:00.885264199 +0100
  41 @@ -122,7 +122,7 @@ public:
  42
  43         ring_matrix< T > & operator = (const ring_matrix< T > &B)
  44         {
  45 -               assign(B);
  46 +               base_matrix< T >::assign(B);
  47                 return *this;
  48         }
  49
  50 --- lidia-2.2.0/src/base/include/LiDIA/dense_ring_matrix.h.orig 2006-03-06 13:24:06.000000000 +0100
  51 +++ lidia-2.2.0/src/base/include/LiDIA/dense_ring_matrix.h      2008-01-03 22:22:09.401286287 +0100
  52 @@ -91,7 +91,7 @@ public:
  53
  54         dense_ring_matrix< T > & operator = (const dense_ring_matrix< T > &B)
  55         {
  56 -               assign(B);
  57 +               dense_base_matrix< T >::assign(B);
  58                 return *this;
  59         }
  60
  61 --- lidia-2.2.0/src/base/include/LiDIA/dense_field_matrix.h.orig        2006-03-06 13:24:06.000000000 +0100
  62 +++ lidia-2.2.0/src/base/include/LiDIA/dense_field_matrix.h     2008-01-03 22:04:32.969698378 +0100
  63 @@ -93,7 +93,7 @@ public:
  64
  65         dense_field_matrix< T > & operator = (const dense_field_matrix< T > &B)
  66         {
  67 -               assign(B);
  68 +               dense_base_matrix< T >::assign(B);
  69                 return *this;
  70         }
  71
  72 --- lidia-2.2.0/src/base/include/LiDIA/sparse_field_matrix.h.orig       2006-03-06 13:24:06.000000000 +0100
  73 +++ lidia-2.2.0/src/base/include/LiDIA/sparse_field_matrix.h    2008-01-03 22:18:21.648725024 +0100
  74 @@ -97,7 +97,7 @@ public:
  75
  76         sparse_field_matrix< T > & operator = (const sparse_field_matrix< T > &B)
  77         {
  78 -               assign(B);
  79 +               sparse_base_matrix< T >::assign(B);
  80                 return *this;
  81         }
  82
  83 --- lidia-2.2.0/src/base/include/LiDIA/field_matrix.h.orig      2006-03-06 13:24:06.000000000 +0100
  84 +++ lidia-2.2.0/src/base/include/LiDIA/field_matrix.h   2008-01-03 22:10:48.653744758 +0100
  85 @@ -132,7 +132,7 @@ public:
  86
  87         field_matrix< T > & operator = (const field_matrix< T > &B)
  88         {
  89 -               assign(B);
  90 +               base_matrix< T >::assign(B);
  91                 return *this;
  92         }
  93
  94 --- lidia-2.2.0/src/base/include/LiDIA/sparse_ring_matrix.h.orig        2006-03-06 13:24:06.000000000 +0100
  95 +++ lidia-2.2.0/src/base/include/LiDIA/sparse_ring_matrix.h     2008-01-03 22:24:55.757150012 +0100
  96 @@ -103,7 +103,7 @@ public:
  97
  98         sparse_ring_matrix< T > & operator = (const sparse_ring_matrix< T > &B)
  99         {
 100 -               assign(B);
 101 +               sparse_base_matrix< T >::assign(B);
 102                 return *this;
 103         }
 104
 105 --- lidia-2.2.0/src/gec/include/LiDIA/prime_proof.h.orig        2006-03-06 13:24:10.000000000 +0100
 106 +++ lidia-2.2.0/src/gec/include/LiDIA/prime_proof.h     2008-01-03 23:35:29.756560696 +0100
 107 @@ -114,59 +114,59 @@ public:
 108         prime_proof (const bigint & p);
 109          ~prime_proof();
 110
 111 -       bool            prime_proof::prove_prime(const bigint & new_p);
 112 -       bool            prime_proof::prove_prime();
 113 -       bool            prime_proof::verify_certificate(certificate & cert);
 114 -       certificate     prime_proof::get_certificate();
 115 -       void            prime_proof::set_verbose(bool verbose);
 116 -       void            prime_proof::set_classnumbers(const int min, const int max);
 117 -       void            prime_proof::set_pollard_rho_parameter(const int start_length,const int rounds);
 118 -       void            prime_proof::set_prime(const bigint & p);
 119 -       void            prime_proof::set_top(bool is_top);
 120 -       void            prime_proof::set_ecpp_mode(int mode);
 121 -       bool            prime_proof::spp(const bigint & spp_n);
 122 -       bool            prime_proof::spp_verify_proof_prime(const base_vector <bigint> cert_vector);
 123 -       bool            prime_proof::n_minus_one( const bigint & new_q, const bigint & new_p);
 124 -       bool            prime_proof::nmo_verify_proof_prime(base_vector <bigint> cert_vector);
 125 -       bool            prime_proof::n_plus_one( const bigint & new_q, const bigint & new_p);
 126 -       bool            prime_proof::npo_verify_proof_prime(base_vector <bigint> cert_vector);
 127 -       bool            prime_proof::ecpp();
 128 -       bool            prime_proof::ecpp_verify_proof(base_vector <bigint> cert_vector);
 129 +       bool            prove_prime(const bigint & new_p);
 130 +       bool            prove_prime();
 131 +       bool            verify_certificate(certificate & cert);
 132 +       certificate     get_certificate();
 133 +       void            set_verbose(bool verbose);
 134 +       void            set_classnumbers(const int min, const int max);
 135 +       void            set_pollard_rho_parameter(const int start_length,const int rounds);
 136 +       void            set_prime(const bigint & p);
 137 +       void            set_top(bool is_top);
 138 +       void            set_ecpp_mode(int mode);
 139 +       bool            spp(const bigint & spp_n);
 140 +       bool            spp_verify_proof_prime(const base_vector <bigint> cert_vector);
 141 +       bool            n_minus_one( const bigint & new_q, const bigint & new_p);
 142 +       bool            nmo_verify_proof_prime(base_vector <bigint> cert_vector);
 143 +       bool            n_plus_one( const bigint & new_q, const bigint & new_p);
 144 +       bool            npo_verify_proof_prime(base_vector <bigint> cert_vector);
 145 +       bool            ecpp();
 146 +       bool            ecpp_verify_proof(base_vector <bigint> cert_vector);
 147
 148
 149
 150
 151  private:
 152 -       bool            prime_proof::factorize_n_pm_one();
 153 -       bool            prime_proof::minus_one_test(bigint & biggest_prime_factor);
 154 -       bool            prime_proof::plus_one_test(bigint & biggest_prime_factor);
 155 -       bool            prime_proof::ecpp_test();
 156 -       certificate     prime_proof::spp_get_certificate();
 157 -       certificate     prime_proof::nmo_get_certificate();
 158 -       certificate     prime_proof::npo_get_certificate();
 159 -       certificate     prime_proof::ecpp_get_certificate();
 160 -       bigmod          prime_proof::lucas_sequence(const bigint & r, const bigint & s, const bigint & d);
 161 -       bigint          prime_proof::found_divisor();
 162 -       bool            prime_proof::prove_n_with_curve ();
 163 -       void            prime_proof::calculate_prime_list();
 164 -       void            prime_proof::calculate_lower_bound_s();
 165 -       bool            prime_proof::prove_downstep(const bigint & r);
 166 -       bool            prime_proof::assign_class_invariant_to_curve( const gf_element & invariant );
 167 -       bool            prime_proof::assign_class_invariant_to_curve_case_minus_three();
 168 -       bool            prime_proof::assign_class_invariant_to_curve_case_minus_four();
 169 -       bigcomplex      prime_proof::class_invariant( const quadratic_form & Q );
 170 -       void            prime_proof::product_real( base_vector<bigfloat> & c,const base_vector<bigfloat> & a,const base_vector<bigfloat> & b );
 171 -       void            prime_proof::product_karatsuba( base_vector<bigfloat> & result, const base_vector<bigfloat> & f,const base_vector<bigfloat> & g);
 172 -       void            prime_proof::compute_class_polynomial();
 173 -       void            prime_proof::compute_class_polynomial_real();
 174 -       void            prime_proof::compute_class_polynomial_karatsuba_high_precision();
 175 -       void            prime_proof::compute_class_polynomial_karatsuba_low_precision();
 176 -       bool            prime_proof::find_next_discriminant(long start_h, long end_h);
 177 -       bool            prime_proof::is_good_order(bigint & t, bigint & y);
 178 -       bigint          prime_proof::pollard_rho(bigint & t);
 179 -       void            prime_proof::set_complex_precision();
 180 -       void            prime_proof::set_generation_mode();
 181 -       bool            prime_proof::generate_curve();
 182 +       bool            factorize_n_pm_one();
 183 +       bool            minus_one_test(bigint & biggest_prime_factor);
 184 +       bool            plus_one_test(bigint & biggest_prime_factor);
 185 +       bool            ecpp_test();
 186 +       certificate     spp_get_certificate();
 187 +       certificate     nmo_get_certificate();
 188 +       certificate     npo_get_certificate();
 189 +       certificate     ecpp_get_certificate();
 190 +       bigmod          lucas_sequence(const bigint & r, const bigint & s, const bigint & d);
 191 +       bigint          found_divisor();
 192 +       bool            prove_n_with_curve ();
 193 +       void            calculate_prime_list();
 194 +       void            calculate_lower_bound_s();
 195 +       bool            prove_downstep(const bigint & r);
 196 +       bool            assign_class_invariant_to_curve( const gf_element & invariant );
 197 +       bool            assign_class_invariant_to_curve_case_minus_three();
 198 +       bool            assign_class_invariant_to_curve_case_minus_four();
 199 +       bigcomplex      class_invariant( const quadratic_form & Q );
 200 +       void            product_real( base_vector<bigfloat> & c,const base_vector<bigfloat> & a,const base_vector<bigfloat> & b );
 201 +       void            product_karatsuba( base_vector<bigfloat> & result, const base_vector<bigfloat> & f,const base_vector<bigfloat> & g);
 202 +       void            compute_class_polynomial();
 203 +       void            compute_class_polynomial_real();
 204 +       void            compute_class_polynomial_karatsuba_high_precision();
 205 +       void            compute_class_polynomial_karatsuba_low_precision();
 206 +       bool            find_next_discriminant(long start_h, long end_h);
 207 +       bool            is_good_order(bigint & t, bigint & y);
 208 +       bigint          pollard_rho(bigint & t);
 209 +       void            set_complex_precision();
 210 +       void            set_generation_mode();
 211 +       bool            generate_curve();
 212
 213
 214
 215 --- lidia-2.2.0/src/base/include/LiDIA/base/sf_bigint.h.orig    2006-03-06 13:24:06.000000000 +0100
 216 +++ lidia-2.2.0/src/base/include/LiDIA/base/sf_bigint.h 2008-01-03 23:49:30.089443623 +0100
 217 @@ -230,6 +230,15 @@ private: // private members for MPQS
 218         bool check_gcd(factorization< bigint > &, const bigmod &, const bigint&);
 219  };
 220
 221 +factorization< bigint > TrialDiv(const bigint & N, const unsigned int upper_bound, const unsigned int lower_bound);
 222 +factorization< bigint > PollardRho(const bigint& x, int size);
 223 +factorization< bigint > PollardPminus1(const bigint& x, int size);
 224 +factorization< bigint > WilliamsPplus1(const bigint& x, int size);
 225 +factorization< bigint > Fermat(const bigint& x);
 226 +factorization< bigint > ECM(const bigint & x, int upper_bound, int lower_bound, int step);
 227 +factorization< bigint > MPQS(const bigint & x);
 228 +factorization< bigint > sf_factor(const bigint & x, int size);
 229 +factorization< bigint > completely_factor(const bigint & x);
 230
 231
 232  inline void