1 //==============================================================================================
2 //
3 // This file is part of LiDIA --- a library for computational number theory
4 //
5 // Copyright (c) 1994--2001 the LiDIA Group. All rights reserved.
6 //
7 // See http://www.informatik.tu-darmstadt.de/TI/LiDIA/
8 //
9 //----------------------------------------------------------------------------------------------
10 //
11 // $Id$
12 //
13 // Author : Werner Backes (WB), Thorsten Lauer (TL)
14 // Changes : see CVS log
15 //
16 //==============================================================================================
17
18
19 #ifndef LIDIA_LATTICE_MODULES_CC_GUARD_
20 #define LIDIA_LATTICE_MODULES_CC_GUARD_
21
22
23
24 /*
25 * g++-2.95.2 occasionally does not instantiate inline specializations
26 * of template class member functions when compiling with
27 * -fno-implicit-templates (though that should not affect inline
28 * definitions). To work around this, we control the instantiations
29 * ourselves, using the pragmas `interface' and `implementation',
30 * which have the additional advantage of avoiding the duplication of
31 * instantiations.
32 */
33 #if __GNUC__ && __GNUC__ < 3
34 #pragma interface "lattice_modules.cc"
35 #endif
36
37
38
39 #ifdef LIDIA_NAMESPACE
40 # ifndef IN_NAMESPACE_LIDIA
41 namespace LiDIA {
42 # endif
43 #endif
44
45
46
47 //
48 // Code for
49 // * base_modules < {bigfloat, bigint}, {double, xdouble, bigfloat} >
50 //
51 //
52 // bigint / double
53 //
54 template <>
55 inline void
prec_startup(dense_alg<bigint> &)56 prec_modules< bigint, double >::prec_startup (dense_alg< bigint > &)
57 {
58 }
59
60
61
62 template <>
63 inline void
prec_update(dense_alg<bigint> & da)64 prec_modules< bigint, double >::prec_update (dense_alg< bigint > & da)
65 {
66 da.d.cut_bit_prec = (1+(da.d.bit_prec/MANTISSA_CUT))*MANTISSA_CUT;
67 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
68 }
69
70
71
72 template <>
73 inline void
prec_exact(const dense_alg<bigint> &)74 prec_modules< bigint, double >::prec_exact (const dense_alg< bigint > &)
75 {
76 }
77
78
79
80 template <>
81 inline void
prec_approx(const dense_alg<bigint> &)82 prec_modules< bigint, double >::prec_approx (const dense_alg< bigint > &)
83 {
84 }
85
86
87
88 template <>
89 inline void
prec_correct(const dense_alg<bigint> &)90 prec_modules< bigint, double >::prec_correct (const dense_alg< bigint > &)
91 {
92 }
93
94
95
96 template <>
97 inline void
prec_restore(const dense_alg<bigint> &)98 prec_modules< bigint, double >::prec_restore (const dense_alg< bigint > &)
99 {
100 }
101
102
103 //
104 // bigint / xdouble
105 //
106 template <>
107 inline void
prec_startup(dense_alg<bigint> &)108 prec_modules< bigint, xdouble >::prec_startup (dense_alg< bigint > &)
109 {
110 }
111
112
113
114 template <>
115 inline void
prec_update(dense_alg<bigint> & da)116 prec_modules< bigint, xdouble >::prec_update (dense_alg< bigint > & da)
117 {
118 da.d.cut_bit_prec = (1+(da.d.bit_prec/MANTISSA_CUT))*MANTISSA_CUT;
119 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
120 }
121
122
123
124 template <>
125 inline void
prec_exact(const dense_alg<bigint> &)126 prec_modules< bigint, xdouble >::prec_exact (const dense_alg< bigint > &)
127 {
128 }
129
130
131
132 template <>
133 inline void
prec_approx(const dense_alg<bigint> &)134 prec_modules< bigint, xdouble >::prec_approx (const dense_alg< bigint > &)
135 {
136 }
137
138
139
140 template <>
141 inline void
prec_correct(const dense_alg<bigint> &)142 prec_modules< bigint, xdouble >::prec_correct (const dense_alg< bigint > &)
143 {
144 }
145
146
147
148 template <>
149 inline void
prec_restore(const dense_alg<bigint> &)150 prec_modules< bigint, xdouble >::prec_restore (const dense_alg< bigint > &)
151 {
152 }
153
154
155
156 //
157 // bigint / bigfloat
158 //
159 template <>
160 inline void
prec_startup(dense_alg<bigint> & da)161 prec_modules< bigint, bigfloat >::prec_startup (dense_alg< bigint > & da)
162 {
163 da.d.old_prec = bigfloat::get_precision();
164 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
165 }
166
167
168
169 template <>
170 inline void
prec_update(dense_alg<bigint> & da)171 prec_modules< bigint, bigfloat >::prec_update (dense_alg< bigint > & da)
172 {
173 da.d.cut_bit_prec = (1+(da.d.bit_prec/MANTISSA_CUT))*MANTISSA_CUT;
174 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
175 }
176
177
178
179 template <>
180 inline void
prec_exact(const dense_alg<bigint> &)181 prec_modules< bigint, bigfloat >::prec_exact (const dense_alg< bigint > &)
182 {
183 }
184
185
186
187 template <>
188 inline void
prec_approx(const dense_alg<bigint> & da)189 prec_modules< bigint, bigfloat >::prec_approx (const dense_alg< bigint > & da)
190 {
191 bigfloat::set_precision(da.d.approx_prec);
192 }
193
194
195
196 template <>
197 inline void
prec_correct(const dense_alg<bigint> &)198 prec_modules< bigint, bigfloat >::prec_correct (const dense_alg< bigint > &)
199 {
200 }
201
202
203
204 template <>
205 inline void
prec_restore(const dense_alg<bigint> & da)206 prec_modules< bigint, bigfloat >::prec_restore (const dense_alg< bigint > & da)
207 {
208 bigfloat::set_precision(da.d.old_prec);
209 }
210
211
212
213 //
214 // bigfloat / double
215 //
216 template <>
217 inline void
prec_startup(dense_alg<bigfloat> & da)218 prec_modules< bigfloat, double >::prec_startup (dense_alg< bigfloat > & da)
219 {
220 //
221 // Compute precision of read lattice
222 //
223 da.d.old_prec = bigfloat::get_precision();
224 da.d.read_prec = 0;
225 for (lidia_size_t i = 0; i < da.b.rows; ++i)
226 for (lidia_size_t j = 0; j < da.b.columns; ++j)
227 if (da.d.read_prec < (tempsdt = static_cast<sdigit>(da.s.value[i][j].bit_length()/
228 std::log(10.0)+1)))
229 da.d.read_prec = tempsdt;
230 da.d.exact_prec = da.d.read_prec*((da.b.columns > da.b.rows)?
231 da.b.columns:da.b.rows);
232 da.d.exact_prec *= Magic_Precision_Factor;
233 }
234
235
236
237 template <>
238 inline void
prec_update(dense_alg<bigfloat> & da)239 prec_modules< bigfloat, double >::prec_update (dense_alg< bigfloat > & da)
240 {
241 da.d.cut_bit_prec = (1+(da.d.bit_prec/MANTISSA_CUT))*MANTISSA_CUT;
242 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
243 }
244
245
246
247 template <>
248 inline void
prec_approx(const dense_alg<bigfloat> &)249 prec_modules< bigfloat, double >::prec_approx (const dense_alg< bigfloat > &)
250 {
251 }
252
253
254
255 template <>
256 inline void
prec_exact(const dense_alg<bigfloat> & da)257 prec_modules< bigfloat, double >::prec_exact (const dense_alg< bigfloat > & da)
258 {
259 bigfloat::set_precision(da.d.exact_prec);
260 }
261
262
263
264 template <>
265 inline void
prec_correct(const dense_alg<bigfloat> & da)266 prec_modules< bigfloat, double >::prec_correct (const dense_alg< bigfloat > & da)
267 {
268 bigfloat::set_precision(da.b.columns+(static_cast<sdigit>(DOUBLE_MANTISSA_BITS*std::log(2.0)/
269 std::log(10.0)+1)*2));
270 }
271
272
273
274 template <>
275 inline void
prec_restore(const dense_alg<bigfloat> & da)276 prec_modules< bigfloat, double >::prec_restore (const dense_alg< bigfloat > & da)
277 {
278 bigfloat::set_precision(da.d.old_prec);
279 }
280
281
282
283 //
284 // bigfloat / xdouble
285 //
286 template <>
287 inline void
prec_startup(dense_alg<bigfloat> & da)288 prec_modules< bigfloat, xdouble >::prec_startup (dense_alg< bigfloat > & da)
289 {
290 da.d.old_prec = bigfloat::get_precision();
291 //
292 // Compute precision of read lattice
293 //
294 da.d.read_prec = 0;
295 for (lidia_size_t i = 0; i < da.b.rows; ++i)
296 for (lidia_size_t j = 0; j < da.b.columns; ++j)
297 if (da.d.read_prec < (tempsdt = static_cast<sdigit>(da.s.value[i][j].bit_length()/
298 std::log(10.0)+1)))
299 da.d.read_prec = tempsdt;
300 da.d.exact_prec = da.d.read_prec*((da.b.columns > da.b.rows)?
301 da.b.columns:da.b.rows);
302 da.d.exact_prec *= Magic_Precision_Factor;
303 }
304
305
306
307 template <>
308 inline void
prec_update(dense_alg<bigfloat> & da)309 prec_modules< bigfloat, xdouble >::prec_update (dense_alg< bigfloat > & da)
310 {
311 da.d.cut_bit_prec = (1+(da.d.bit_prec/MANTISSA_CUT))*MANTISSA_CUT;
312 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
313 }
314
315
316
317 template <>
318 inline void
prec_approx(const dense_alg<bigfloat> &)319 prec_modules< bigfloat, xdouble >::prec_approx (const dense_alg< bigfloat > &)
320 {
321 }
322
323
324
325 template <>
326 inline void
prec_exact(const dense_alg<bigfloat> & da)327 prec_modules< bigfloat, xdouble >::prec_exact (const dense_alg< bigfloat > & da)
328 {
329 bigfloat::set_precision(da.d.exact_prec);
330 }
331
332
333
334 template <>
335 inline void
prec_correct(const dense_alg<bigfloat> & da)336 prec_modules< bigfloat, xdouble >::prec_correct (const dense_alg< bigfloat > & da)
337 {
338 bigfloat::set_precision(da.b.columns+(static_cast<sdigit>(DOUBLE_MANTISSA_BITS*std::log(2.0)/
339 std::log(10.0)+1)*4));
340 }
341
342
343
344 template <>
345 inline void
prec_restore(const dense_alg<bigfloat> & da)346 prec_modules< bigfloat, xdouble >::prec_restore (const dense_alg< bigfloat > & da)
347 {
348 bigfloat::set_precision(da.d.old_prec);
349 }
350
351
352
353 //
354 // bigfloat / bigfloat
355 //
356 template <>
357 inline void
prec_startup(dense_alg<bigfloat> & da)358 prec_modules< bigfloat, bigfloat >::prec_startup (dense_alg< bigfloat > & da)
359 {
360 da.d.old_prec = bigfloat::get_precision();
361 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
362 //
363 // Compute precision of read lattice
364 //
365 da.d.read_prec = 0;
366 for (lidia_size_t i = 0; i < da.b.rows; ++i)
367 for (lidia_size_t j = 0; j < da.b.columns; ++j)
368 if (da.d.read_prec < (tempsdt = static_cast<sdigit>(da.s.value[i][j].bit_length()/
369 std::log(10.0)+1)))
370 da.d.read_prec = tempsdt;
371 da.d.exact_prec = da.d.read_prec*((da.b.columns > da.b.rows)?
372 da.b.columns:da.b.rows);
373 da.d.exact_prec *= Magic_Precision_Factor;
374 }
375
376
377
378 template <>
379 inline void
prec_update(dense_alg<bigfloat> & da)380 prec_modules< bigfloat, bigfloat >::prec_update (dense_alg< bigfloat > & da)
381 {
382 da.d.cut_bit_prec = (1+(da.d.bit_prec/MANTISSA_CUT))*MANTISSA_CUT;
383 da.d.approx_prec = static_cast<sdigit>(static_cast<double>(da.d.bit_prec)*std::log(2.0)/std::log(10.0));
384 }
385
386
387
388 template <>
389 inline void
prec_approx(const dense_alg<bigfloat> & da)390 prec_modules< bigfloat, bigfloat >::prec_approx (const dense_alg< bigfloat > & da)
391 {
392 bigfloat::set_precision(da.d.approx_prec);
393 }
394
395
396
397 template <>
398 inline void
prec_exact(const dense_alg<bigfloat> & da)399 prec_modules< bigfloat, bigfloat >::prec_exact (const dense_alg< bigfloat > & da)
400 {
401 bigfloat::set_precision(da.d.exact_prec);
402 }
403
404
405
406 template <>
407 inline void
prec_correct(const dense_alg<bigfloat> & da)408 prec_modules< bigfloat, bigfloat >::prec_correct (const dense_alg< bigfloat > & da)
409 {
410 bigfloat::set_precision(da.b.columns+(static_cast<sdigit>(da.d.bit_prec*std::log(2.0)/
411 std::log(10.0)+1)*2));
412 }
413
414
415
416 template <>
417 inline void
prec_restore(const dense_alg<bigfloat> & da)418 prec_modules< bigfloat, bigfloat >::prec_restore (const dense_alg< bigfloat > & da)
419 {
420 bigfloat::set_precision(da.d.old_prec);
421 }
422
423
424
425 //
426 // End of
427 // * prec_modules < {bigfloat, bigint}, {double, xdouble, bigfloat} >
428 //
429
430 //
431 // Code for
432 // * base_modules < bigint, {double, xdouble, bigfloat}, Normal >
433 // * basis_modules < bigint, {double, xdouble, bigfloat}, Normal >
434 // * gensys_modules < bigint, {double, xdouble, bigfloat}, Normal >
435 //
436 template <>
437 inline void
E_convert_value_A(dense_alg<bigint> &,double & d,const bigint & bin)438 base_modules< bigint, double, Normal >::E_convert_value_A (dense_alg< bigint > &,
439 double& d,
440 const bigint& bin)
441 {
442 d = dbl(bin);
443 }
444
445
446
447 template <>
448 inline bool
A_convert_value_E_bound(dense_alg<bigint> &,bigint & bin,const double & dbl,const double & bound)449 base_modules< bigint, double, Normal >::A_convert_value_E_bound (dense_alg< bigint > &,
450 bigint& bin,
451 const double& dbl,
452 const double& bound)
453 {
454 if (fabs(dbl) > bound) {
455 tempbfl.assign(dbl);
456 tempbfl.bigintify(bin);
457 return (true);
458 }
459 else {
460 bin.assign(static_cast<sdigit>(dbl));
461 return (false);
462 }
463 }
464
465
466
467 template <>
468 inline void
E_convert_value_A(dense_alg<bigint> &,xdouble & xd,const bigint & bin)469 base_modules< bigint, xdouble, Normal >::E_convert_value_A (dense_alg< bigint > &,
470 xdouble& xd,
471 const bigint& bin)
472 {
473 xd = xdbl(bin);
474 }
475
476
477
478 template <>
479 inline bool
A_convert_value_E_bound(dense_alg<bigint> &,bigint & bin,const xdouble & xdbl,const xdouble & bound)480 base_modules< bigint, xdouble, Normal >::A_convert_value_E_bound (dense_alg< bigint > &,
481 bigint& bin,
482 const xdouble& xdbl,
483 const xdouble& bound)
484 {
485 tempbfl.assign(xdbl);
486 tempbfl.bigintify(bin);
487 if (fabs(xdbl) > bound)
488 return (true);
489 return (false);
490 }
491
492
493
494 template <>
495 inline void
E_convert_value_A(dense_alg<bigint> & da,bigfloat & bfl,const bigint & bin)496 base_modules< bigint, bigfloat, Normal >::E_convert_value_A (dense_alg< bigint > & da,
497 bigfloat& bfl,
498 const bigint& bin)
499 {
500 bi_bit_len = bin.bit_length();
501 if (bi_bit_len > da.d.cut_bit_prec) {
502 bit_diff = bi_bit_len-da.d.cut_bit_prec;
503 shift_right(tempbin, bin, bit_diff);
504 bfl.assign(tempbin);
505 shift_left(bfl, bfl, bit_diff);
506 }
507 else
508 bfl.assign(bin);
509 }
510
511
512
513 template <>
514 inline bool
A_convert_value_E_bound(dense_alg<bigint> &,bigint & bin,const bigfloat & bfl,const bigfloat & bound)515 base_modules< bigint, bigfloat, Normal >::A_convert_value_E_bound (dense_alg< bigint > &,
516 bigint& bin,
517 const bigfloat& bfl,
518 const bigfloat& bound)
519 {
520 bfl.bigintify(bin);
521 if (abs(bfl).compare(bound) > 0)
522 return (true);
523 return (false);
524 }
525
526
527
528 template <>
529 inline void
E_convert_lattice_A(dense_alg<bigint> & da,double ** dblvalue)530 basis_modules< bigint, double, Normal >::E_convert_lattice_A (dense_alg< bigint > & da,
531 double** dblvalue)
532 {
533 for (lidia_size_t i = 0; i < da.b.rows; i++)
534 for (lidia_size_t j = 0; j < da.b.columns; j++)
535 dblvalue[i][j] = dbl(da.s.value[i][j]);
536 }
537
538
539
540 template <>
541 inline bool
E_convert_vector_A(dense_alg<bigint> & da,double ** dblvalue,const lidia_size_t k)542 basis_modules< bigint, double, Normal >::E_convert_vector_A (dense_alg< bigint > & da,
543 double **dblvalue,
544 const lidia_size_t k)
545 {
546 for (lidia_size_t i = 0; i < da.b.columns; i++)
547 dblvalue[k][i] = dbl(da.s.value[k][i]);
548 return(false);
549 }
550
551
552
553 template <>
554 inline void
E_convert_lattice_A(dense_alg<bigint> & da,xdouble ** xdblvalue)555 basis_modules< bigint, xdouble, Normal >::E_convert_lattice_A (dense_alg< bigint > & da,
556 xdouble** xdblvalue)
557 {
558 for (lidia_size_t i = 0; i < da.b.rows; i++)
559 for (lidia_size_t j = 0; j < da.b.columns; j++)
560 xdblvalue[i][j] = xdbl(da.s.value[i][j]);
561 }
562
563
564
565 template <>
566 inline bool
E_convert_vector_A(dense_alg<bigint> & da,xdouble ** xdblvalue,const lidia_size_t k)567 basis_modules< bigint, xdouble, Normal >::E_convert_vector_A (dense_alg< bigint > & da,
568 xdouble **xdblvalue,
569 const lidia_size_t k)
570 {
571 for (lidia_size_t i = 0; i < da.b.columns; i++)
572 xdblvalue[k][i] = xdbl(da.s.value[k][i]);
573 return(false);
574 }
575
576
577
578 template <>
579 inline void
E_convert_lattice_A(dense_alg<bigint> & da,bigfloat ** bflvalue)580 basis_modules< bigint, bigfloat, Normal >::E_convert_lattice_A (dense_alg< bigint > & da,
581 bigfloat** bflvalue)
582 {
583 for (lidia_size_t i = 0; i < da.b.rows; i++)
584 for (lidia_size_t j = 0; j < da.b.columns; j++) {
585 bi_bit_len = da.s.value[i][j].bit_length();
586 if (bi_bit_len > da.d.cut_bit_prec) {
587 bit_diff = bi_bit_len-da.d.cut_bit_prec;
588 shift_right(tempbin, da.s.value[i][j], bit_diff);
589 bflvalue[i][j].assign(tempbin);
590 shift_left(bflvalue[i][j], bflvalue[i][j], bit_diff);
591 }
592 else
593 bflvalue[i][j].assign(da.s.value[i][j]);
594 }
595 }
596
597
598
599 template <>
600 inline bool
E_convert_vector_A(dense_alg<bigint> & da,bigfloat ** bflvalue,const lidia_size_t k)601 basis_modules< bigint, bigfloat, Normal >::E_convert_vector_A (dense_alg< bigint > & da,
602 bigfloat** bflvalue,
603 const lidia_size_t k)
604 {
605 for (lidia_size_t i = 0; i < da.b.columns; i++) {
606 bi_bit_len = da.s.value[k][i].bit_length();
607 if (bi_bit_len > da.d.cut_bit_prec) {
608 bit_diff = bi_bit_len-da.d.cut_bit_prec;
609 shift_right(tempbin, da.s.value[k][i], bit_diff);
610 bflvalue[k][i].assign(tempbin);
611 shift_left(bflvalue[k][i], bflvalue[k][i], bit_diff);
612 }
613 else
614 bflvalue[k][i].assign(da.s.value[k][i]);
615 }
616 return (false);
617 }
618
619
620
621 template <>
622 inline void
E_convert_lattice_A(dense_alg<bigint> & da,double ** dblvalue)623 gensys_modules< bigint, double, Normal >::E_convert_lattice_A (dense_alg< bigint > & da,
624 double** dblvalue)
625 {
626 for (lidia_size_t i = 0; i < da.b.rank;) {
627 is_zero = true;
628 for (lidia_size_t j = 0; j < da.b.columns; j++)
629 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
630 dblvalue[i][j] = dbl(da.s.value[i][j]);
631 is_zero = false;
632 }
633 else
634 dblvalue[i][j] = 0.0;
635 if (is_zero) {
636 da.b.rank--;
637 for (lidia_size_t j = i; j < da.b.rank; j++) {
638 tempP = static_cast<void *>(dblvalue[j]);
639 dblvalue[j] = dblvalue[j+1];
640 dblvalue[j+1] = static_cast<double *>(tempP);
641 tempP = static_cast<void *>(da.s.value[j]);
642 da.s.value[j] = da.s.value[j+1];
643 da.s.value[j+1] = static_cast<bigint *>(tempP);
644 }
645 }
646 else
647 i++;
648 }
649 }
650
651
652
653 template <>
654 inline bool
E_convert_vector_A(dense_alg<bigint> & da,double ** dblvalue,const lidia_size_t k)655 gensys_modules< bigint, double, Normal >::E_convert_vector_A (dense_alg< bigint > & da,
656 double** dblvalue,
657 const lidia_size_t k)
658 {
659 is_zero = true;
660 for (lidia_size_t i = 0; i < da.b.columns; i++)
661 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
662 dblvalue[k][i] = dbl(da.s.value[k][i]);
663 is_zero = false;
664 }
665 else
666 dblvalue[k][i] = 0.0;
667 if (is_zero) {
668 da.b.rank--;
669 for (lidia_size_t i = k; i < da.b.rank; i++) {
670 tempP = static_cast<void *>(dblvalue[i]);
671 dblvalue[i] = dblvalue[i+1];
672 dblvalue[i+1] = static_cast<double *>(tempP);
673 tempP = static_cast<void *>(da.s.value[i]);
674 da.s.value[i] = da.s.value[i+1];
675 da.s.value[i+1] = static_cast<bigint *>(tempP);
676 }
677 return(true);
678 }
679 return(false);
680 }
681
682
683
684 template <>
685 inline void
E_convert_lattice_A(dense_alg<bigint> & da,xdouble ** xdblvalue)686 gensys_modules< bigint, xdouble, Normal >::E_convert_lattice_A (dense_alg< bigint > & da,
687 xdouble** xdblvalue)
688 {
689 for (lidia_size_t i = 0; i < da.b.rank;) {
690 is_zero = true;
691 for (lidia_size_t j = 0; j < da.b.columns; j++)
692 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
693 xdblvalue[i][j] = xdbl(da.s.value[i][j]);
694 is_zero = false;
695 }
696 else
697 xdblvalue[i][j] = 0.0;
698 if (is_zero) {
699 da.b.rank--;
700 for (lidia_size_t j = i; j < da.b.rank; j++) {
701 tempP = static_cast<void *>(xdblvalue[j]);
702 xdblvalue[j] = xdblvalue[j+1];
703 xdblvalue[j+1] = static_cast<xdouble *>(tempP);
704 tempP = static_cast<void *>(da.s.value[j]);
705 da.s.value[j] = da.s.value[j+1];
706 da.s.value[j+1] = static_cast<bigint *>(tempP);
707 }
708 }
709 else
710 i++;
711 }
712 }
713
714
715
716 template <>
717 inline bool
E_convert_vector_A(dense_alg<bigint> & da,xdouble ** xdblvalue,const lidia_size_t k)718 gensys_modules< bigint, xdouble, Normal >::E_convert_vector_A (dense_alg< bigint > & da,
719 xdouble** xdblvalue,
720 const lidia_size_t k)
721 {
722 is_zero = true;
723 for (lidia_size_t i = 0; i < da.b.columns; i++)
724 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
725 xdblvalue[k][i] = xdbl(da.s.value[k][i]);
726 is_zero = false;
727 }
728 else
729 xdblvalue[k][i] = 0.0;
730 if (is_zero) {
731 da.b.rank--;
732 for (lidia_size_t i = k; i < da.b.rank; i++) {
733 tempP = static_cast<void *>(xdblvalue[i]);
734 xdblvalue[i] = xdblvalue[i+1];
735 xdblvalue[i+1] = static_cast<xdouble *>(tempP);
736 tempP = static_cast<void *>(da.s.value[i]);
737 da.s.value[i] = da.s.value[i+1];
738 da.s.value[i+1] = static_cast<bigint *>(tempP);
739 }
740 return(true);
741 }
742 return(false);
743 }
744
745
746
747 template <>
748 inline void
E_convert_lattice_A(dense_alg<bigint> & da,bigfloat ** bflvalue)749 gensys_modules< bigint, bigfloat, Normal >::E_convert_lattice_A (dense_alg< bigint > & da,
750 bigfloat** bflvalue)
751 {
752 for (lidia_size_t i = 0; i < da.b.rank;) {
753 is_zero = true;
754 for (lidia_size_t j = 0; j < da.b.columns; j++)
755 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
756 bi_bit_len = da.s.value[i][j].bit_length();
757 if (bi_bit_len > da.d.cut_bit_prec) {
758 bit_diff = bi_bit_len-da.d.cut_bit_prec;
759 shift_right(tempbin, da.s.value[i][j], bit_diff);
760 bflvalue[i][j].assign(tempbin);
761 shift_left(bflvalue[i][j], bflvalue[i][j], bit_diff);
762 }
763 else
764 bflvalue[i][j].assign(da.s.value[i][j]);
765 is_zero = false;
766 }
767 else
768 bflvalue[i][j].assign_zero();
769 if (is_zero) {
770 da.b.rank--;
771 for (lidia_size_t j = i; j < da.b.rank; j++) {
772 tempP = static_cast<void *>(bflvalue[j]);
773 bflvalue[j] = bflvalue[j+1];
774 bflvalue[j+1] = static_cast<bigfloat *>(tempP);
775 tempP = static_cast<void *>(da.s.value[j]);
776 da.s.value[j] = da.s.value[j+1];
777 da.s.value[j+1] = static_cast<bigint *>(tempP);
778 }
779 }
780 else
781 i++;
782 }
783 }
784
785
786
787 template <>
788 inline bool
E_convert_vector_A(dense_alg<bigint> & da,bigfloat ** bflvalue,const lidia_size_t k)789 gensys_modules< bigint, bigfloat, Normal >::E_convert_vector_A (dense_alg< bigint > & da,
790 bigfloat** bflvalue,
791 const lidia_size_t k)
792 {
793 is_zero = true;
794 for (lidia_size_t i = 0; i < da.b.columns; i++)
795 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
796 bi_bit_len = da.s.value[k][i].bit_length();
797 if (bi_bit_len > da.d.cut_bit_prec) {
798 bit_diff = bi_bit_len-da.d.cut_bit_prec;
799 shift_right(tempbin, da.s.value[k][i], bit_diff);
800 bflvalue[k][i].assign(tempbin);
801 shift_left(bflvalue[k][i], bflvalue[k][i], bit_diff);
802 }
803 else
804 bflvalue[k][i].assign(da.s.value[k][i]);
805 is_zero = false;
806 }
807 else
808 bflvalue[k][i].assign_zero();
809 if (is_zero) {
810 da.b.rank--;
811 for (lidia_size_t i = k; i < da.b.rank; i++) {
812 tempP = static_cast<void *>(bflvalue[i]);
813 bflvalue[i] = bflvalue[i+1];
814 bflvalue[i+1] = static_cast<bigfloat *>(tempP);
815 tempP = static_cast<void *>(da.s.value[i]);
816 da.s.value[i] = da.s.value[i+1];
817 da.s.value[i+1] = static_cast<bigint *>(tempP);
818 }
819 return(true);
820 }
821 return(false);
822 }
823
824
825
826 //
827 // End of
828 // * base_modules < bigint, {double, xdouble, bigfloat}, Normal >
829 // * basis_modules < bigint, {double, xdouble, bigfloat}, Normal >
830 // * gensys_modules < bigint, {double, xdouble, bigfloat}, Normal >
831 //
832
833 //
834 // Code for
835 // * base_modules < bigint, {double, xdouble, bigfloat}, VariationI >
836 // * basis_modules < bigint, {double, xdouble, bigfloat}, VariationI >
837 // * gensys_modules < bigint, {double, xdouble, bigfloat}, VariationI >
838 //
839 template <>
840 inline void
E_convert_value_A(dense_alg<bigint> & da,double & d,const bigint & bin)841 base_modules< bigint, double, VariationI >::E_convert_value_A (dense_alg< bigint > & da,
842 double& d,
843 const bigint& bin)
844 {
845 tempbfl.assign(bin);
846 shift_right(tempbfl, tempbfl, da.d.bit_factor);
847 tempbfl.doublify(d);
848 }
849
850
851
852 template <>
853 inline bool
A_convert_value_E_bound(dense_alg<bigint> &,bigint & bin,const double & dbl,const double & bound)854 base_modules< bigint, double, VariationI >::A_convert_value_E_bound (dense_alg< bigint > &,
855 bigint& bin,
856 const double& dbl,
857 const double& bound)
858 {
859 if (fabs(dbl) > bound) {
860 tempbfl.assign(dbl);
861 tempbfl.bigintify(bin);
862 return (true);
863 }
864 else {
865 bin.assign(static_cast<sdigit>(dbl));
866 return (false);
867 }
868 }
869
870
871
872 template <>
873 inline void
E_convert_value_A(dense_alg<bigint> & da,xdouble & xd,const bigint & bin)874 base_modules< bigint, xdouble, VariationI >::E_convert_value_A (dense_alg< bigint > & da,
875 xdouble& xd,
876 const bigint& bin)
877 {
878 tempbfl.assign(bin);
879 shift_right(tempbfl, tempbfl, da.d.bit_factor);
880 tempbfl.xdoublify(xd);
881 }
882
883
884
885 template <>
886 inline bool
A_convert_value_E_bound(dense_alg<bigint> &,bigint & bin,const xdouble & xdbl,const xdouble & bound)887 base_modules< bigint, xdouble, VariationI >::A_convert_value_E_bound (dense_alg< bigint > &,
888 bigint& bin,
889 const xdouble& xdbl,
890 const xdouble& bound)
891 {
892 tempbfl.assign(xdbl);
893 tempbfl.bigintify(bin);
894 if (fabs(xdbl) > bound)
895 return (true);
896 return (false);
897 }
898
899
900
901 template <>
902 inline void
E_convert_value_A(dense_alg<bigint> & da,bigfloat & bfl,const bigint & bin)903 base_modules< bigint, bigfloat, VariationI >::E_convert_value_A (dense_alg< bigint > & da,
904 bigfloat& bfl,
905 const bigint& bin)
906 {
907 bi_bit_len = bin.bit_length();
908 if (bi_bit_len > da.d.cut_bit_prec) {
909 bit_diff = bi_bit_len-da.d.cut_bit_prec;
910 shift_right(tempbin, bin, bit_diff);
911 bfl.assign(tempbin);
912 shift_left(bfl, bfl, bit_diff);
913 }
914 else
915 bfl.assign(bin);
916 shift_right(bfl, bfl, da.d.bit_factor);
917 }
918
919
920
921 template <>
922 inline bool
A_convert_value_E_bound(dense_alg<bigint> &,bigint & bin,const bigfloat & bfl,const bigfloat & bound)923 base_modules< bigint, bigfloat, VariationI >::A_convert_value_E_bound (dense_alg< bigint > &,
924 bigint& bin,
925 const bigfloat& bfl,
926 const bigfloat& bound)
927 {
928 bfl.bigintify(bin);
929 if (abs(bfl).compare(bound) > 0)
930 return (true);
931 return (false);
932 }
933
934
935
936 template <>
937 inline void
E_convert_lattice_A(dense_alg<bigint> & da,double ** dblvalue)938 basis_modules< bigint, double, VariationI >::E_convert_lattice_A (dense_alg< bigint > & da,
939 double** dblvalue)
940 {
941 for (lidia_size_t i = 0; i < da.b.rows; i++)
942 for (lidia_size_t j = 0; j < da.b.columns; j++) {
943 tempbfl.assign(da.s.value[i][j]);
944 shift_right(tempbfl, tempbfl, da.d.bit_factor);
945 tempbfl.doublify(dblvalue[i][j]);
946 }
947 }
948
949
950
951 template <>
952 inline bool
E_convert_vector_A(dense_alg<bigint> & da,double ** dblvalue,const lidia_size_t k)953 basis_modules< bigint, double, VariationI >::E_convert_vector_A (dense_alg< bigint > & da,
954 double **dblvalue,
955 const lidia_size_t k)
956 {
957 for (lidia_size_t i = 0; i < da.b.columns; i++) {
958 tempbfl.assign(da.s.value[k][i]);
959 shift_right(tempbfl, tempbfl, da.d.bit_factor);
960 tempbfl.doublify(dblvalue[k][i]);
961 }
962 return(false);
963 }
964
965
966
967 template <>
968 inline void
E_convert_lattice_A(dense_alg<bigint> & da,xdouble ** xdblvalue)969 basis_modules< bigint, xdouble, VariationI >::E_convert_lattice_A (dense_alg< bigint > & da,
970 xdouble** xdblvalue)
971 {
972 for (lidia_size_t i = 0; i < da.b.rows; i++)
973 for (lidia_size_t j = 0; j < da.b.columns; j++) {
974 tempbfl.assign(da.s.value[i][j]);
975 shift_right(tempbfl, tempbfl, da.d.bit_factor);
976 tempbfl.xdoublify(xdblvalue[i][j]);
977 }
978 }
979
980
981
982 template <>
983 inline bool
E_convert_vector_A(dense_alg<bigint> & da,xdouble ** xdblvalue,const lidia_size_t k)984 basis_modules< bigint, xdouble, VariationI >::E_convert_vector_A (dense_alg< bigint > & da,
985 xdouble **xdblvalue,
986 const lidia_size_t k)
987 {
988 for (lidia_size_t i = 0; i < da.b.columns; i++) {
989 tempbfl.assign(da.s.value[k][i]);
990 shift_right(tempbfl, tempbfl, da.d.bit_factor);
991 tempbfl.xdoublify(xdblvalue[k][i]);
992 }
993 return(false);
994 }
995
996
997
998 template <>
999 inline void
E_convert_lattice_A(dense_alg<bigint> & da,bigfloat ** bflvalue)1000 basis_modules< bigint, bigfloat, VariationI >::E_convert_lattice_A (dense_alg< bigint > & da,
1001 bigfloat** bflvalue)
1002 {
1003 for (lidia_size_t i = 0; i < da.b.rows; i++)
1004 for (lidia_size_t j = 0; j < da.b.columns; j++) {
1005 bi_bit_len = da.s.value[i][j].bit_length();
1006 if (bi_bit_len > da.d.cut_bit_prec) {
1007 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1008 shift_right(tempbin, da.s.value[i][j], bit_diff);
1009 bflvalue[i][j].assign(tempbin);
1010 shift_left(bflvalue[i][j], bflvalue[i][j], bit_diff);
1011 }
1012 else
1013 bflvalue[i][j].assign(da.s.value[i][j]);
1014 shift_right(bflvalue[i][j], bflvalue[i][j], da.d.bit_factor);
1015 }
1016 }
1017
1018
1019
1020 template <>
1021 inline bool
E_convert_vector_A(dense_alg<bigint> & da,bigfloat ** bflvalue,const lidia_size_t k)1022 basis_modules< bigint, bigfloat, VariationI >::E_convert_vector_A (dense_alg< bigint > & da,
1023 bigfloat** bflvalue,
1024 const lidia_size_t k)
1025 {
1026 for (lidia_size_t i = 0; i < da.b.columns; i++) {
1027 bi_bit_len = da.s.value[k][i].bit_length();
1028 if (bi_bit_len > da.d.cut_bit_prec) {
1029 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1030 shift_right(tempbin, da.s.value[k][i], bit_diff);
1031 bflvalue[k][i].assign(tempbin);
1032 shift_left(bflvalue[k][i], bflvalue[k][i], bit_diff);
1033 }
1034 else
1035 bflvalue[k][i].assign(da.s.value[k][i]);
1036 shift_right(bflvalue[k][i], bflvalue[k][i], da.d.bit_factor);
1037 }
1038 return (false);
1039 }
1040
1041
1042
1043 template <>
1044 inline void
E_convert_lattice_A(dense_alg<bigint> & da,double ** dblvalue)1045 gensys_modules< bigint, double, VariationI >::E_convert_lattice_A (dense_alg< bigint > & da,
1046 double** dblvalue)
1047 {
1048 for (lidia_size_t i = 0; i < da.b.rank;) {
1049 is_zero = true;
1050 for (lidia_size_t j = 0; j < da.b.columns; j++)
1051 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
1052 tempbfl.assign(da.s.value[i][j]);
1053 shift_right(tempbfl, tempbfl, da.d.bit_factor);
1054 tempbfl.doublify(dblvalue[i][j]);
1055 is_zero = false;
1056 }
1057 else
1058 dblvalue[i][j] = 0.0;
1059 if (is_zero) {
1060 da.b.rank--;
1061 for (lidia_size_t j = i; j < da.b.rank; j++) {
1062 tempP = static_cast<void *>(dblvalue[j]);
1063 dblvalue[j] = dblvalue[j+1];
1064 dblvalue[j+1] = static_cast<double *>(tempP);
1065 tempP = static_cast<void *>(da.s.value[j]);
1066 da.s.value[j] = da.s.value[j+1];
1067 da.s.value[j+1] = static_cast<bigint *>(tempP);
1068 }
1069 }
1070 else
1071 i++;
1072 }
1073 }
1074
1075
1076
1077 template <>
1078 inline bool
E_convert_vector_A(dense_alg<bigint> & da,double ** dblvalue,const lidia_size_t k)1079 gensys_modules< bigint, double, VariationI >::E_convert_vector_A (dense_alg< bigint > & da,
1080 double** dblvalue,
1081 const lidia_size_t k)
1082 {
1083 is_zero = true;
1084 for (lidia_size_t i = 0; i < da.b.columns; i++)
1085 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
1086 tempbfl.assign(da.s.value[k][i]);
1087 shift_right(tempbfl, tempbfl, da.d.bit_factor);
1088 tempbfl.doublify(dblvalue[k][i]);
1089 is_zero = false;
1090 }
1091 else
1092 dblvalue[k][i] = 0.0;
1093 if (is_zero) {
1094 da.b.rank--;
1095 for (lidia_size_t i = k; i < da.b.rank; i++) {
1096 tempP = static_cast<void *>(dblvalue[i]);
1097 dblvalue[i] = dblvalue[i+1];
1098 dblvalue[i+1] = static_cast<double *>(tempP);
1099 tempP = static_cast<void *>(da.s.value[i]);
1100 da.s.value[i] = da.s.value[i+1];
1101 da.s.value[i+1] = static_cast<bigint *>(tempP);
1102 }
1103 return(true);
1104 }
1105 return(false);
1106 }
1107
1108
1109
1110 template <>
1111 inline void
E_convert_lattice_A(dense_alg<bigint> & da,xdouble ** xdblvalue)1112 gensys_modules< bigint, xdouble, VariationI >::E_convert_lattice_A (dense_alg< bigint > & da,
1113 xdouble** xdblvalue)
1114 {
1115 for (lidia_size_t i = 0; i < da.b.rank;) {
1116 is_zero = true;
1117 for (lidia_size_t j = 0; j < da.b.columns; j++)
1118 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
1119 tempbfl.assign(da.s.value[i][j]);
1120 shift_right(tempbfl, tempbfl, da.d.bit_factor);
1121 tempbfl.xdoublify(xdblvalue[i][j]);
1122 is_zero = false;
1123 }
1124 else
1125 xdblvalue[i][j] = 0.0;
1126 if (is_zero) {
1127 da.b.rank--;
1128 for (lidia_size_t j = i; j < da.b.rank; j++) {
1129 tempP = static_cast<void *>(xdblvalue[j]);
1130 xdblvalue[j] = xdblvalue[j+1];
1131 xdblvalue[j+1] = static_cast<xdouble *>(tempP);
1132 tempP = static_cast<void *>(da.s.value[j]);
1133 da.s.value[j] = da.s.value[j+1];
1134 da.s.value[j+1] = static_cast<bigint *>(tempP);
1135 }
1136 }
1137 else
1138 i++;
1139 }
1140 }
1141
1142
1143
1144 template <>
1145 inline bool
E_convert_vector_A(dense_alg<bigint> & da,xdouble ** xdblvalue,const lidia_size_t k)1146 gensys_modules< bigint, xdouble, VariationI >::E_convert_vector_A (dense_alg< bigint > & da,
1147 xdouble** xdblvalue,
1148 const lidia_size_t k)
1149 {
1150 is_zero = true;
1151 for (lidia_size_t i = 0; i < da.b.columns; i++)
1152 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
1153 tempbfl.assign(da.s.value[k][i]);
1154 shift_right(tempbfl, tempbfl, da.d.bit_factor);
1155 tempbfl.xdoublify(xdblvalue[k][i]);
1156 is_zero = false;
1157 }
1158 else
1159 xdblvalue[k][i] = 0.0;
1160 if (is_zero) {
1161 da.b.rank--;
1162 for (lidia_size_t i = k; i < da.b.rank; i++) {
1163 tempP = static_cast<void *>(xdblvalue[i]);
1164 xdblvalue[i] = xdblvalue[i+1];
1165 xdblvalue[i+1] = static_cast<xdouble *>(tempP);
1166 tempP = static_cast<void *>(da.s.value[i]);
1167 da.s.value[i] = da.s.value[i+1];
1168 da.s.value[i+1] = static_cast<bigint *>(tempP);
1169 }
1170 return(true);
1171 }
1172 return(false);
1173 }
1174
1175
1176
1177 template <>
1178 inline void
E_convert_lattice_A(dense_alg<bigint> & da,bigfloat ** bflvalue)1179 gensys_modules< bigint, bigfloat, VariationI >::E_convert_lattice_A (dense_alg< bigint > & da,
1180 bigfloat** bflvalue)
1181 {
1182 for (lidia_size_t i = 0; i < da.b.rank;) {
1183 is_zero = true;
1184 for (lidia_size_t j = 0; j < da.b.columns; j++)
1185 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
1186 bi_bit_len = da.s.value[i][j].bit_length();
1187 if (bi_bit_len > da.d.cut_bit_prec) {
1188 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1189 shift_right(tempbin, da.s.value[i][j], bit_diff);
1190 bflvalue[i][j].assign(tempbin);
1191 shift_left(bflvalue[i][j], bflvalue[i][j], bit_diff);
1192 }
1193 else
1194 bflvalue[i][j].assign(da.s.value[i][j]);
1195 shift_right(bflvalue[i][j], bflvalue[i][j], da.d.bit_factor);
1196 is_zero = false;
1197 }
1198 else
1199 bflvalue[i][j].assign_zero();
1200 if (is_zero) {
1201 da.b.rank--;
1202 for (lidia_size_t j = i; j < da.b.rank; j++) {
1203 tempP = static_cast<void *>(bflvalue[j]);
1204 bflvalue[j] = bflvalue[j+1];
1205 bflvalue[j+1] = static_cast<bigfloat *>(tempP);
1206 tempP = static_cast<void *>(da.s.value[j]);
1207 da.s.value[j] = da.s.value[j+1];
1208 da.s.value[j+1] = static_cast<bigint *>(tempP);
1209 }
1210 }
1211 else
1212 i++;
1213 }
1214 }
1215
1216
1217
1218 template <>
1219 inline bool
E_convert_vector_A(dense_alg<bigint> & da,bigfloat ** bflvalue,const lidia_size_t k)1220 gensys_modules< bigint, bigfloat, VariationI >::E_convert_vector_A (dense_alg< bigint > & da,
1221 bigfloat** bflvalue,
1222 const lidia_size_t k)
1223 {
1224 is_zero = true;
1225 for (lidia_size_t i = 0; i < da.b.columns; i++)
1226 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
1227 bi_bit_len = da.s.value[k][i].bit_length();
1228 if (bi_bit_len > da.d.cut_bit_prec) {
1229 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1230 shift_right(tempbin, da.s.value[k][i], bit_diff);
1231 bflvalue[k][i].assign(tempbin);
1232 shift_left(bflvalue[k][i], bflvalue[k][i], bit_diff);
1233 }
1234 else
1235 bflvalue[k][i].assign(da.s.value[k][i]);
1236 shift_right(bflvalue[k][i], bflvalue[k][i], da.d.bit_factor);
1237 is_zero = false;
1238 }
1239 else
1240 bflvalue[k][i].assign_zero();
1241 if (is_zero) {
1242 da.b.rank--;
1243 for (lidia_size_t i = k; i < da.b.rank; i++) {
1244 tempP = static_cast<void *>(bflvalue[i]);
1245 bflvalue[i] = bflvalue[i+1];
1246 bflvalue[i+1] = static_cast<bigfloat *>(tempP);
1247 tempP = static_cast<void *>(da.s.value[i]);
1248 da.s.value[i] = da.s.value[i+1];
1249 da.s.value[i+1] = static_cast<bigint *>(tempP);
1250 }
1251 return(true);
1252 }
1253 return(false);
1254 }
1255
1256
1257
1258 //
1259 // End of
1260 // * base_modules < bigint, {double, xdouble, bigfloat}, VariationI >
1261 // * basis_modules < bigint, {double, xdouble, bigfloat}, VariationI >
1262 // * gensys_modules < bigint, {double, xdouble, bigfloat}, VariationI >
1263 //
1264
1265 //
1266 // Code for
1267 // * base_modules < bigfloat, {double, xdouble, bigfloat}, Normal >
1268 // * basis_modules < bigfloat, {double, xdouble, bigfloat}, Normal >
1269 // * gensys_modules < bigfloat, {double, xdouble, bigfloat}, Normal >
1270 //
1271 template <>
1272 inline void
E_convert_value_A(dense_alg<bigfloat> &,double & d,const bigfloat & bfl)1273 base_modules< bigfloat, double, Normal >::E_convert_value_A (dense_alg< bigfloat > &,
1274 double& d,
1275 const bigfloat& bfl)
1276 {
1277 bfl.doublify(d);
1278 }
1279
1280
1281
1282 template <>
1283 inline bool
A_convert_value_E_bound(dense_alg<bigfloat> &,bigfloat & bfl,const double & dbl,const double & bound)1284 base_modules< bigfloat, double, Normal >::A_convert_value_E_bound (dense_alg< bigfloat > &,
1285 bigfloat& bfl,
1286 const double& dbl,
1287 const double& bound)
1288 {
1289 if (fabs(dbl) > bound) {
1290 bfl.assign(dbl);
1291 return (true);
1292 }
1293 else {
1294 bfl.assign(static_cast<sdigit>(dbl));
1295 return (false);
1296 }
1297 }
1298
1299
1300
1301 template <>
1302 inline void
E_convert_value_A(dense_alg<bigfloat> &,xdouble & xd,const bigfloat & bfl)1303 base_modules< bigfloat, xdouble, Normal >::E_convert_value_A (dense_alg< bigfloat > &,
1304 xdouble& xd,
1305 const bigfloat& bfl)
1306 {
1307 bfl.xdoublify(xd);
1308 }
1309
1310
1311
1312 template <>
1313 inline bool
A_convert_value_E_bound(dense_alg<bigfloat> &,bigfloat & bfl,const xdouble & xdbl,const xdouble & bound)1314 base_modules< bigfloat, xdouble, Normal >::A_convert_value_E_bound (dense_alg< bigfloat > &,
1315 bigfloat& bfl,
1316 const xdouble& xdbl,
1317 const xdouble& bound)
1318 {
1319 bfl.assign(xdbl);
1320 if (fabs(xdbl) > bound)
1321 return (true);
1322 return (false);
1323 }
1324
1325
1326
1327 template <>
1328 inline void
E_convert_value_A(dense_alg<bigfloat> & da,bigfloat & bfla,const bigfloat & bfl)1329 base_modules< bigfloat, bigfloat, Normal >::E_convert_value_A (dense_alg< bigfloat > & da,
1330 bigfloat& bfla,
1331 const bigfloat& bfl)
1332 {
1333 bigfloat::set_precision(da.d.approx_prec);
1334 mant.assign(bfl.mantissa());
1335 expo = bfl.exponent();
1336 bi_bit_len = mant.bit_length();
1337 if (bi_bit_len > da.d.cut_bit_prec) {
1338 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1339 shift_right(mant, mant, bit_diff);
1340 bfla.assign(mant);
1341 shift_left(bfla, bfla, bit_diff);
1342 }
1343 else
1344 bfla.assign(mant);
1345 shift_left(bfla, bfla, expo);
1346 bigfloat::set_precision(da.d.exact_prec);
1347 }
1348
1349
1350
1351 template <>
1352 inline bool
A_convert_value_E_bound(dense_alg<bigfloat> &,bigfloat & bfla,const bigfloat & bfl,const bigfloat & bound)1353 base_modules< bigfloat, bigfloat, Normal >::A_convert_value_E_bound (dense_alg< bigfloat > &,
1354 bigfloat& bfla,
1355 const bigfloat& bfl,
1356 const bigfloat& bound)
1357 {
1358 bfla.assign(bfl);
1359 if (abs(bfl).compare(bound) > 0)
1360 return (true);
1361 return (false);
1362 }
1363
1364
1365
1366 template <>
1367 inline void
E_convert_lattice_A(dense_alg<bigfloat> & da,double ** dblvalue)1368 basis_modules< bigfloat, double, Normal >::E_convert_lattice_A (dense_alg< bigfloat > & da,
1369 double** dblvalue)
1370 {
1371 for (lidia_size_t i = 0; i < da.b.rows; i++)
1372 for (lidia_size_t j = 0; j < da.b.columns; j++)
1373 da.s.value[i][j].doublify(dblvalue[i][j]);
1374 }
1375
1376
1377
1378 template <>
1379 inline bool
E_convert_vector_A(dense_alg<bigfloat> & da,double ** dblvalue,const lidia_size_t k)1380 basis_modules< bigfloat, double, Normal >::E_convert_vector_A (dense_alg< bigfloat > & da,
1381 double **dblvalue,
1382 const lidia_size_t k)
1383 {
1384 for (lidia_size_t i = 0; i < da.b.columns; i++)
1385 da.s.value[k][i].doublify(dblvalue[k][i]);
1386 return(false);
1387 }
1388
1389
1390
1391 template <>
1392 inline void
E_convert_lattice_A(dense_alg<bigfloat> & da,xdouble ** xdblvalue)1393 basis_modules< bigfloat, xdouble, Normal >::E_convert_lattice_A (dense_alg< bigfloat > & da,
1394 xdouble** xdblvalue)
1395 {
1396 for (lidia_size_t i = 0; i < da.b.rows; i++)
1397 for (lidia_size_t j = 0; j < da.b.columns; j++)
1398 da.s.value[i][j].xdoublify(xdblvalue[i][j]);
1399 }
1400
1401
1402
1403 template <>
1404 inline bool
E_convert_vector_A(dense_alg<bigfloat> & da,xdouble ** xdblvalue,const lidia_size_t k)1405 basis_modules< bigfloat, xdouble, Normal >::E_convert_vector_A (dense_alg< bigfloat > & da,
1406 xdouble **xdblvalue,
1407 const lidia_size_t k)
1408 {
1409 for (lidia_size_t i = 0; i < da.b.columns; i++)
1410 da.s.value[k][i].xdoublify(xdblvalue[k][i]);
1411 return(false);
1412 }
1413
1414
1415
1416 template <>
1417 inline void
E_convert_lattice_A(dense_alg<bigfloat> & da,bigfloat ** bflvalue)1418 basis_modules< bigfloat, bigfloat, Normal >::E_convert_lattice_A (dense_alg< bigfloat > & da,
1419 bigfloat** bflvalue)
1420 {
1421 bigfloat::set_precision(da.d.approx_prec);
1422 for (lidia_size_t i = 0; i < da.b.rows; i++)
1423 for (lidia_size_t j = 0; j < da.b.columns; j++) {
1424 mant.assign(da.s.value[i][j].mantissa());
1425 expo = da.s.value[i][j].exponent();
1426 bi_bit_len = mant.bit_length();
1427 if (bi_bit_len > da.d.cut_bit_prec) {
1428 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1429 shift_right(mant, mant, bit_diff);
1430 bflvalue[i][j].assign(mant);
1431 shift_left(bflvalue[i][j], bflvalue[i][j], bit_diff);
1432 }
1433 else
1434 bflvalue[i][j].assign(mant);
1435 shift_left(bflvalue[i][j], bflvalue[i][j], expo);
1436 }
1437 bigfloat::set_precision(da.d.exact_prec);
1438 }
1439
1440
1441
1442 template <>
1443 inline bool
E_convert_vector_A(dense_alg<bigfloat> & da,bigfloat ** bflvalue,const lidia_size_t k)1444 basis_modules< bigfloat, bigfloat, Normal >::E_convert_vector_A (dense_alg< bigfloat > & da,
1445 bigfloat** bflvalue,
1446 const lidia_size_t k)
1447 {
1448 bigfloat::set_precision(da.d.approx_prec);
1449 for (lidia_size_t i = 0; i < da.b.columns; i++) {
1450 mant.assign(da.s.value[k][i].mantissa());
1451 expo = da.s.value[k][i].exponent();
1452 bi_bit_len = mant.bit_length();
1453 if (bi_bit_len > da.d.cut_bit_prec) {
1454 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1455 shift_right(mant, mant, bit_diff);
1456 bflvalue[k][i].assign(mant);
1457 shift_left(bflvalue[k][i], bflvalue[k][i], bit_diff);
1458 }
1459 else
1460 bflvalue[k][i].assign(mant);
1461 shift_left(bflvalue[k][i], bflvalue[k][i], expo);
1462 }
1463 bigfloat::set_precision(da.d.exact_prec);
1464 return (false);
1465 }
1466
1467
1468
1469 template <>
1470 inline void
E_convert_lattice_A(dense_alg<bigfloat> & da,double ** dblvalue)1471 gensys_modules< bigfloat, double, Normal >::E_convert_lattice_A (dense_alg< bigfloat > & da,
1472 double** dblvalue)
1473 {
1474 for (lidia_size_t i = 0; i < da.b.rank;) {
1475 is_zero = true;
1476 for (lidia_size_t j = 0; j < da.b.columns; j++)
1477 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
1478 da.s.value[i][j].doublify(dblvalue[i][j]);
1479 is_zero = false;
1480 }
1481 else
1482 dblvalue[i][j] = 0.0;
1483 if (is_zero) {
1484 da.b.rank--;
1485 for (lidia_size_t j = i; j < da.b.rank; j++) {
1486 tempP = static_cast<void *>(dblvalue[j]);
1487 dblvalue[j] = dblvalue[j+1];
1488 dblvalue[j+1] = static_cast<double *>(tempP);
1489 tempP = static_cast<void *>(da.s.value[j]);
1490 da.s.value[j] = da.s.value[j+1];
1491 da.s.value[j+1] = static_cast<bigfloat *>(tempP);
1492 }
1493 }
1494 else
1495 i++;
1496 }
1497 }
1498
1499
1500
1501 template <>
1502 inline bool
E_convert_vector_A(dense_alg<bigfloat> & da,double ** dblvalue,const lidia_size_t k)1503 gensys_modules< bigfloat, double, Normal >::E_convert_vector_A (dense_alg< bigfloat > & da,
1504 double** dblvalue,
1505 const lidia_size_t k)
1506 {
1507 is_zero = true;
1508 for (lidia_size_t i = 0; i < da.b.columns; i++)
1509 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
1510 da.s.value[k][i].doublify(dblvalue[k][i]);
1511 is_zero = false;
1512 }
1513 else
1514 dblvalue[k][i] = 0.0;
1515 if (is_zero) {
1516 da.b.rank--;
1517 for (lidia_size_t i = k; i < da.b.rank; i++) {
1518 tempP = static_cast<void *>(dblvalue[i]);
1519 dblvalue[i] = dblvalue[i+1];
1520 dblvalue[i+1] = static_cast<double *>(tempP);
1521 tempP = static_cast<void *>(da.s.value[i]);
1522 da.s.value[i] = da.s.value[i+1];
1523 da.s.value[i+1] = static_cast<bigfloat *>(tempP);
1524 }
1525 return(true);
1526 }
1527 return(false);
1528 }
1529
1530
1531
1532 template <>
1533 inline void
E_convert_lattice_A(dense_alg<bigfloat> & da,xdouble ** xdblvalue)1534 gensys_modules< bigfloat, xdouble, Normal >::E_convert_lattice_A (dense_alg< bigfloat > & da,
1535 xdouble** xdblvalue)
1536 {
1537 for (lidia_size_t i = 0; i < da.b.rank;) {
1538 is_zero = true;
1539 for (lidia_size_t j = 0; j < da.b.columns; j++)
1540 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
1541 da.s.value[i][j].xdoublify(xdblvalue[i][j]);
1542 is_zero = false;
1543 }
1544 else
1545 xdblvalue[i][j] = 0.0;
1546 if (is_zero) {
1547 da.b.rank--;
1548 for (lidia_size_t j = i; j < da.b.rank; j++) {
1549 tempP = static_cast<void *>(xdblvalue[j]);
1550 xdblvalue[j] = xdblvalue[j+1];
1551 xdblvalue[j+1] = static_cast<xdouble *>(tempP);
1552 tempP = static_cast<void *>(da.s.value[j]);
1553 da.s.value[j] = da.s.value[j+1];
1554 da.s.value[j+1] = static_cast<bigfloat *>(tempP);
1555 }
1556 }
1557 else
1558 i++;
1559 }
1560 }
1561
1562
1563
1564 template <>
1565 inline bool
E_convert_vector_A(dense_alg<bigfloat> & da,xdouble ** xdblvalue,const lidia_size_t k)1566 gensys_modules< bigfloat, xdouble, Normal >::E_convert_vector_A (dense_alg< bigfloat > & da,
1567 xdouble** xdblvalue,
1568 const lidia_size_t k)
1569 {
1570 is_zero = true;
1571 for (lidia_size_t i = 0; i < da.b.columns; i++)
1572 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
1573 da.s.value[k][i].xdoublify(xdblvalue[k][i]);
1574 is_zero = false;
1575 }
1576 else
1577 xdblvalue[k][i] = 0.0;
1578 if (is_zero) {
1579 da.b.rank--;
1580 for (lidia_size_t i = k; i < da.b.rank; i++) {
1581 tempP = static_cast<void *>(xdblvalue[i]);
1582 xdblvalue[i] = xdblvalue[i+1];
1583 xdblvalue[i+1] = static_cast<xdouble *>(tempP);
1584 tempP = static_cast<void *>(da.s.value[i]);
1585 da.s.value[i] = da.s.value[i+1];
1586 da.s.value[i+1] = static_cast<bigfloat *>(tempP);
1587 }
1588 return(true);
1589 }
1590 return(false);
1591 }
1592
1593
1594
1595 template <>
1596 inline void
E_convert_lattice_A(dense_alg<bigfloat> & da,bigfloat ** bflvalue)1597 gensys_modules< bigfloat, bigfloat, Normal >::E_convert_lattice_A (dense_alg< bigfloat > & da,
1598 bigfloat** bflvalue)
1599 {
1600 bigfloat::set_precision(da.d.approx_prec);
1601 for (lidia_size_t i = 0; i < da.b.rank;) {
1602 is_zero = true;
1603 for (lidia_size_t j = 0; j < da.b.columns; j++)
1604 if ((!is_zero) || (!da.s.value[i][j].is_zero())) {
1605 mant.assign(da.s.value[i][j].mantissa());
1606 expo = da.s.value[i][j].exponent();
1607 bi_bit_len = mant.bit_length();
1608 if (bi_bit_len > da.d.cut_bit_prec) {
1609 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1610 shift_right(mant, mant, bit_diff);
1611 bflvalue[i][j].assign(mant);
1612 shift_left(bflvalue[i][j], bflvalue[i][j], bit_diff);
1613 }
1614 else
1615 bflvalue[i][j].assign(mant);
1616 shift_left(bflvalue[i][j], bflvalue[i][j], expo);
1617 is_zero = false;
1618 }
1619 else
1620 bflvalue[i][j].assign_zero();
1621 if (is_zero) {
1622 da.b.rank--;
1623 for (lidia_size_t j = i; j < da.b.rank; j++) {
1624 tempP = static_cast<void *>(bflvalue[j]);
1625 bflvalue[j] = bflvalue[j+1];
1626 bflvalue[j+1] = static_cast<bigfloat *>(tempP);
1627 tempP = static_cast<void *>(da.s.value[j]);
1628 da.s.value[j] = da.s.value[j+1];
1629 da.s.value[j+1] = static_cast<bigfloat *>(tempP);
1630 }
1631 }
1632 else
1633 i++;
1634 }
1635 bigfloat::set_precision(da.d.exact_prec);
1636 }
1637
1638
1639
1640 template <>
1641 inline bool
E_convert_vector_A(dense_alg<bigfloat> & da,bigfloat ** bflvalue,const lidia_size_t k)1642 gensys_modules< bigfloat, bigfloat, Normal >::E_convert_vector_A (dense_alg< bigfloat > & da,
1643 bigfloat** bflvalue,
1644 const lidia_size_t k)
1645 {
1646 bigfloat::set_precision(da.d.approx_prec);
1647 is_zero = true;
1648 for (lidia_size_t i = 0; i < da.b.columns; i++)
1649 if ((!is_zero) || (!da.s.value[k][i].is_zero())) {
1650 mant.assign(da.s.value[k][i].mantissa());
1651 expo = da.s.value[k][i].exponent();
1652 bi_bit_len = mant.bit_length();
1653 if (bi_bit_len > da.d.cut_bit_prec) {
1654 bit_diff = bi_bit_len-da.d.cut_bit_prec;
1655 shift_right(mant, mant, bit_diff);
1656 bflvalue[k][i].assign(mant);
1657 shift_left(bflvalue[k][i], bflvalue[k][i], bit_diff);
1658 }
1659 else
1660 bflvalue[k][i].assign(mant);
1661 shift_left(bflvalue[k][i], bflvalue[k][i], expo);
1662 is_zero = false;
1663 }
1664 else
1665 bflvalue[k][i].assign_zero();
1666 if (is_zero) {
1667 da.b.rank--;
1668 for (lidia_size_t i = k; i < da.b.rank; i++) {
1669 tempP = static_cast<void *>(bflvalue[i]);
1670 bflvalue[i] = bflvalue[i+1];
1671 bflvalue[i+1] = static_cast<bigfloat *>(tempP);
1672 tempP = static_cast<void *>(da.s.value[i]);
1673 da.s.value[i] = da.s.value[i+1];
1674 da.s.value[i+1] = static_cast<bigfloat *>(tempP);
1675 }
1676 bigfloat::set_precision(da.d.exact_prec);
1677 return(true);
1678 }
1679 bigfloat::set_precision(da.d.exact_prec);
1680 return(false);
1681 }
1682
1683
1684
1685 //
1686 // End of
1687 // * base_modules < bigfloat, {double, xdouble, bigfloat}, Normal >
1688 // * basis_modules < bigfloat, {double, xdouble, bigfloat}, Normal >
1689 // * gensys_modules < bigfloat, {double, xdouble, bigfloat}, Normal >
1690 //
1691
1692
1693
1694 #ifdef LIDIA_NAMESPACE
1695 # ifndef IN_NAMESPACE_LIDIA
1696 } // end of namespace LiDIA
1697 # endif
1698 #endif
1699
1700
1701
1702 #endif // LIDIA_LATTICE_MODULES_CC_GUARD_
1703