1/*****************************************************************************
2
3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4 more contributor license agreements. See the NOTICE file distributed
5 with this work for additional information regarding copyright ownership.
6 Accellera licenses this file to you under the Apache License, Version 2.0
7 (the "License"); you may not use this file except in compliance with the
8 License. You may obtain a copy of the License at
9
10 http://www.apache.org/licenses/LICENSE-2.0
11
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15 implied. See the License for the specific language governing
16 permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22 sc_nbcommon.cpp -- Functions common to both sc_signed and sc_unsigned.
23 This file is included in sc_signed.cpp and
24 sc_unsigned.cpp after the macros are defined accordingly.
25 For example, sc_signed.cpp will first define CLASS_TYPE
26 as sc_signed before including this file. This file like
27 sc_nbfriends.cpp and sc_nbexterns.cpp is created in order
28 to ensure only one version of each function, regardless
29 of the class that they interface to.
30
31 Original Author: Ali Dasdan, Synopsys, Inc.
32
33 *****************************************************************************/
34
35/*****************************************************************************
36
37 MODIFICATION LOG - modifiers, enter your name, affiliation, date and
38 changes you are making here.
39
40 Name, Affiliation, Date:
41 Description of Modification:
42
43 *****************************************************************************/
44
45
46// ----------------------------------------------------------------------------
47// SECTION : Public members
48// ----------------------------------------------------------------------------
49
50// Create a CLASS_TYPE number with nb bits.
51CLASS_TYPE::CLASS_TYPE(int nb) :
52 sc_value_base(), sgn(), nbits(), ndigits(), digit()
53{
54 sgn = default_sign();
55 if (nb > 0) {
56 nbits = num_bits(nb);
57 } else {
58 invalid_init("int nb", nb);
59 sc_core::sc_abort(); // can't recover from here
60 }
61 ndigits = DIV_CEIL(nbits);
62#ifdef SC_MAX_NBITS
63 test_bound(nb);
64#else
65 digit = new sc_digit[ndigits];
66#endif
67 makezero();
68}
69
70
71// Create a copy of v with sgn s. v is of the same type.
72CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE &v) :
73 sc_value_base(v), sgn(v.sgn), nbits(v.nbits), ndigits(v.ndigits), digit()
74{
75#ifndef SC_MAX_NBITS
76 digit = new sc_digit[ndigits];
77#endif
78
79 vec_copy(ndigits, digit, v.digit);
80}
81
82
83// Create a copy of v where v is of the different type.
84CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE &v) :
85 sc_value_base(v), sgn(v.sgn), nbits(num_bits(v.nbits)), ndigits(), digit()
86{
87#if (IF_SC_SIGNED == 1)
88 ndigits = v.ndigits;
89#else
90 ndigits = DIV_CEIL(nbits);
91#endif
92
93#ifndef SC_MAX_NBITS
94 digit = new sc_digit[ndigits];
95#endif
96
97 copy_digits(v.nbits, v.ndigits, v.digit);
98}
99
100// Create a copy of v where v is an sign-less instance.
101CLASS_TYPE::CLASS_TYPE(const sc_bv_base &v) :
102 sc_value_base(), sgn(), nbits(), ndigits(), digit()
103{
104 int nb = v.length();
105 sgn = default_sign();
106 if (nb > 0) {
107 nbits = num_bits(nb);
108 } else {
109 invalid_init("sc_bv_base", nb);
110 sc_core::sc_abort(); // can't recover from here
111 }
112 ndigits = DIV_CEIL(nbits);
113# ifdef SC_MAX_NBITS
114 test_bound(nb);
115# else
116 digit = new sc_digit[ndigits];
117# endif
118 makezero();
119 *this = v;
120}
121
122CLASS_TYPE::CLASS_TYPE(const sc_lv_base &v) :
123 sc_value_base(), sgn(), nbits(), ndigits(), digit()
124{
125 int nb = v.length();
126 sgn = default_sign();
127 if (nb > 0) {
128 nbits = num_bits(nb);
129 } else {
130 invalid_init("sc_lv_base", nb);
131 sc_core::sc_abort(); // can't recover from here
132 }
133 ndigits = DIV_CEIL(nbits);
134# ifdef SC_MAX_NBITS
135 test_bound(nb);
136# else
137 digit = new sc_digit[ndigits];
138# endif
139 makezero();
140 *this = v;
141}
142
143CLASS_TYPE::CLASS_TYPE(const sc_int_subref_r &v) :
144 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
145{
146 int nb = v.length();
147 sgn = default_sign();
148 if (nb > 0) {
149 nbits = num_bits(nb);
150 } else {
151 invalid_init("sc_int_subref", nb);
152 sc_core::sc_abort(); // can't recover from here
153 }
154 ndigits = DIV_CEIL(nbits);
155# ifdef SC_MAX_NBITS
156 test_bound(nb);
157# else
158 digit = new sc_digit[ndigits];
159# endif
160 makezero();
161 *this = v.to_uint64();
162}
163
164CLASS_TYPE::CLASS_TYPE(const sc_uint_subref_r &v) :
165 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
166{
167 int nb = v.length();
168 sgn = default_sign();
169 if (nb > 0) {
170 nbits = num_bits(nb);
171 } else {
172 invalid_init("sc_uint_subref", nb);
173 sc_core::sc_abort(); // can't recover from here
174 }
175 ndigits = DIV_CEIL(nbits);
176# ifdef SC_MAX_NBITS
177 test_bound(nb);
178# else
179 digit = new sc_digit[ndigits];
180# endif
181 makezero();
182 *this = v.to_uint64();
183}
184
185CLASS_TYPE::CLASS_TYPE(const sc_signed_subref_r &v) :
186 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
187{
188 int nb = v.length();
189 sgn = default_sign();
190 if (nb > 0) {
191 nbits = num_bits(nb);
192 } else {
193 invalid_init("sc_signed_subref", nb);
194 sc_core::sc_abort(); // can't recover from here
195 }
196 ndigits = DIV_CEIL(nbits);
197# ifdef SC_MAX_NBITS
198 test_bound(nb);
199# else
200 digit = new sc_digit[ndigits];
201# endif
202 makezero();
203 *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
204}
205
206CLASS_TYPE::CLASS_TYPE(const sc_unsigned_subref_r &v) :
207 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
208{
209 int nb = v.length();
210 sgn = default_sign();
211 if (nb > 0) {
212 nbits = num_bits(nb);
213 } else {
214 invalid_init("sc_unsigned_subref", nb);
215 sc_core::sc_abort(); // can't recover from here
216 }
217 ndigits = DIV_CEIL(nbits);
218# ifdef SC_MAX_NBITS
219 test_bound(nb);
220# else
221 digit = new sc_digit[ndigits];
222# endif
223 makezero();
224 *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
225}
226
227// ----------------------------------------------------------------------------
228// SECTION: Public members - Concatenation support.
229// ----------------------------------------------------------------------------
230
231
232// ----------------------------------------------------------------------------
233// SECTION: Public members - Assignment operators.
234// ----------------------------------------------------------------------------
235
236// Assignment from v of the same type.
237const CLASS_TYPE &
238CLASS_TYPE::operator = (const CLASS_TYPE &v)
239{
240 if (this != &v) {
241 sgn = v.sgn;
242
243 if (sgn == SC_ZERO)
244 vec_zero(ndigits, digit);
245 else
246 copy_digits(v.nbits, v.ndigits, v.digit);
247 }
248 return *this;
249}
250
251
252// Assignment from v of the different type.
253const CLASS_TYPE &
254CLASS_TYPE::operator = (const OTHER_CLASS_TYPE &v)
255{
256 sgn = v.sgn;
257
258 if (sgn == SC_ZERO)
259 vec_zero(ndigits, digit);
260 else
261 copy_digits(v.nbits, v.ndigits, v.digit);
262
263 return *this;
264}
265
266
267// Assignment from an sc_unsigned_subref_r
268const CLASS_TYPE &
269CLASS_TYPE::operator = (const sc_unsigned_subref_r &v)
270{
271 return operator=(sc_unsigned(v));
272}
273
274
275// Assignment from an sc_signed_subref_r
276const CLASS_TYPE &
277CLASS_TYPE::operator = (const sc_signed_subref_r &v)
278{
279 return operator = (sc_unsigned(v));
280}
281
282
283// ----------------------------------------------------------------------------
284// SECTION: Input and output operators
285// ----------------------------------------------------------------------------
286
287void
288CLASS_TYPE::scan(::std::istream &is)
289{
290 std::string s;
291 is >> s;
292 *this = s.c_str();
293}
294
295
296// ----------------------------------------------------------------------------
297// SECTION: PLUS operators: +, +=, ++
298// ----------------------------------------------------------------------------
299
300// Cases to consider when computing u + v:
301// 1. 0 + v = v
302// 2. u + 0 = u
303// 3. if sgn(u) == sgn(v)
304// 3.1 u + v = +(u + v) = sgn(u) * (u + v)
305// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
306// 4. if sgn(u) != sgn(v)
307// 4.1 u + (-v) = u - v = sgn(u) * (u - v)
308// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
309//
310// Specialization of above cases for computing ++u or u++:
311// 1. 0 + 1 = 1
312// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
313// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
314
315const CLASS_TYPE &
316CLASS_TYPE::operator += (const CLASS_TYPE &v)
317{
318 // u = *this
319
320 if (sgn == SC_ZERO) // case 1
321 return (*this = v);
322
323 if (v.sgn == SC_ZERO) // case 2
324 return *this;
325
326 // cases 3 and 4
327 add_on_help(sgn, nbits, ndigits, digit,
328 v.sgn, v.nbits, v.ndigits, v.digit);
329
330 convert_SM_to_2C_to_SM();
331
332 return *this;
333}
334
335
336const CLASS_TYPE &
337CLASS_TYPE::operator += (const OTHER_CLASS_TYPE &v)
338{
339 // u = *this
340
341 if (sgn == SC_ZERO) // case 1
342 return (*this = v);
343
344 if (v.sgn == SC_ZERO) // case 2
345 return *this;
346
347 // cases 3 and 4
348 add_on_help(sgn, nbits, ndigits, digit,
349 v.sgn, v.nbits, v.ndigits, v.digit);
350
351 convert_SM_to_2C_to_SM();
352
353 return *this;
354}
355
356
357CLASS_TYPE &
358CLASS_TYPE::operator ++ () // prefix
359{
360 *this = *this + 1;
361 return *this;
362}
363
364
365const CLASS_TYPE
366CLASS_TYPE::operator ++ (int) // postfix
367{
368 // Copy digit into d.
369
370#ifdef SC_MAX_NBITS
371 sc_digit d[MAX_NDIGITS];
372#else
373 sc_digit *d = new sc_digit[ndigits];
374#endif
375
376 small_type s = sgn;
377
378 vec_copy(ndigits, d, digit);
379
380 *this = *this + 1;
381
382 return CLASS_TYPE(s, nbits, ndigits, d);
383}
384
385
386const CLASS_TYPE &
387CLASS_TYPE::operator += (int64 v)
388{
389 // u = *this
390
391 if (sgn == SC_ZERO) // case 1
392 return (*this = v);
393
394 if (v == 0) // case 2
395 return *this;
396
397 CONVERT_INT64(v);
398
399 // cases 3 and 4
400 add_on_help(sgn, nbits, ndigits, digit,
401 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
402
403 convert_SM_to_2C_to_SM();
404
405 return *this;
406}
407
408
409const CLASS_TYPE &
410CLASS_TYPE::operator += (uint64 v)
411{
412 // u = *this
413
414 if (sgn == SC_ZERO) // case 1
415 return (*this = v);
416
417 if (v == 0) // case 2
418 return *this;
419
420 CONVERT_INT64(v);
421
422 // cases 3 and 4
423 add_on_help(sgn, nbits, ndigits, digit,
424 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
425
426 convert_SM_to_2C_to_SM();
427
428 return *this;
429}
430
431
432const CLASS_TYPE &
433CLASS_TYPE::operator += (long v)
434{
435 // u = *this
436
437 if (sgn == SC_ZERO) // case 1
438 return (*this = v);
439
440 if (v == 0) // case 2
441 return *this;
442
443 CONVERT_LONG(v);
444
445 // cases 3 and 4
446 add_on_help(sgn, nbits, ndigits, digit,
447 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
448
449 convert_SM_to_2C_to_SM();
450
451 return *this;
452}
453
454
455const CLASS_TYPE &
456CLASS_TYPE::operator += (unsigned long v)
457{
458 // u = *this
459
460 if (sgn == SC_ZERO) // case 1
461 return (*this = v);
462
463 if (v == 0) // case 2
464 return *this;
465
466 CONVERT_LONG(v);
467
468 // cases 3 and 4
469 add_on_help(sgn, nbits, ndigits, digit,
470 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
471
472 convert_SM_to_2C_to_SM();
473
474 return *this;
475}
476
477
478// ----------------------------------------------------------------------------
479// SECTION: MINUS operators: -, -=, --
480// ----------------------------------------------------------------------------
481
482// Cases to consider when computing u + v:
483// 1. u - 0 = u
484// 2. 0 - v = -v
485// 3. if sgn(u) != sgn(v)
486// 3.1 u - (-v) = u + v = sgn(u) * (u + v)
487// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
488// 4. if sgn(u) == sgn(v)
489// 4.1 u - v = +(u - v) = sgn(u) * (u - v)
490// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
491//
492// Specialization of above cases for computing --u or u--:
493// 1. 0 - 1 = -1
494// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
495// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
496
497const CLASS_TYPE &
498CLASS_TYPE::operator -= (const CLASS_TYPE &v)
499{
500 // u = *this
501 if (v.sgn == SC_ZERO) // case 1
502 return *this;
503 if (sgn == SC_ZERO) { // case 2
504 sgn = -v.sgn;
505 copy_digits(v.nbits, v.ndigits, v.digit);
506 } else {
507 // cases 3 and 4
508 add_on_help(sgn, nbits, ndigits, digit,
509 -v.sgn, v.nbits, v.ndigits, v.digit);
510 convert_SM_to_2C_to_SM();
511 }
512
513 return *this;
514}
515
516
517const CLASS_TYPE &
518CLASS_TYPE::operator -= (const OTHER_CLASS_TYPE &v)
519{
520 // u = *this
521 if (v.sgn == SC_ZERO) // case 1
522 return *this;
523 if (sgn == SC_ZERO) { // case 2
524 sgn = -v.sgn;
525 copy_digits(v.nbits, v.ndigits, v.digit);
526 } else {
527 // cases 3 and 4
528 add_on_help(sgn, nbits, ndigits, digit,
529 -v.sgn, v.nbits, v.ndigits, v.digit);
530
531 convert_SM_to_2C_to_SM();
532 }
533 return *this;
534}
535
536CLASS_TYPE &
537CLASS_TYPE::operator -- () // prefix
538{
539 *this = *this - 1;
540 return *this;
541}
542
543const CLASS_TYPE
544CLASS_TYPE::operator -- (int) // postfix
545{
546 // Copy digit into d.
547#ifdef SC_MAX_NBITS
548 sc_digit d[MAX_NDIGITS];
549#else
550 sc_digit *d = new sc_digit[ndigits];
551#endif
552 small_type s = sgn;
553 vec_copy(ndigits, d, digit);
554 *this = *this - 1;
555 return CLASS_TYPE(s, nbits, ndigits, d);
556}
557
558
559const CLASS_TYPE &
560CLASS_TYPE::operator -= (int64 v)
561{
562 // u = *this
563 if (v == 0) // case 1
564 return *this;
565 if (sgn == SC_ZERO) // case 2
566 return (*this = -v);
567
568 CONVERT_INT64(v);
569
570 // cases 3 and 4
571 add_on_help(sgn, nbits, ndigits, digit,
572 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
573
574 convert_SM_to_2C_to_SM();
575
576 return *this;
577}
578
579
580const CLASS_TYPE &
581CLASS_TYPE::operator -= (uint64 v)
582{
583 // u = *this
584
585 if (v == 0) // case 1
586 return *this;
587
588 int64 v2 = (int64) v;
589
590 if (sgn == SC_ZERO) // case 2
591 return (*this = -v2);
592
593 CONVERT_INT64(v);
594
595 // cases 3 and 4
596 add_on_help(sgn, nbits, ndigits, digit,
597 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
598
599 convert_SM_to_2C_to_SM();
600
601 return *this;
602}
603
604const CLASS_TYPE &
605CLASS_TYPE::operator -= (long v)
606{
607 // u = *this
608
609 if (v == 0) // case 1
610 return *this;
611
612 if (sgn == SC_ZERO) // case 2
613 return (*this = -v);
614
615 CONVERT_LONG(v);
616
617 // cases 3 and 4
618 add_on_help(sgn, nbits, ndigits, digit,
619 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
620
621 convert_SM_to_2C_to_SM();
622
623 return *this;
624}
625
626
627const CLASS_TYPE &
628CLASS_TYPE::operator -= (unsigned long v)
629{
630 // u = *this
631
632 if (v == 0) // case 1
633 return *this;
634
635 long v2 = (long) v;
636
637 if (sgn == SC_ZERO) // case 2
638 return (*this = -v2);
639
640 CONVERT_LONG(v);
641
642 // cases 3 and 4
643 add_on_help(sgn, nbits, ndigits, digit,
644 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
645
646 convert_SM_to_2C_to_SM();
647
648 return *this;
649}
650
651
652// ----------------------------------------------------------------------------
653// SECTION: MULTIPLICATION operators: *, *=
654// ----------------------------------------------------------------------------
655
656// Cases to consider when computing u * v:
657// 1. u * 0 = 0 * v = 0
658// 2. 1 * v = v and -1 * v = -v
659// 3. u * 1 = u and u * -1 = -u
660// 4. u * v = u * v
661
662const CLASS_TYPE &
663CLASS_TYPE::operator *= (const CLASS_TYPE &v)
664{
665 // u = *this
666
667 sgn = mul_signs(sgn, v.sgn);
668
669 if (sgn == SC_ZERO) { // case 1
670 vec_zero(ndigits, digit);
671 } else {
672 // cases 2-4
673 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
674 v.nbits, v.ndigits, v.digit);
675 }
676
677 return *this;
678}
679
680
681const CLASS_TYPE &
682CLASS_TYPE::operator *= (const OTHER_CLASS_TYPE &v)
683{
684 // u = *this
685
686 sgn = mul_signs(sgn, v.sgn);
687
688 if (sgn == SC_ZERO) { // case 1
689 vec_zero(ndigits, digit);
690 } else {
691 // cases 2-4
692 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
693 v.nbits, v.ndigits, v.digit);
694 }
695
696 return *this;
697}
698
699
700const CLASS_TYPE &
701CLASS_TYPE::operator *= (int64 v)
702{
703 // u = *this
704
705 sgn = mul_signs(sgn, get_sign(v));
706
707 if (sgn == SC_ZERO) { // case 1
708 vec_zero(ndigits, digit);
709 } else { // cases 2-4
710 CONVERT_INT64_2(v);
711 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
712 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
713 }
714
715 return *this;
716}
717
718
719const CLASS_TYPE &
720CLASS_TYPE::operator *= (uint64 v)
721{
722 // u = *this
723 sgn = mul_signs(sgn, get_sign(v));
724
725 if (sgn == SC_ZERO) { // case 1
726 vec_zero(ndigits, digit);
727 } else { // cases 2-4
728 CONVERT_INT64_2(v);
729 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
730 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
731 }
732
733 return *this;
734}
735
736
737const CLASS_TYPE &
738CLASS_TYPE::operator *= (long v)
739{
740 // u = *this
741
742 sgn = mul_signs(sgn, get_sign(v));
743
744 if (sgn == SC_ZERO) { // case 1
745 vec_zero(ndigits, digit);
746 } else { // cases 2-4
747 CONVERT_LONG_2(v);
748 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
749 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
750 }
751 return *this;
752}
753
754
755const CLASS_TYPE &
756CLASS_TYPE::operator *= (unsigned long v)
757{
758 // u = *this
759
760 sgn = mul_signs(sgn, get_sign(v));
761
762 if (sgn == SC_ZERO) { // case 1
763 vec_zero(ndigits, digit);
764 } else { // cases 2-4
765 CONVERT_LONG_2(v);
766 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
767 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
768 }
769
770 return *this;
771}
772
773
774// ----------------------------------------------------------------------------
775// SECTION: DIVISION operators: /, /=
776// ----------------------------------------------------------------------------
777
778// Cases to consider when finding the quotient q = floor(u/v):
779// Note that u = q * v + r for r < q.
780// 1. 0 / 0 or u / 0 => error
781// 2. 0 / v => 0 = 0 * v + 0
782// 3. u / v && u = v => u = 1 * u + 0 - u or v can be 1 or -1
783// 4. u / v && u < v => u = 0 * v + u - u can be 1 or -1
784// 5. u / v && u > v => u = q * v + r - v can be 1 or -1
785
786const CLASS_TYPE &
787CLASS_TYPE::operator /= (const CLASS_TYPE &v)
788{
789 sgn = mul_signs(sgn, v.sgn);
790
791 if (sgn == SC_ZERO) {
792 div_by_zero(v.sgn); // case 1
793 vec_zero(ndigits, digit); // case 2
794 } else { // other cases
795 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
796 v.nbits, v.ndigits, v.digit);
797 }
798 return *this;
799}
800
801
802const CLASS_TYPE &
803CLASS_TYPE::operator /= (const OTHER_CLASS_TYPE &v)
804{
805 sgn = mul_signs(sgn, v.sgn);
806
807 if (sgn == SC_ZERO) {
808 div_by_zero(v.sgn); // case 1
809 vec_zero(ndigits, digit); // case 2
810 } else { // other cases
811 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
812 v.nbits, v.ndigits, v.digit);
813 }
814 return *this;
815}
816
817
818const CLASS_TYPE &
819CLASS_TYPE::operator /= (int64 v)
820{
821 // u = *this
822
823 sgn = mul_signs(sgn, get_sign(v));
824
825 if (sgn == SC_ZERO) {
826 div_by_zero(v); // case 1
827 vec_zero(ndigits, digit); // case 2
828 } else {
829 CONVERT_INT64_2(v);
830 // other cases
831 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
832 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
833 }
834 return *this;
835}
836
837
838const CLASS_TYPE &
839CLASS_TYPE::operator /= (uint64 v)
840{
841 // u = *this
842
843 sgn = mul_signs(sgn, get_sign(v));
844
845 if (sgn == SC_ZERO) {
846 div_by_zero(v); // case 1
847 vec_zero(ndigits, digit); // case 2
848 } else {
849 CONVERT_INT64_2(v);
850 // other cases
851 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
852 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
853 }
854 return *this;
855}
856
857
858const CLASS_TYPE &
859CLASS_TYPE::operator /= (long v)
860{
861 // u = *this
862
863 sgn = mul_signs(sgn, get_sign(v));
864
865 if (sgn == SC_ZERO) {
866 div_by_zero(v); // case 1
867 vec_zero(ndigits, digit); // case 2
868 } else {
869 CONVERT_LONG_2(v);
870 // other cases
871 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
872 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
873 }
874 return *this;
875}
876
877
878const CLASS_TYPE &
879CLASS_TYPE::operator /= (unsigned long v)
880{
881 // u = *this
882
883 sgn = mul_signs(sgn, get_sign(v));
884
885 if (sgn == SC_ZERO) {
886 div_by_zero(v); // case 1
887 vec_zero(ndigits, digit); // case 2
888 } else {
889 CONVERT_LONG_2(v);
890 // other cases
891 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
892 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
893 }
894 return *this;
895}
896
897
898// ----------------------------------------------------------------------------
899// SECTION: MOD operators: %, %=.
900// ----------------------------------------------------------------------------
901
902// Cases to consider when finding the remainder r = u % v:
903// Note that u = q * v + r for r < q.
904// 1. 0 % 0 or u % 0 => error
905// 2. 0 % v => 0 = 0 * v + 0
906// 3. u % v && u = v => u = 1 * u + 0 - u or v can be 1 or -1
907// 4. u % v && u < v => u = 0 * v + u - u can be 1 or -1
908// 5. u % v && u > v => u = q * v + r - v can be 1 or -1
909
910const CLASS_TYPE &
911CLASS_TYPE::operator %= (const CLASS_TYPE &v)
912{
913 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
914 div_by_zero(v.sgn); // case 1
915 vec_zero(ndigits, digit); // case 2
916 } else { // other cases
917 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
918 v.nbits, v.ndigits, v.digit);
919 }
920 return *this;
921}
922
923
924const CLASS_TYPE &
925CLASS_TYPE::operator %= (const OTHER_CLASS_TYPE &v)
926{
927 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
928 div_by_zero(v.sgn); // case 1
929 vec_zero(ndigits, digit); // case 2
930 } else { // other cases
931 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
932 v.nbits, v.ndigits, v.digit);
933 }
934
935 return *this;
936}
937
938
939const CLASS_TYPE &
940CLASS_TYPE::operator %= (int64 v)
941{
942 small_type vs = get_sign(v);
943
944 if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
945 div_by_zero(v); // case 1
946 vec_zero(ndigits, digit); // case 2
947 } else {
948 CONVERT_INT64_2(v);
949 // other cases
950 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
951 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
952 }
953 return *this;
954}
955
956
957const CLASS_TYPE &
958CLASS_TYPE::operator %= (uint64 v)
959{
960 if ((sgn == SC_ZERO) || (v == 0)) {
961 div_by_zero(v); // case 1
962 vec_zero(ndigits, digit); // case 2
963 } else {
964 CONVERT_INT64_2(v);
965 // other cases
966 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
967 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
968
969 }
970 return *this;
971}
972
973
974const CLASS_TYPE &
975CLASS_TYPE::operator %= (long v)
976{
977 small_type vs = get_sign(v);
978
979 if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
980 div_by_zero(v); // case 1
981 vec_zero(ndigits, digit); // case 2
982 } else {
983 CONVERT_LONG_2(v);
984 // other cases
985 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
986 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
987 }
988 return *this;
989}
990
991
992const CLASS_TYPE &
993CLASS_TYPE::operator %= (unsigned long v)
994{
995 if ((sgn == SC_ZERO) || (v == 0)) {
996 div_by_zero(v); // case 1
997 vec_zero(ndigits, digit); // case 2
998 } else {
999 CONVERT_LONG_2(v);
1000 // other cases
1001 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
1002 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1003 }
1004 return *this;
1005}
1006
1007
1008// ----------------------------------------------------------------------------
1009// SECTION: Bitwise AND operators: &, &=
1010// ----------------------------------------------------------------------------
1011
1012// Cases to consider when computing u &v:
1013// 1. u & 0 = 0 &v = 0
1014// 2. u &v => sgn = +
1015// 3. (-u) & (-v) => sgn = -
1016// 4. u & (-v) => sgn = +
1017// 5. (-u) &v => sgn = +
1018
1019const CLASS_TYPE &
1020CLASS_TYPE::operator &= (const CLASS_TYPE &v)
1021{
1022 // u = *this
1023 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { // case 1
1024 makezero();
1025 } else { // other cases
1026 and_on_help(sgn, nbits, ndigits, digit,
1027 v.sgn, v.nbits, v.ndigits, v.digit);
1028 convert_2C_to_SM();
1029 }
1030 return *this;
1031}
1032
1033
1034const CLASS_TYPE &
1035CLASS_TYPE::operator &= (const OTHER_CLASS_TYPE &v)
1036{
1037 // u = *this
1038
1039 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { // case 1
1040 makezero();
1041 } else { // other cases
1042 and_on_help(sgn, nbits, ndigits, digit,
1043 v.sgn, v.nbits, v.ndigits, v.digit);
1044 convert_2C_to_SM();
1045 }
1046 return *this;
1047}
1048
1049
1050const CLASS_TYPE &
1051CLASS_TYPE::operator &= (int64 v)
1052{
1053 // u = *this
1054 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1055 makezero();
1056 } else { // other cases
1057 CONVERT_INT64(v);
1058 and_on_help(sgn, nbits, ndigits, digit,
1059 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1060 convert_2C_to_SM();
1061 }
1062 return *this;
1063}
1064
1065
1066const CLASS_TYPE &
1067CLASS_TYPE::operator &= (uint64 v)
1068{
1069 // u = *this
1070 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1071 makezero();
1072 } else { // other cases
1073 CONVERT_INT64(v);
1074 and_on_help(sgn, nbits, ndigits, digit,
1075 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1076 convert_2C_to_SM();
1077 }
1078 return *this;
1079}
1080
1081
1082const CLASS_TYPE &
1083CLASS_TYPE::operator &= (long v)
1084{
1085 // u = *this
1086
1087 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1088 makezero();
1089 } else { // other cases
1090 CONVERT_LONG(v);
1091 and_on_help(sgn, nbits, ndigits, digit,
1092 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1093 convert_2C_to_SM();
1094 }
1095
1096 return *this;
1097}
1098
1099
1100const CLASS_TYPE &
1101CLASS_TYPE::operator &= (unsigned long v)
1102{
1103 // u = *this
1104 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1105 makezero();
1106 } else { // other cases
1107 CONVERT_LONG(v);
1108 and_on_help(sgn, nbits, ndigits, digit,
1109 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1110 convert_2C_to_SM();
1111 }
1112 return *this;
1113}
1114
1115
1116// ----------------------------------------------------------------------------
1117// SECTION: Bitwise OR operators: |, |=
1118// ----------------------------------------------------------------------------
1119
1120// Cases to consider when computing u | v:
1121// 1. u | 0 = u
1122// 2. 0 | v = v
1123// 3. u | v => sgn = +
1124// 4. (-u) | (-v) => sgn = -
1125// 5. u | (-v) => sgn = -
1126// 6. (-u) | v => sgn = -
1127
1128const CLASS_TYPE &
1129CLASS_TYPE::operator |= (const CLASS_TYPE &v)
1130{
1131 if (v.sgn == SC_ZERO) // case 1
1132 return *this;
1133 if (sgn == SC_ZERO) // case 2
1134 return (*this = v);
1135 // other cases
1136 or_on_help(sgn, nbits, ndigits, digit,
1137 v.sgn, v.nbits, v.ndigits, v.digit);
1138 convert_2C_to_SM();
1139 return *this;
1140}
1141
1142
1143const CLASS_TYPE &
1144CLASS_TYPE::operator |= (const OTHER_CLASS_TYPE &v)
1145{
1146 if (v.sgn == SC_ZERO) // case 1
1147 return *this;
1148 if (sgn == SC_ZERO) // case 2
1149 return (*this = v);
1150 // other cases
1151 or_on_help(sgn, nbits, ndigits, digit,
1152 v.sgn, v.nbits, v.ndigits, v.digit);
1153 convert_2C_to_SM();
1154 return *this;
1155}
1156
1157
1158const CLASS_TYPE&
1159CLASS_TYPE::operator |= (int64 v)
1160{
1161 if (v == 0) // case 1
1162 return *this;
1163 if (sgn == SC_ZERO) // case 2
1164 return (*this = v);
1165 // other cases
1166 CONVERT_INT64(v);
1167 or_on_help(sgn, nbits, ndigits, digit,
1168 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1169 convert_2C_to_SM();
1170 return *this;
1171}
1172
1173
1174const CLASS_TYPE&
1175CLASS_TYPE::operator |= (uint64 v)
1176{
1177 if (v == 0) // case 1
1178 return *this;
1179 if (sgn == SC_ZERO) // case 2
1180 return (*this = v);
1181 // other cases
1182 CONVERT_INT64(v);
1183 or_on_help(sgn, nbits, ndigits, digit,
1184 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1185 convert_2C_to_SM();
1186 return *this;
1187}
1188
1189
1190const CLASS_TYPE &
1191CLASS_TYPE::operator |= (long v)
1192{
1193 if (v == 0) // case 1
1194 return *this;
1195 if (sgn == SC_ZERO) // case 2
1196 return (*this = v);
1197 // other cases
1198 CONVERT_LONG(v);
1199 or_on_help(sgn, nbits, ndigits, digit,
1200 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1201 convert_2C_to_SM();
1202 return *this;
1203}
1204
1205
1206const CLASS_TYPE &
1207CLASS_TYPE::operator |= (unsigned long v)
1208{
1209 if (v == 0) // case 1
1210 return *this;
1211 if (sgn == SC_ZERO) // case 2
1212 return (*this = v);
1213 // other cases
1214 CONVERT_LONG(v);
1215 or_on_help(sgn, nbits, ndigits, digit,
1216 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1217 convert_2C_to_SM();
1218 return *this;
1219}
1220
1221
1222// ----------------------------------------------------------------------------
1223// SECTION: Bitwise XOR operators: ^, ^=
1224// ----------------------------------------------------------------------------
1225
1226// Cases to consider when computing u ^ v:
1227// Note that u ^ v = (~u &v) | (u & ~v).
1228// 1. u ^ 0 = u
1229// 2. 0 ^ v = v
1230// 3. u ^ v => sgn = +
1231// 4. (-u) ^ (-v) => sgn = -
1232// 5. u ^ (-v) => sgn = -
1233// 6. (-u) ^ v => sgn = +
1234
1235const CLASS_TYPE &
1236CLASS_TYPE::operator ^= (const CLASS_TYPE &v)
1237{
1238 // u = *this
1239 if (v.sgn == SC_ZERO) // case 1
1240 return *this;
1241 if (sgn == SC_ZERO) // case 2
1242 return (*this = v);
1243 // other cases
1244 xor_on_help(sgn, nbits, ndigits, digit,
1245 v.sgn, v.nbits, v.ndigits, v.digit);
1246 convert_2C_to_SM();
1247 return *this;
1248}
1249
1250
1251const CLASS_TYPE &
1252CLASS_TYPE::operator ^= (const OTHER_CLASS_TYPE &v)
1253{
1254 // u = *this
1255 if (v.sgn == SC_ZERO) // case 1
1256 return *this;
1257 if (sgn == SC_ZERO) // case 2
1258 return (*this = v);
1259 // other cases
1260 xor_on_help(sgn, nbits, ndigits, digit,
1261 v.sgn, v.nbits, v.ndigits, v.digit);
1262 convert_2C_to_SM();
1263 return *this;
1264}
1265
1266
1267const CLASS_TYPE&
1268CLASS_TYPE::operator ^= (int64 v)
1269{
1270 if (v == 0) // case 1
1271 return *this;
1272 if (sgn == SC_ZERO) // case 2
1273 return (*this = v);
1274 // other cases
1275 CONVERT_INT64(v);
1276 xor_on_help(sgn, nbits, ndigits, digit,
1277 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1278 convert_2C_to_SM();
1279 return *this;
1280}
1281
1282
1283const CLASS_TYPE &
1284CLASS_TYPE::operator ^= (uint64 v)
1285{
1286 if (v == 0) // case 1
1287 return *this;
1288 if (sgn == SC_ZERO) // case 2
1289 return (*this = v);
1290 // other cases
1291 CONVERT_INT64(v);
1292 xor_on_help(sgn, nbits, ndigits, digit,
1293 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1294 convert_2C_to_SM();
1295 return *this;
1296}
1297
1298
1299const CLASS_TYPE &
1300CLASS_TYPE::operator ^= (long v)
1301{
1302 if (v == 0) // case 1
1303 return *this;
1304 if (sgn == SC_ZERO) // case 2
1305 return (*this = v);
1306 // other cases
1307 CONVERT_LONG(v);
1308 xor_on_help(sgn, nbits, ndigits, digit,
1309 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1310 convert_2C_to_SM();
1311 return *this;
1312}
1313
1314
1315const CLASS_TYPE &
1316CLASS_TYPE::operator ^= (unsigned long v)
1317{
1318 if (v == 0) // case 1
1319 return *this;
1320 if (sgn == SC_ZERO) // case 2
1321 return (*this = v);
1322 // other cases
1323 CONVERT_LONG(v);
1324 xor_on_help(sgn, nbits, ndigits, digit,
1325 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1326 convert_2C_to_SM();
1327 return *this;
1328}
1329
1330
1331// ----------------------------------------------------------------------------
1332// SECTION: Bitwise NOT operator: ~
1333// ----------------------------------------------------------------------------
1334
1335CLASS_TYPE
1336operator ~ (const CLASS_TYPE &u)
1337{
1338 small_type s = u.sgn;
1339 if (s == SC_ZERO) {
1340 sc_digit d = 1;
1341 return CLASS_TYPE(SC_NEG, u.nbits, 1, &d, false);
1342 }
1343
1344 int nd = u.ndigits;
1345
1346#ifdef SC_MAX_NBITS
1347 sc_digit d[MAX_NDIGITS];
1348#else
1349 sc_digit *d = new sc_digit[nd];
1350#endif
1351
1352 vec_copy(nd, d, u.digit);
1353 if (s == SC_POS) {
1354 s = SC_NEG;
1355 vec_add_small_on(nd, d, 1);
1356 } else {
1357 s = SC_POS;
1358 vec_sub_small_on(nd, d, 1);
1359 if (check_for_zero(nd, d))
1360 s = SC_ZERO;
1361 }
1362 return CLASS_TYPE(s, u.nbits, nd, d);
1363}
1364
1365
1366// ----------------------------------------------------------------------------
1367// SECTION: LEFT SHIFT operators: <<, <<=
1368// ----------------------------------------------------------------------------
1369
1370CLASS_TYPE
1371operator << (const CLASS_TYPE &u, const CLASS_TYPE &v)
1372{
1373 if (v.sgn == SC_ZERO)
1374 return CLASS_TYPE(u);
1375#ifdef SC_SIGNED
1376 if (v.sgn == SC_NEG)
1377 return CLASS_TYPE(u);
1378#endif
1379 return operator << (u, v.to_ulong());
1380}
1381
1382
1383const CLASS_TYPE &
1384CLASS_TYPE::operator <<= (const CLASS_TYPE &v)
1385{
1386 if (v.sgn == SC_ZERO)
1387 return *this;
1388#ifdef SC_SIGNED
1389 if (v.sgn == SC_NEG)
1390 return *this;
1391#endif
1392 return operator <<= (v.to_ulong());
1393}
1394
1395
1396const CLASS_TYPE &
1397CLASS_TYPE::operator <<= (const OTHER_CLASS_TYPE &v)
1398{
1399 if (v.sgn == SC_ZERO)
1400 return *this;
1401#ifdef SC_UNSIGNED
1402 if (v.sgn == SC_NEG)
1403 return *this;
1404#endif
1405 return operator <<= (v.to_ulong());
1406}
1407
1408
1409CLASS_TYPE
1410operator << (const CLASS_TYPE &u, int64 v)
1411{
1412 if (v <= 0)
1413 return CLASS_TYPE(u);
1414 return operator << (u, (unsigned long)v);
1415}
1416
1417
1418CLASS_TYPE
1419operator << (const CLASS_TYPE &u, uint64 v)
1420{
1421 if (v == 0)
1422 return CLASS_TYPE(u);
1423 return operator << (u, (unsigned long)v);
1424}
1425
1426
1427const CLASS_TYPE &
1428CLASS_TYPE::operator <<= (int64 v)
1429{
1430 if (v <= 0)
1431 return *this;
1432 return operator <<= ((unsigned long)v);
1433}
1434
1435
1436const CLASS_TYPE &
1437CLASS_TYPE::operator <<= (uint64 v)
1438{
1439 if (v == 0)
1440 return *this;
1441 return operator <<= ((unsigned long)v);
1442}
1443
1444
1445CLASS_TYPE
1446operator << (const CLASS_TYPE &u, long v)
1447{
1448 if (v <= 0)
1449 return CLASS_TYPE(u);
1450 return operator << (u, (unsigned long)v);
1451}
1452
1453CLASS_TYPE
1454operator << (const CLASS_TYPE &u, unsigned long v)
1455{
1456 if (v == 0)
1457 return CLASS_TYPE(u);
1458 if (u.sgn == SC_ZERO)
1459 return CLASS_TYPE(u);
1460
1461 int nb = u.nbits + v;
1462 int nd = DIV_CEIL(nb);
1463
1464#ifdef SC_MAX_NBITS
1465 test_bound(nb);
1466 sc_digit d[MAX_NDIGITS];
1467#else
1468 sc_digit *d = new sc_digit[nd];
1469#endif
1470
1471 vec_copy_and_zero(nd, d, u.ndigits, u.digit);
1472 convert_SM_to_2C(u.sgn, nd, d);
1473 vec_shift_left(nd, d, v);
1474 small_type s = convert_signed_2C_to_SM(nb, nd, d);
1475 return CLASS_TYPE(s, nb, nd, d);
1476}
1477
1478
1479const CLASS_TYPE &
1480CLASS_TYPE::operator <<= (long v)
1481{
1482 if (v <= 0)
1483 return *this;
1484 return operator <<= ((unsigned long)v);
1485}
1486
1487
1488const CLASS_TYPE &
1489CLASS_TYPE::operator <<= (unsigned long v)
1490{
1491 if (v == 0)
1492 return *this;
1493 if (sgn == SC_ZERO)
1494 return *this;
1495 convert_SM_to_2C();
1496 vec_shift_left(ndigits, digit, v);
1497 convert_2C_to_SM();
1498 return *this;
1499}
1500
1501
1502// ----------------------------------------------------------------------------
1503// SECTION: RIGHT SHIFT operators: >>, >>=
1504// ----------------------------------------------------------------------------
1505
1506CLASS_TYPE
1507operator >> (const CLASS_TYPE &u, const CLASS_TYPE &v)
1508{
1509 if (v.sgn == SC_ZERO)
1510 return CLASS_TYPE(u);
1511#ifdef SC_SIGNED
1512 if (v.sgn == SC_NEG)
1513 return CLASS_TYPE(u);
1514#endif
1515 return operator >> (u, v.to_long());
1516}
1517
1518
1519const CLASS_TYPE &
1520CLASS_TYPE::operator >>= (const CLASS_TYPE &v)
1521{
1522 if (v.sgn == SC_ZERO)
1523 return *this;
1524#ifdef SC_SIGNED
1525 if (v.sgn == SC_NEG)
1526 return *this;
1527#endif
1528 return operator >>= (v.to_long());
1529}
1530
1531
1532const CLASS_TYPE &
1533CLASS_TYPE::operator >>= (const OTHER_CLASS_TYPE &v)
1534{
1535 if (v.sgn == SC_ZERO)
1536 return *this;
1537#ifdef SC_UNSIGNED
1538 if (v.sgn == SC_NEG)
1539 return *this;
1540#endif
1541 return operator >>= (v.to_ulong());
1542}
1543
1544
1545CLASS_TYPE
1546operator >> (const CLASS_TYPE &u, int64 v)
1547{
1548 if (v <= 0)
1549 return CLASS_TYPE(u);
1550 return operator >> (u, (unsigned long)v);
1551}
1552
1553
1554CLASS_TYPE
1555operator >> (const CLASS_TYPE &u, uint64 v)
1556{
1557 if (v == 0)
1558 return CLASS_TYPE(u);
1559 return operator >> (u, (unsigned long)v);
1560}
1561
1562const CLASS_TYPE &
1563CLASS_TYPE::operator >>= (int64 v)
1564{
1565 if (v <= 0)
1566 return *this;
1567 return operator >>= ((unsigned long)v);
1568}
1569
1570
1571const CLASS_TYPE &
1572CLASS_TYPE::operator >>= (uint64 v)
1573{
1574 if (v == 0)
1575 return *this;
1576 return operator >>= ((unsigned long)v);
1577}
1578
1579
1580CLASS_TYPE
1581operator >> (const CLASS_TYPE &u, long v)
1582{
1583 if (v <= 0)
1584 return CLASS_TYPE(u);
1585 return operator >> (u, (unsigned long)v);
1586}
1587
1588
1589CLASS_TYPE
1590operator >> (const CLASS_TYPE &u, unsigned long v)
1591{
1592 if (v == 0)
1593 return CLASS_TYPE(u);
1594 if (u.sgn == SC_ZERO)
1595 return CLASS_TYPE(u);
1596
1597 int nb = u.nbits;
1598 int nd = u.ndigits;
1599
1600#ifdef SC_MAX_NBITS
1601 sc_digit d[MAX_NDIGITS];
1602#else
1603 sc_digit *d = new sc_digit[nd];
1604#endif
1605
1606 vec_copy(nd, d, u.digit);
1607 convert_SM_to_2C(u.sgn, nd, d);
1608 if (u.sgn == SC_NEG)
1609 vec_shift_right(nd, d, v, DIGIT_MASK);
1610 else
1611 vec_shift_right(nd, d, v, 0);
1612 small_type s = convert_signed_2C_to_SM(nb, nd, d);
1613 return CLASS_TYPE(s, nb, nd, d);
1614}
1615
1616
1617const CLASS_TYPE &
1618CLASS_TYPE::operator >>= (long v)
1619{
1620 if (v <= 0)
1621 return *this;
1622 return operator >>= ((unsigned long)v);
1623}
1624
1625
1626const CLASS_TYPE &
1627CLASS_TYPE::operator >>= (unsigned long v)
1628{
1629 if (v == 0)
1630 return *this;
1631 if (sgn == SC_ZERO)
1632 return *this;
1633
1634 convert_SM_to_2C();
1635
1636 if (sgn == SC_NEG)
1637 vec_shift_right(ndigits, digit, v, DIGIT_MASK);
1638 else
1639 vec_shift_right(ndigits, digit, v, 0);
1640 convert_2C_to_SM();
1641 return *this;
1642}
1643
1644
1645// ----------------------------------------------------------------------------
1646// SECTION: EQUAL TO operator: ==
1647// ----------------------------------------------------------------------------
1648
1649// Defined in the sc_signed.cpp and sc_unsigned.cpp.
1650
1651
1652// ----------------------------------------------------------------------------
1653// SECTION: NOT_EQUAL operator: !=
1654// ----------------------------------------------------------------------------
1655
1656bool
1657operator != (const CLASS_TYPE &u, const CLASS_TYPE &v)
1658{
1659 return (!operator == (u, v));
1660}
1661
1662
1663bool
1664operator != (const CLASS_TYPE &u, int64 v)
1665{
1666 return (!operator == (u, v));
1667}
1668
1669
1670bool
1671operator != (int64 u, const CLASS_TYPE &v)
1672{
1673 return (!operator == (u, v));
1674}
1675
1676
1677bool
1678operator != (const CLASS_TYPE &u, uint64 v)
1679{
1680 return (!operator == (u, v));
1681}
1682
1683
1684bool
1685operator != (uint64 u, const CLASS_TYPE &v)
1686{
1687 return (!operator == (u, v));
1688}
1689
1690
1691bool
1692operator != (const CLASS_TYPE &u, long v)
1693{
1694 return (!operator == (u, v));
1695}
1696
1697
1698bool
1699operator != (long u, const CLASS_TYPE &v)
1700{
1701 return (!operator == (u, v));
1702}
1703
1704
1705bool
1706operator != (const CLASS_TYPE &u, unsigned long v)
1707{
1708 return (!operator == (u, v));
1709}
1710
1711
1712bool
1713operator != (unsigned long u, const CLASS_TYPE &v)
1714{
1715 return (!operator == (u, v));
1716}
1717
1718
1719// ----------------------------------------------------------------------------
1720// SECTION: LESS THAN operator: <
1721// ----------------------------------------------------------------------------
1722
1723// Defined in the sc_signed.cpp and sc_unsigned.cpp.
1724
1725
1726// ----------------------------------------------------------------------------
1727// SECTION: LESS THAN or EQUAL operator: <=
1728// ----------------------------------------------------------------------------
1729
1730bool
1731operator <= (const CLASS_TYPE &u, const CLASS_TYPE &v)
1732{
1733 return (operator < (u, v) || operator == (u, v));
1734}
1735
1736
1737bool
1738operator <= (const CLASS_TYPE &u, int64 v)
1739{
1740 return (operator < (u, v) || operator == (u, v));
1741}
1742
1743
1744bool
1745operator <= (int64 u, const CLASS_TYPE &v)
1746{
1747 return (operator < (u, v) || operator == (u, v));
1748}
1749
1750
1751bool
1752operator <= (const CLASS_TYPE &u, uint64 v)
1753{
1754 return (operator < (u, v) || operator == (u, v));
1755}
1756
1757
1758bool
1759operator <= (uint64 u, const CLASS_TYPE &v)
1760{
1761 return (operator < (u, v) || operator == (u, v));
1762}
1763
1764
1765bool
1766operator <= (const CLASS_TYPE &u, long v)
1767{
1768 return (operator < (u, v) || operator == (u, v));
1769}
1770
1771
1772bool
1773operator <= (long u, const CLASS_TYPE &v)
1774{
1775 return (operator < (u, v) || operator == (u, v));
1776}
1777
1778
1779bool
1780operator <= (const CLASS_TYPE &u, unsigned long v)
1781{
1782 return (operator < (u, v) || operator == (u, v));
1783}
1784
1785
1786bool
1787operator <= (unsigned long u, const CLASS_TYPE &v)
1788{
1789 return (operator < (u, v) || operator == (u, v));
1790}
1791
1792
1793// ----------------------------------------------------------------------------
1794// SECTION: GREATER THAN operator: >
1795// ----------------------------------------------------------------------------
1796
1797bool
1798operator > (const CLASS_TYPE &u, const CLASS_TYPE &v)
1799{
1800 return (!(operator <= (u, v)));
1801}
1802
1803
1804bool
1805operator > (const CLASS_TYPE &u, int64 v)
1806{
1807 return (!(operator <= (u, v)));
1808}
1809
1810
1811bool
1812operator > (int64 u, const CLASS_TYPE &v)
1813{
1814 return (!(operator <= (u, v)));
1815}
1816
1817
1818bool
1819operator > (const CLASS_TYPE &u, uint64 v)
1820{
1821 return (!(operator <= (u, v)));
1822}
1823
1824
1825bool
1826operator > (uint64 u, const CLASS_TYPE &v)
1827{
1828 return (!(operator <= (u, v)));
1829}
1830
1831
1832bool
1833operator > (const CLASS_TYPE &u, long v)
1834{
1835 return (!(operator <= (u, v)));
1836}
1837
1838
1839bool
1840operator > (long u, const CLASS_TYPE &v)
1841{
1842 return (!(operator <= (u, v)));
1843}
1844
1845
1846bool
1847operator > (const CLASS_TYPE &u, unsigned long v)
1848{
1849 return (!(operator <= (u, v)));
1850}
1851
1852
1853bool
1854operator > (unsigned long u, const CLASS_TYPE &v)
1855{
1856 return (!(operator <= (u, v)));
1857}
1858
1859
1860// ----------------------------------------------------------------------------
1861// SECTION: GREATER THAN or EQUAL operator: >=
1862// ----------------------------------------------------------------------------
1863
1864bool
1865operator >= (const CLASS_TYPE &u, const CLASS_TYPE &v)
1866{
1867 return (!(operator < (u, v)));
1868}
1869
1870
1871bool
1872operator >= (const CLASS_TYPE &u, int64 v)
1873{
1874 return (!(operator < (u, v)));
1875}
1876
1877
1878bool
1879operator >= (int64 u, const CLASS_TYPE &v)
1880{
1881 return (!(operator < (u, v)));
1882}
1883
1884
1885bool
1886operator >= (const CLASS_TYPE &u, uint64 v)
1887{
1888 return (!(operator < (u, v)));
1889}
1890
1891
1892bool
1893operator >= (uint64 u, const CLASS_TYPE &v)
1894{
1895 return (!(operator < (u, v)));
1896}
1897
1898
1899bool
1900operator >= (const CLASS_TYPE &u, long v)
1901{
1902 return (!(operator < (u, v)));
1903}
1904
1905
1906bool
1907operator >= (long u, const CLASS_TYPE &v)
1908{
1909 return (!(operator < (u, v)));
1910}
1911
1912
1913bool
1914operator >= (const CLASS_TYPE &u, unsigned long v)
1915{
1916 return (!(operator < (u, v)));
1917}
1918
1919
1920bool
1921operator >= (unsigned long u, const CLASS_TYPE &v)
1922{
1923 return (!(operator < (u, v)));
1924}
1925
1926
1927// ----------------------------------------------------------------------------
1928// SECTION: Public members - Other utils.
1929// ----------------------------------------------------------------------------
1930
1931// Convert to int64, long, or int.
1932#define TO_INTX(RET_TYPE, UP_RET_TYPE) \
1933if (sgn == SC_ZERO) \
1934 return 0; \
1935int vnd = sc_min((int)DIGITS_PER_ ## UP_RET_TYPE, ndigits); \
1936RET_TYPE v = 0; \
1937while (--vnd >= 0) \
1938 v = (v << BITS_PER_DIGIT) + digit[vnd]; \
1939if (sgn == SC_NEG) \
1940 return -v; \
1941else \
1942 return v;
1943
1944
1945int64
1946CLASS_TYPE::to_int64() const
1947{
1948 TO_INTX(int64, INT64);
1949}
1950
1951
1952long
1953CLASS_TYPE::to_long() const
1954{
1955 TO_INTX(long, LONG);
1956}
1957
1958
1959int
1960CLASS_TYPE::to_int() const
1961{
1962 TO_INTX(int, INT);
1963}
1964
1965
1966// Convert to unsigned int64, unsigned long or unsigned
1967// int. to_uint64, to_ulong, and to_uint have the same body except for
1968// the type of v defined inside.
1969uint64
1970CLASS_TYPE::to_uint64() const
1971{
1972 if (sgn == SC_ZERO)
1973 return 0;
1974
1975 int vnd = sc_min((int)DIGITS_PER_INT64, ndigits);
1976
1977 uint64 v = 0;
1978
1979 if (sgn == SC_NEG) {
1980#ifdef SC_MAX_NBITS
1981 sc_digit d[MAX_NDIGITS];
1982#else
1983 sc_digit *d = new sc_digit[ndigits];
1984#endif
1985 vec_copy(ndigits, d, digit);
1986 convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
1987 while (--vnd >= 0)
1988 v = (v << BITS_PER_DIGIT) + d[vnd];
1989#ifndef SC_MAX_NBITS
1990 delete [] d;
1991#endif
1992 } else {
1993 while (--vnd >= 0)
1994 v = (v << BITS_PER_DIGIT) + digit[vnd];
1995 }
1996 return v;
1997}
1998
1999
2000unsigned long
2001CLASS_TYPE::to_ulong() const
2002{
2003 if (sgn == SC_ZERO)
2004 return 0;
2005
2006 int vnd = sc_min((int)DIGITS_PER_LONG, ndigits);
2007 unsigned long v = 0;
2008
2009 if (sgn == SC_NEG) {
2010#ifdef SC_MAX_NBITS
2011 sc_digit d[MAX_NDIGITS];
2012#else
2013 sc_digit *d = new sc_digit[ndigits];
2014#endif
2015 vec_copy(ndigits, d, digit);
2016 convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
2017 while (--vnd >= 0)
2018 v = (v << BITS_PER_DIGIT) + d[vnd];
2019#ifndef SC_MAX_NBITS
2020 delete [] d;
2021#endif
2022 } else {
2023 while (--vnd >= 0)
2024 v = (v << BITS_PER_DIGIT) + digit[vnd];
2025 }
2026 return v;
2027}
2028
2029
2030unsigned int
2031CLASS_TYPE::to_uint() const
2032{
2033 if (sgn == SC_ZERO)
2034 return 0;
2035
2036 int vnd = sc_min((int)DIGITS_PER_INT, ndigits);
2037 unsigned int v = 0;
2038 if (sgn == SC_NEG) {
2039#ifdef SC_MAX_NBITS
2040 sc_digit d[MAX_NDIGITS];
2041#else
2042 sc_digit *d = new sc_digit[ndigits];
2043#endif
2044 vec_copy(ndigits, d, digit);
2045 convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
2046 while (--vnd >= 0)
2047 v = (v << BITS_PER_DIGIT) + d[vnd];
2048#ifndef SC_MAX_NBITS
2049 delete [] d;
2050#endif
2051 } else {
2052 while (--vnd >= 0)
2053 v = (v << BITS_PER_DIGIT) + digit[vnd];
2054 }
2055 return v;
2056}
2057
2058
2059// Convert to double.
2060double
2061CLASS_TYPE::to_double() const
2062{
2063 if (sgn == SC_ZERO)
2064 return (double) 0.0;
2065
2066 int vnd = ndigits;
2067 double v = 0.0;
2068 while (--vnd >= 0)
2069 v = v * DIGIT_RADIX + digit[vnd];
2070 if (sgn == SC_NEG)
2071 return -v;
2072 else
2073 return v;
2074}
2075
2076
2077// Return true if the bit i is 1, false otherwise. If i is outside the
2078// bounds, return 1/0 according to the sign of the number by assuming
2079// that the number has infinite length.
2080
2081bool
2082CLASS_TYPE::test(int i) const
2083{
2084#ifdef SC_SIGNED
2085 if (check_if_outside(i)) {
2086 if (sgn == SC_NEG)
2087 return 1;
2088 else
2089 return 0;
2090 }
2091#else
2092 if (check_if_outside(i))
2093 return 0;
2094#endif
2095
2096 int bit_num = bit_ord(i);
2097 int digit_num = digit_ord(i);
2098
2099 if (sgn == SC_NEG) {
2100#ifdef SC_MAX_NBITS
2101 sc_digit d[MAX_NDIGITS];
2102#else
2103 sc_digit *d = new sc_digit[ndigits];
2104#endif
2105 vec_copy(ndigits, d, digit);
2106 vec_complement(ndigits, d);
2107 bool val = ((d[digit_num] & one_and_zeros(bit_num)) != 0);
2108#ifndef SC_MAX_NBITS
2109 delete [] d;
2110#endif
2111 return val;
2112 } else {
2113 return ((digit[digit_num] & one_and_zeros(bit_num)) != 0);
2114 }
2115}
2116
2117
2118// Set the ith bit with 1.
2119void
2120CLASS_TYPE::set(int i)
2121{
2122 if (check_if_outside(i))
2123 return;
2124
2125 int bit_num = bit_ord(i);
2126 int digit_num = digit_ord(i);
2127
2128 convert_SM_to_2C();
2129 digit[digit_num] |= one_and_zeros(bit_num);
2130 digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
2131 convert_2C_to_SM();
2132}
2133
2134
2135// Set the ith bit with 0, i.e., clear the ith bit.
2136void
2137CLASS_TYPE::clear(int i)
2138{
2139 if (check_if_outside(i))
2140 return;
2141
2142 int bit_num = bit_ord(i);
2143 int digit_num = digit_ord(i);
2144
2145 convert_SM_to_2C();
2146 digit[digit_num] &= ~(one_and_zeros(bit_num));
2147 digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
2148 convert_2C_to_SM();
2149}
2150
2151
2152// Create a mirror image of the number.
2153void
2154CLASS_TYPE::reverse()
2155{
2156 convert_SM_to_2C();
2157 vec_reverse(length(), ndigits, digit, length() - 1);
2158 convert_2C_to_SM();
2159}
2160
2161
2162// Get a packed bit representation of the number.
2163void
2164CLASS_TYPE::get_packed_rep(sc_digit *buf) const
2165{
2166 int buf_ndigits = (length() - 1) / BITS_PER_DIGIT_TYPE + 1;
2167 // Initialize buf to zero.
2168 vec_zero(buf_ndigits, buf);
2169
2170 if (sgn == SC_ZERO)
2171 return;
2172
2173 const sc_digit *digit_or_d;
2174#ifdef SC_MAX_NBITS
2175 sc_digit d[MAX_NDIGITS];
2176#else
2177 sc_digit *d = new sc_digit[ndigits];
2178#endif
2179
2180 if (sgn == SC_POS) {
2181 digit_or_d = digit;
2182 } else {
2183 // If sgn is negative, we have to convert digit to its 2's
2184 // complement. Since this function is const, we can not do it on
2185 // digit. Since buf doesn't have overflow bits, we cannot also do
2186 // it on buf. Thus, we have to do the complementation on a copy of
2187 // digit, i.e., on d.
2188
2189 vec_copy(ndigits, d, digit);
2190 vec_complement(ndigits, d);
2191 buf[buf_ndigits - 1] = ~((sc_digit) 0);
2192 digit_or_d = d;
2193 }
2194
2195 // Copy the bits from digit to buf. The division and mod operations
2196 // below can be converted to addition/subtraction and comparison
2197 // operations at the expense of complicating the code. We can do it
2198 // if we see any performance problems.
2199
2200 for (int i = length() - 1; i >= 0; --i) {
2201
2202 if ((digit_or_d[digit_ord(i)] &
2203 one_and_zeros(bit_ord(i))) != 0) { // Test.
2204 buf[i / BITS_PER_DIGIT_TYPE] |=
2205 one_and_zeros(i % BITS_PER_DIGIT_TYPE); // Set.
2206 } else {
2207 buf[i / BITS_PER_DIGIT_TYPE] &=
2208 ~(one_and_zeros(i % BITS_PER_DIGIT_TYPE)); // Clear.
2209 }
2210 }
2211
2212#ifndef SC_MAX_NBITS
2213 delete[] d;
2214#endif
2215}
2216
2217
2218// Set a packed bit representation of the number.
2219void
2220CLASS_TYPE::set_packed_rep(sc_digit *buf)
2221{
2222 // Initialize digit to zero.
2223 vec_zero(ndigits, digit);
2224
2225 // Copy the bits from buf to digit.
2226 for (int i = length() - 1; i >= 0; --i) {
2227 if ((buf[i / BITS_PER_DIGIT_TYPE] &
2228 one_and_zeros(i % BITS_PER_DIGIT_TYPE)) != 0) { // Test.
2229 digit[digit_ord(i)] |= one_and_zeros(bit_ord(i)); // Set.
2230 } else {
2231 digit[digit_ord(i)] &= ~(one_and_zeros(bit_ord(i))); // Clear
2232 }
2233 }
2234 convert_2C_to_SM();
2235}
2236
2237
2238// ----------------------------------------------------------------------------
2239// SECTION: Private members.
2240// ----------------------------------------------------------------------------
2241
2242// Create a copy of v with sgn s.
2243CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE &v, small_type s) :
2244 sc_value_base(v), sgn(s), nbits(v.nbits), ndigits(v.ndigits), digit()
2245{
2246#ifndef SC_MAX_NBITS
2247 digit = new sc_digit[ndigits];
2248#endif
2249 vec_copy(ndigits, digit, v.digit);
2250}
2251
2252
2253// Create a copy of v where v is of the different type.
2254CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE &v, small_type s) :
2255 sc_value_base(v), sgn(s), nbits(num_bits(v.nbits)), ndigits(), digit()
2256{
2257#if (IF_SC_SIGNED == 1)
2258 ndigits = v.ndigits;
2259#else
2260 ndigits = DIV_CEIL(nbits);
2261#endif
2262
2263#ifndef SC_MAX_NBITS
2264 digit = new sc_digit[ndigits];
2265#endif
2266
2267 copy_digits(v.nbits, v.ndigits, v.digit);
2268}
2269
2270
2271// Create a signed number with (s, nb, nd, d) as its attributes (as
2272// defined in class CLASS_TYPE). If alloc is set, delete d.
2273CLASS_TYPE::CLASS_TYPE(
2274 small_type s, int nb, int nd, sc_digit *d, bool alloc) :
2275 sc_value_base(), sgn(s), nbits(num_bits(nb)), ndigits(), digit()
2276{
2277 ndigits = DIV_CEIL(nbits);
2278#ifndef SC_MAX_NBITS
2279 digit = new sc_digit[ndigits];
2280#endif
2281
2282 if (ndigits <= nd)
2283 vec_copy(ndigits, digit, d);
2284 else
2285 vec_copy_and_zero(ndigits, digit, nd, d);
2286
2287#ifndef SC_MAX_NBITS
2288 if (alloc)
2289 delete [] d;
2290#endif
2291}
2292
2293// This constructor is mainly used in finding a "range" of bits from a
2294// number of type CLASS_TYPE. The function range(l, r) can have
2295// arbitrary precedence between l and r. If l is smaller than r, then
2296// the output is the reverse of range(r, l).
2297CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE *u, int l, int r) :
2298 sc_value_base(), sgn(), nbits(), ndigits(), digit()
2299{
2300 bool reversed = false;
2301
2302 if (l < r) {
2303 reversed = true;
2304 int tmp = l;
2305 l = r;
2306 r = tmp;
2307 }
2308
2309 // at this point, l >= r
2310
2311 // make sure that l and r point to the bits of u
2312 r = sc_max(r, 0);
2313 l = sc_min(l, u->nbits - 1);
2314
2315 nbits = num_bits(l - r + 1);
2316
2317 // nbits can still be <= 0 because l and r have just been updated
2318 // with the bounds of u.
2319
2320 // if u == 0 or the range is out of bounds, return 0
2321 if (u->sgn == SC_ZERO || nbits <= num_bits(0)) {
2322 sgn = SC_ZERO;
2323 if (nbits <= num_bits(0)) {
2324 nbits = 1;
2325 }
2326 ndigits = DIV_CEIL(nbits);
2327#ifndef SC_MAX_NBITS
2328 digit = new sc_digit[ndigits];
2329#endif
2330 vec_zero(ndigits, digit);
2331 return;
2332 }
2333
2334 // The rest will be executed if u is not zero.
2335
2336 ndigits = DIV_CEIL(nbits);
2337
2338 // The number of bits up to and including l and r, respectively.
2339 int nl = l + 1;
2340 int nr = r + 1;
2341
2342 // The indices of the digits that have lth and rth bits, respectively.
2343 int left_digit = DIV_CEIL(nl) - 1;
2344 int right_digit = DIV_CEIL(nr) - 1;
2345
2346 int nd;
2347
2348 // The range is performed on the 2's complement representation, so
2349 // first get the indices for that.
2350 if (u->sgn == SC_NEG)
2351 nd = left_digit + 1;
2352 else
2353 nd = left_digit - right_digit + 1;
2354
2355 // Allocate memory for the range.
2356#ifdef SC_MAX_NBITS
2357 sc_digit d[MAX_NDIGITS];
2358#else
2359 digit = new sc_digit[ndigits];
2360 sc_digit *d = new sc_digit[nd];
2361#endif
2362
2363 // Getting the range on the 2's complement representation.
2364 if (u->sgn == SC_NEG) {
2365 vec_copy(nd, d, u->digit);
2366 vec_complement(nd, d); // d = -d;
2367 vec_shift_right(nd, d, r, DIGIT_MASK);
2368 } else {
2369 for (int i = right_digit; i <= left_digit; ++i)
2370 d[i - right_digit] = u->digit[i];
2371 vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
2372 }
2373
2374 vec_zero(ndigits, digit);
2375
2376 if (!reversed) {
2377 vec_copy(sc_min(nd, ndigits), digit, d);
2378 } else {
2379 // If l < r, i.e., reversed is set, reverse the bits of digit. d
2380 // will be used as a temporary store. The following code tries to
2381 // minimize the use of bit_ord and digit_ord, which use mod and
2382 // div operators. Since these operators are function calls to
2383 // standard library routines, they are slow. The main idea in
2384 // reversing is "read bits out of d from left to right and push
2385 // them into digit using right shifting."
2386
2387 // Take care of the last digit.
2388 int nd_less_1 = nd - 1;
2389
2390 // Deletions will start from the left end and move one position
2391 // after each deletion.
2392 sc_digit del_mask = one_and_zeros(bit_ord(l - r));
2393
2394 while (del_mask) {
2395 vec_shift_right(ndigits, digit, 1,
2396 ((d[nd_less_1] & del_mask) != 0));
2397 del_mask >>= 1;
2398 }
2399
2400 // Take care of the other digits if any.
2401
2402 // Insertion to digit will always occur at the left end.
2403 sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
2404
2405 for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
2406 // Deletions will start from the left end and move one position
2407 // after each deletion.
2408 del_mask = ins_mask;
2409 while (del_mask) {
2410 vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
2411 del_mask >>= 1;
2412 }
2413 }
2414
2415 if (u->sgn == SC_NEG)
2416 vec_shift_right(ndigits, digit,
2417 ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
2418 else
2419 vec_shift_right(ndigits, digit,
2420 ndigits * BITS_PER_DIGIT - length(), 0);
2421
2422
2423 } // if reversed.
2424
2425 convert_2C_to_SM();
2426
2427#ifndef SC_MAX_NBITS
2428 delete [] d;
2429#endif
2430}
2431
2432// This constructor is mainly used in finding a "range" of bits from a
2433// number of type OTHER_CLASS_TYPE. The function range(l, r) can have
2434// arbitrary precedence between l and r. If l is smaller than r, then
2435// the output is the reverse of range(r, l).
2436CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE *u, int l, int r) :
2437 sc_value_base(), sgn(), nbits(), ndigits(), digit()
2438{
2439 bool reversed = false;
2440
2441 if (l < r) {
2442 reversed = true;
2443 int tmp = l;
2444 l = r;
2445 r = tmp;
2446 }
2447
2448 // at this point, l >= r
2449
2450 // make sure that l and r point to the bits of u
2451 r = sc_max(r, 0);
2452 l = sc_min(l, u->nbits - 1);
2453
2454 nbits = num_bits(l - r + 1);
2455
2456 // nbits can still be <= 0 because l and r have just been updated
2457 // with the bounds of u.
2458
2459 // if u == 0 or the range is out of bounds, return 0
2460 if (u->sgn == SC_ZERO || nbits <= num_bits(0)) {
2461 sgn = SC_ZERO;
2462 if (nbits <= num_bits(0)) {
2463 nbits = 1;
2464 }
2465 ndigits = DIV_CEIL(nbits);
2466#ifndef SC_MAX_NBITS
2467 digit = new sc_digit[ndigits];
2468#endif
2469 vec_zero(ndigits, digit);
2470 return;
2471 }
2472
2473 // The rest will be executed if u is not zero.
2474
2475 ndigits = DIV_CEIL(nbits);
2476
2477 // The number of bits up to and including l and r, respectively.
2478 int nl = l + 1;
2479 int nr = r + 1;
2480
2481 // The indices of the digits that have lth and rth bits, respectively.
2482 int left_digit = DIV_CEIL(nl) - 1;
2483 int right_digit = DIV_CEIL(nr) - 1;
2484
2485 int nd;
2486
2487 // The range is performed on the 2's complement representation, so
2488 // first get the indices for that.
2489 if (u->sgn == SC_NEG)
2490 nd = left_digit + 1;
2491 else
2492 nd = left_digit - right_digit + 1;
2493
2494 // Allocate memory for the range.
2495#ifdef SC_MAX_NBITS
2496 sc_digit d[MAX_NDIGITS];
2497#else
2498 digit = new sc_digit[ndigits];
2499 sc_digit *d = new sc_digit[nd];
2500#endif
2501
2502 // Getting the range on the 2's complement representation.
2503 if (u->sgn == SC_NEG) {
2504 vec_copy(nd, d, u->digit);
2505 vec_complement(nd, d); // d = -d;
2506 vec_shift_right(nd, d, r, DIGIT_MASK);
2507 } else {
2508 for (int i = right_digit; i <= left_digit; ++i)
2509 d[i - right_digit] = u->digit[i];
2510 vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
2511 }
2512
2513 vec_zero(ndigits, digit);
2514
2515 if (!reversed) {
2516 vec_copy(sc_min(nd, ndigits), digit, d);
2517 } else {
2518 // If l < r, i.e., reversed is set, reverse the bits of digit. d
2519 // will be used as a temporary store. The following code tries to
2520 // minimize the use of bit_ord and digit_ord, which use mod and
2521 // div operators. Since these operators are function calls to
2522 // standard library routines, they are slow. The main idea in
2523 // reversing is "read bits out of d from left to right and push
2524 // them into digit using right shifting."
2525
2526 // Take care of the last digit.
2527 int nd_less_1 = nd - 1;
2528
2529 // Deletions will start from the left end and move one position
2530 // after each deletion.
2531 sc_digit del_mask = one_and_zeros(bit_ord(l - r));
2532
2533 while (del_mask) {
2534 vec_shift_right(ndigits, digit, 1,
2535 ((d[nd_less_1] & del_mask) != 0));
2536 del_mask >>= 1;
2537 }
2538
2539 // Take care of the other digits if any.
2540
2541 // Insertion to digit will always occur at the left end.
2542 sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
2543
2544 for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
2545 // Deletions will start from the left end and move one position
2546 // after each deletion.
2547 del_mask = ins_mask;
2548
2549 while (del_mask) {
2550 vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
2551 del_mask >>= 1;
2552 }
2553 }
2554
2555 if (u->sgn == SC_NEG)
2556 vec_shift_right(ndigits, digit,
2557 ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
2558 else
2559 vec_shift_right(ndigits, digit,
2560 ndigits * BITS_PER_DIGIT - length(), 0);
2561
2562
2563 } // if reversed.
2564
2565 convert_2C_to_SM();
2566
2567#ifndef SC_MAX_NBITS
2568 delete [] d;
2569#endif
2570}
2571
2572
2573// Print out all the physical attributes.
2574void
2575CLASS_TYPE::dump(::std::ostream &os) const
2576{
2577 // Save the current setting, and set the base to decimal.
2578 ::std::ios::fmtflags old_flags =
2579 os.setf(::std::ios::dec, ::std::ios::basefield);
2580
2581 os << "width = " << length() << ::std::endl;
2582 os << "value = " << *this << ::std::endl;
| 1/*****************************************************************************
2
3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4 more contributor license agreements. See the NOTICE file distributed
5 with this work for additional information regarding copyright ownership.
6 Accellera licenses this file to you under the Apache License, Version 2.0
7 (the "License"); you may not use this file except in compliance with the
8 License. You may obtain a copy of the License at
9
10 http://www.apache.org/licenses/LICENSE-2.0
11
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15 implied. See the License for the specific language governing
16 permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22 sc_nbcommon.cpp -- Functions common to both sc_signed and sc_unsigned.
23 This file is included in sc_signed.cpp and
24 sc_unsigned.cpp after the macros are defined accordingly.
25 For example, sc_signed.cpp will first define CLASS_TYPE
26 as sc_signed before including this file. This file like
27 sc_nbfriends.cpp and sc_nbexterns.cpp is created in order
28 to ensure only one version of each function, regardless
29 of the class that they interface to.
30
31 Original Author: Ali Dasdan, Synopsys, Inc.
32
33 *****************************************************************************/
34
35/*****************************************************************************
36
37 MODIFICATION LOG - modifiers, enter your name, affiliation, date and
38 changes you are making here.
39
40 Name, Affiliation, Date:
41 Description of Modification:
42
43 *****************************************************************************/
44
45
46// ----------------------------------------------------------------------------
47// SECTION : Public members
48// ----------------------------------------------------------------------------
49
50// Create a CLASS_TYPE number with nb bits.
51CLASS_TYPE::CLASS_TYPE(int nb) :
52 sc_value_base(), sgn(), nbits(), ndigits(), digit()
53{
54 sgn = default_sign();
55 if (nb > 0) {
56 nbits = num_bits(nb);
57 } else {
58 invalid_init("int nb", nb);
59 sc_core::sc_abort(); // can't recover from here
60 }
61 ndigits = DIV_CEIL(nbits);
62#ifdef SC_MAX_NBITS
63 test_bound(nb);
64#else
65 digit = new sc_digit[ndigits];
66#endif
67 makezero();
68}
69
70
71// Create a copy of v with sgn s. v is of the same type.
72CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE &v) :
73 sc_value_base(v), sgn(v.sgn), nbits(v.nbits), ndigits(v.ndigits), digit()
74{
75#ifndef SC_MAX_NBITS
76 digit = new sc_digit[ndigits];
77#endif
78
79 vec_copy(ndigits, digit, v.digit);
80}
81
82
83// Create a copy of v where v is of the different type.
84CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE &v) :
85 sc_value_base(v), sgn(v.sgn), nbits(num_bits(v.nbits)), ndigits(), digit()
86{
87#if (IF_SC_SIGNED == 1)
88 ndigits = v.ndigits;
89#else
90 ndigits = DIV_CEIL(nbits);
91#endif
92
93#ifndef SC_MAX_NBITS
94 digit = new sc_digit[ndigits];
95#endif
96
97 copy_digits(v.nbits, v.ndigits, v.digit);
98}
99
100// Create a copy of v where v is an sign-less instance.
101CLASS_TYPE::CLASS_TYPE(const sc_bv_base &v) :
102 sc_value_base(), sgn(), nbits(), ndigits(), digit()
103{
104 int nb = v.length();
105 sgn = default_sign();
106 if (nb > 0) {
107 nbits = num_bits(nb);
108 } else {
109 invalid_init("sc_bv_base", nb);
110 sc_core::sc_abort(); // can't recover from here
111 }
112 ndigits = DIV_CEIL(nbits);
113# ifdef SC_MAX_NBITS
114 test_bound(nb);
115# else
116 digit = new sc_digit[ndigits];
117# endif
118 makezero();
119 *this = v;
120}
121
122CLASS_TYPE::CLASS_TYPE(const sc_lv_base &v) :
123 sc_value_base(), sgn(), nbits(), ndigits(), digit()
124{
125 int nb = v.length();
126 sgn = default_sign();
127 if (nb > 0) {
128 nbits = num_bits(nb);
129 } else {
130 invalid_init("sc_lv_base", nb);
131 sc_core::sc_abort(); // can't recover from here
132 }
133 ndigits = DIV_CEIL(nbits);
134# ifdef SC_MAX_NBITS
135 test_bound(nb);
136# else
137 digit = new sc_digit[ndigits];
138# endif
139 makezero();
140 *this = v;
141}
142
143CLASS_TYPE::CLASS_TYPE(const sc_int_subref_r &v) :
144 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
145{
146 int nb = v.length();
147 sgn = default_sign();
148 if (nb > 0) {
149 nbits = num_bits(nb);
150 } else {
151 invalid_init("sc_int_subref", nb);
152 sc_core::sc_abort(); // can't recover from here
153 }
154 ndigits = DIV_CEIL(nbits);
155# ifdef SC_MAX_NBITS
156 test_bound(nb);
157# else
158 digit = new sc_digit[ndigits];
159# endif
160 makezero();
161 *this = v.to_uint64();
162}
163
164CLASS_TYPE::CLASS_TYPE(const sc_uint_subref_r &v) :
165 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
166{
167 int nb = v.length();
168 sgn = default_sign();
169 if (nb > 0) {
170 nbits = num_bits(nb);
171 } else {
172 invalid_init("sc_uint_subref", nb);
173 sc_core::sc_abort(); // can't recover from here
174 }
175 ndigits = DIV_CEIL(nbits);
176# ifdef SC_MAX_NBITS
177 test_bound(nb);
178# else
179 digit = new sc_digit[ndigits];
180# endif
181 makezero();
182 *this = v.to_uint64();
183}
184
185CLASS_TYPE::CLASS_TYPE(const sc_signed_subref_r &v) :
186 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
187{
188 int nb = v.length();
189 sgn = default_sign();
190 if (nb > 0) {
191 nbits = num_bits(nb);
192 } else {
193 invalid_init("sc_signed_subref", nb);
194 sc_core::sc_abort(); // can't recover from here
195 }
196 ndigits = DIV_CEIL(nbits);
197# ifdef SC_MAX_NBITS
198 test_bound(nb);
199# else
200 digit = new sc_digit[ndigits];
201# endif
202 makezero();
203 *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
204}
205
206CLASS_TYPE::CLASS_TYPE(const sc_unsigned_subref_r &v) :
207 sc_value_base(v), sgn(), nbits(), ndigits(), digit()
208{
209 int nb = v.length();
210 sgn = default_sign();
211 if (nb > 0) {
212 nbits = num_bits(nb);
213 } else {
214 invalid_init("sc_unsigned_subref", nb);
215 sc_core::sc_abort(); // can't recover from here
216 }
217 ndigits = DIV_CEIL(nbits);
218# ifdef SC_MAX_NBITS
219 test_bound(nb);
220# else
221 digit = new sc_digit[ndigits];
222# endif
223 makezero();
224 *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
225}
226
227// ----------------------------------------------------------------------------
228// SECTION: Public members - Concatenation support.
229// ----------------------------------------------------------------------------
230
231
232// ----------------------------------------------------------------------------
233// SECTION: Public members - Assignment operators.
234// ----------------------------------------------------------------------------
235
236// Assignment from v of the same type.
237const CLASS_TYPE &
238CLASS_TYPE::operator = (const CLASS_TYPE &v)
239{
240 if (this != &v) {
241 sgn = v.sgn;
242
243 if (sgn == SC_ZERO)
244 vec_zero(ndigits, digit);
245 else
246 copy_digits(v.nbits, v.ndigits, v.digit);
247 }
248 return *this;
249}
250
251
252// Assignment from v of the different type.
253const CLASS_TYPE &
254CLASS_TYPE::operator = (const OTHER_CLASS_TYPE &v)
255{
256 sgn = v.sgn;
257
258 if (sgn == SC_ZERO)
259 vec_zero(ndigits, digit);
260 else
261 copy_digits(v.nbits, v.ndigits, v.digit);
262
263 return *this;
264}
265
266
267// Assignment from an sc_unsigned_subref_r
268const CLASS_TYPE &
269CLASS_TYPE::operator = (const sc_unsigned_subref_r &v)
270{
271 return operator=(sc_unsigned(v));
272}
273
274
275// Assignment from an sc_signed_subref_r
276const CLASS_TYPE &
277CLASS_TYPE::operator = (const sc_signed_subref_r &v)
278{
279 return operator = (sc_unsigned(v));
280}
281
282
283// ----------------------------------------------------------------------------
284// SECTION: Input and output operators
285// ----------------------------------------------------------------------------
286
287void
288CLASS_TYPE::scan(::std::istream &is)
289{
290 std::string s;
291 is >> s;
292 *this = s.c_str();
293}
294
295
296// ----------------------------------------------------------------------------
297// SECTION: PLUS operators: +, +=, ++
298// ----------------------------------------------------------------------------
299
300// Cases to consider when computing u + v:
301// 1. 0 + v = v
302// 2. u + 0 = u
303// 3. if sgn(u) == sgn(v)
304// 3.1 u + v = +(u + v) = sgn(u) * (u + v)
305// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
306// 4. if sgn(u) != sgn(v)
307// 4.1 u + (-v) = u - v = sgn(u) * (u - v)
308// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
309//
310// Specialization of above cases for computing ++u or u++:
311// 1. 0 + 1 = 1
312// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
313// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
314
315const CLASS_TYPE &
316CLASS_TYPE::operator += (const CLASS_TYPE &v)
317{
318 // u = *this
319
320 if (sgn == SC_ZERO) // case 1
321 return (*this = v);
322
323 if (v.sgn == SC_ZERO) // case 2
324 return *this;
325
326 // cases 3 and 4
327 add_on_help(sgn, nbits, ndigits, digit,
328 v.sgn, v.nbits, v.ndigits, v.digit);
329
330 convert_SM_to_2C_to_SM();
331
332 return *this;
333}
334
335
336const CLASS_TYPE &
337CLASS_TYPE::operator += (const OTHER_CLASS_TYPE &v)
338{
339 // u = *this
340
341 if (sgn == SC_ZERO) // case 1
342 return (*this = v);
343
344 if (v.sgn == SC_ZERO) // case 2
345 return *this;
346
347 // cases 3 and 4
348 add_on_help(sgn, nbits, ndigits, digit,
349 v.sgn, v.nbits, v.ndigits, v.digit);
350
351 convert_SM_to_2C_to_SM();
352
353 return *this;
354}
355
356
357CLASS_TYPE &
358CLASS_TYPE::operator ++ () // prefix
359{
360 *this = *this + 1;
361 return *this;
362}
363
364
365const CLASS_TYPE
366CLASS_TYPE::operator ++ (int) // postfix
367{
368 // Copy digit into d.
369
370#ifdef SC_MAX_NBITS
371 sc_digit d[MAX_NDIGITS];
372#else
373 sc_digit *d = new sc_digit[ndigits];
374#endif
375
376 small_type s = sgn;
377
378 vec_copy(ndigits, d, digit);
379
380 *this = *this + 1;
381
382 return CLASS_TYPE(s, nbits, ndigits, d);
383}
384
385
386const CLASS_TYPE &
387CLASS_TYPE::operator += (int64 v)
388{
389 // u = *this
390
391 if (sgn == SC_ZERO) // case 1
392 return (*this = v);
393
394 if (v == 0) // case 2
395 return *this;
396
397 CONVERT_INT64(v);
398
399 // cases 3 and 4
400 add_on_help(sgn, nbits, ndigits, digit,
401 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
402
403 convert_SM_to_2C_to_SM();
404
405 return *this;
406}
407
408
409const CLASS_TYPE &
410CLASS_TYPE::operator += (uint64 v)
411{
412 // u = *this
413
414 if (sgn == SC_ZERO) // case 1
415 return (*this = v);
416
417 if (v == 0) // case 2
418 return *this;
419
420 CONVERT_INT64(v);
421
422 // cases 3 and 4
423 add_on_help(sgn, nbits, ndigits, digit,
424 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
425
426 convert_SM_to_2C_to_SM();
427
428 return *this;
429}
430
431
432const CLASS_TYPE &
433CLASS_TYPE::operator += (long v)
434{
435 // u = *this
436
437 if (sgn == SC_ZERO) // case 1
438 return (*this = v);
439
440 if (v == 0) // case 2
441 return *this;
442
443 CONVERT_LONG(v);
444
445 // cases 3 and 4
446 add_on_help(sgn, nbits, ndigits, digit,
447 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
448
449 convert_SM_to_2C_to_SM();
450
451 return *this;
452}
453
454
455const CLASS_TYPE &
456CLASS_TYPE::operator += (unsigned long v)
457{
458 // u = *this
459
460 if (sgn == SC_ZERO) // case 1
461 return (*this = v);
462
463 if (v == 0) // case 2
464 return *this;
465
466 CONVERT_LONG(v);
467
468 // cases 3 and 4
469 add_on_help(sgn, nbits, ndigits, digit,
470 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
471
472 convert_SM_to_2C_to_SM();
473
474 return *this;
475}
476
477
478// ----------------------------------------------------------------------------
479// SECTION: MINUS operators: -, -=, --
480// ----------------------------------------------------------------------------
481
482// Cases to consider when computing u + v:
483// 1. u - 0 = u
484// 2. 0 - v = -v
485// 3. if sgn(u) != sgn(v)
486// 3.1 u - (-v) = u + v = sgn(u) * (u + v)
487// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
488// 4. if sgn(u) == sgn(v)
489// 4.1 u - v = +(u - v) = sgn(u) * (u - v)
490// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
491//
492// Specialization of above cases for computing --u or u--:
493// 1. 0 - 1 = -1
494// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
495// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
496
497const CLASS_TYPE &
498CLASS_TYPE::operator -= (const CLASS_TYPE &v)
499{
500 // u = *this
501 if (v.sgn == SC_ZERO) // case 1
502 return *this;
503 if (sgn == SC_ZERO) { // case 2
504 sgn = -v.sgn;
505 copy_digits(v.nbits, v.ndigits, v.digit);
506 } else {
507 // cases 3 and 4
508 add_on_help(sgn, nbits, ndigits, digit,
509 -v.sgn, v.nbits, v.ndigits, v.digit);
510 convert_SM_to_2C_to_SM();
511 }
512
513 return *this;
514}
515
516
517const CLASS_TYPE &
518CLASS_TYPE::operator -= (const OTHER_CLASS_TYPE &v)
519{
520 // u = *this
521 if (v.sgn == SC_ZERO) // case 1
522 return *this;
523 if (sgn == SC_ZERO) { // case 2
524 sgn = -v.sgn;
525 copy_digits(v.nbits, v.ndigits, v.digit);
526 } else {
527 // cases 3 and 4
528 add_on_help(sgn, nbits, ndigits, digit,
529 -v.sgn, v.nbits, v.ndigits, v.digit);
530
531 convert_SM_to_2C_to_SM();
532 }
533 return *this;
534}
535
536CLASS_TYPE &
537CLASS_TYPE::operator -- () // prefix
538{
539 *this = *this - 1;
540 return *this;
541}
542
543const CLASS_TYPE
544CLASS_TYPE::operator -- (int) // postfix
545{
546 // Copy digit into d.
547#ifdef SC_MAX_NBITS
548 sc_digit d[MAX_NDIGITS];
549#else
550 sc_digit *d = new sc_digit[ndigits];
551#endif
552 small_type s = sgn;
553 vec_copy(ndigits, d, digit);
554 *this = *this - 1;
555 return CLASS_TYPE(s, nbits, ndigits, d);
556}
557
558
559const CLASS_TYPE &
560CLASS_TYPE::operator -= (int64 v)
561{
562 // u = *this
563 if (v == 0) // case 1
564 return *this;
565 if (sgn == SC_ZERO) // case 2
566 return (*this = -v);
567
568 CONVERT_INT64(v);
569
570 // cases 3 and 4
571 add_on_help(sgn, nbits, ndigits, digit,
572 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
573
574 convert_SM_to_2C_to_SM();
575
576 return *this;
577}
578
579
580const CLASS_TYPE &
581CLASS_TYPE::operator -= (uint64 v)
582{
583 // u = *this
584
585 if (v == 0) // case 1
586 return *this;
587
588 int64 v2 = (int64) v;
589
590 if (sgn == SC_ZERO) // case 2
591 return (*this = -v2);
592
593 CONVERT_INT64(v);
594
595 // cases 3 and 4
596 add_on_help(sgn, nbits, ndigits, digit,
597 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
598
599 convert_SM_to_2C_to_SM();
600
601 return *this;
602}
603
604const CLASS_TYPE &
605CLASS_TYPE::operator -= (long v)
606{
607 // u = *this
608
609 if (v == 0) // case 1
610 return *this;
611
612 if (sgn == SC_ZERO) // case 2
613 return (*this = -v);
614
615 CONVERT_LONG(v);
616
617 // cases 3 and 4
618 add_on_help(sgn, nbits, ndigits, digit,
619 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
620
621 convert_SM_to_2C_to_SM();
622
623 return *this;
624}
625
626
627const CLASS_TYPE &
628CLASS_TYPE::operator -= (unsigned long v)
629{
630 // u = *this
631
632 if (v == 0) // case 1
633 return *this;
634
635 long v2 = (long) v;
636
637 if (sgn == SC_ZERO) // case 2
638 return (*this = -v2);
639
640 CONVERT_LONG(v);
641
642 // cases 3 and 4
643 add_on_help(sgn, nbits, ndigits, digit,
644 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
645
646 convert_SM_to_2C_to_SM();
647
648 return *this;
649}
650
651
652// ----------------------------------------------------------------------------
653// SECTION: MULTIPLICATION operators: *, *=
654// ----------------------------------------------------------------------------
655
656// Cases to consider when computing u * v:
657// 1. u * 0 = 0 * v = 0
658// 2. 1 * v = v and -1 * v = -v
659// 3. u * 1 = u and u * -1 = -u
660// 4. u * v = u * v
661
662const CLASS_TYPE &
663CLASS_TYPE::operator *= (const CLASS_TYPE &v)
664{
665 // u = *this
666
667 sgn = mul_signs(sgn, v.sgn);
668
669 if (sgn == SC_ZERO) { // case 1
670 vec_zero(ndigits, digit);
671 } else {
672 // cases 2-4
673 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
674 v.nbits, v.ndigits, v.digit);
675 }
676
677 return *this;
678}
679
680
681const CLASS_TYPE &
682CLASS_TYPE::operator *= (const OTHER_CLASS_TYPE &v)
683{
684 // u = *this
685
686 sgn = mul_signs(sgn, v.sgn);
687
688 if (sgn == SC_ZERO) { // case 1
689 vec_zero(ndigits, digit);
690 } else {
691 // cases 2-4
692 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
693 v.nbits, v.ndigits, v.digit);
694 }
695
696 return *this;
697}
698
699
700const CLASS_TYPE &
701CLASS_TYPE::operator *= (int64 v)
702{
703 // u = *this
704
705 sgn = mul_signs(sgn, get_sign(v));
706
707 if (sgn == SC_ZERO) { // case 1
708 vec_zero(ndigits, digit);
709 } else { // cases 2-4
710 CONVERT_INT64_2(v);
711 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
712 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
713 }
714
715 return *this;
716}
717
718
719const CLASS_TYPE &
720CLASS_TYPE::operator *= (uint64 v)
721{
722 // u = *this
723 sgn = mul_signs(sgn, get_sign(v));
724
725 if (sgn == SC_ZERO) { // case 1
726 vec_zero(ndigits, digit);
727 } else { // cases 2-4
728 CONVERT_INT64_2(v);
729 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
730 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
731 }
732
733 return *this;
734}
735
736
737const CLASS_TYPE &
738CLASS_TYPE::operator *= (long v)
739{
740 // u = *this
741
742 sgn = mul_signs(sgn, get_sign(v));
743
744 if (sgn == SC_ZERO) { // case 1
745 vec_zero(ndigits, digit);
746 } else { // cases 2-4
747 CONVERT_LONG_2(v);
748 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
749 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
750 }
751 return *this;
752}
753
754
755const CLASS_TYPE &
756CLASS_TYPE::operator *= (unsigned long v)
757{
758 // u = *this
759
760 sgn = mul_signs(sgn, get_sign(v));
761
762 if (sgn == SC_ZERO) { // case 1
763 vec_zero(ndigits, digit);
764 } else { // cases 2-4
765 CONVERT_LONG_2(v);
766 MUL_ON_HELPER(sgn, nbits, ndigits, digit,
767 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
768 }
769
770 return *this;
771}
772
773
774// ----------------------------------------------------------------------------
775// SECTION: DIVISION operators: /, /=
776// ----------------------------------------------------------------------------
777
778// Cases to consider when finding the quotient q = floor(u/v):
779// Note that u = q * v + r for r < q.
780// 1. 0 / 0 or u / 0 => error
781// 2. 0 / v => 0 = 0 * v + 0
782// 3. u / v && u = v => u = 1 * u + 0 - u or v can be 1 or -1
783// 4. u / v && u < v => u = 0 * v + u - u can be 1 or -1
784// 5. u / v && u > v => u = q * v + r - v can be 1 or -1
785
786const CLASS_TYPE &
787CLASS_TYPE::operator /= (const CLASS_TYPE &v)
788{
789 sgn = mul_signs(sgn, v.sgn);
790
791 if (sgn == SC_ZERO) {
792 div_by_zero(v.sgn); // case 1
793 vec_zero(ndigits, digit); // case 2
794 } else { // other cases
795 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
796 v.nbits, v.ndigits, v.digit);
797 }
798 return *this;
799}
800
801
802const CLASS_TYPE &
803CLASS_TYPE::operator /= (const OTHER_CLASS_TYPE &v)
804{
805 sgn = mul_signs(sgn, v.sgn);
806
807 if (sgn == SC_ZERO) {
808 div_by_zero(v.sgn); // case 1
809 vec_zero(ndigits, digit); // case 2
810 } else { // other cases
811 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
812 v.nbits, v.ndigits, v.digit);
813 }
814 return *this;
815}
816
817
818const CLASS_TYPE &
819CLASS_TYPE::operator /= (int64 v)
820{
821 // u = *this
822
823 sgn = mul_signs(sgn, get_sign(v));
824
825 if (sgn == SC_ZERO) {
826 div_by_zero(v); // case 1
827 vec_zero(ndigits, digit); // case 2
828 } else {
829 CONVERT_INT64_2(v);
830 // other cases
831 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
832 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
833 }
834 return *this;
835}
836
837
838const CLASS_TYPE &
839CLASS_TYPE::operator /= (uint64 v)
840{
841 // u = *this
842
843 sgn = mul_signs(sgn, get_sign(v));
844
845 if (sgn == SC_ZERO) {
846 div_by_zero(v); // case 1
847 vec_zero(ndigits, digit); // case 2
848 } else {
849 CONVERT_INT64_2(v);
850 // other cases
851 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
852 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
853 }
854 return *this;
855}
856
857
858const CLASS_TYPE &
859CLASS_TYPE::operator /= (long v)
860{
861 // u = *this
862
863 sgn = mul_signs(sgn, get_sign(v));
864
865 if (sgn == SC_ZERO) {
866 div_by_zero(v); // case 1
867 vec_zero(ndigits, digit); // case 2
868 } else {
869 CONVERT_LONG_2(v);
870 // other cases
871 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
872 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
873 }
874 return *this;
875}
876
877
878const CLASS_TYPE &
879CLASS_TYPE::operator /= (unsigned long v)
880{
881 // u = *this
882
883 sgn = mul_signs(sgn, get_sign(v));
884
885 if (sgn == SC_ZERO) {
886 div_by_zero(v); // case 1
887 vec_zero(ndigits, digit); // case 2
888 } else {
889 CONVERT_LONG_2(v);
890 // other cases
891 DIV_ON_HELPER(sgn, nbits, ndigits, digit,
892 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
893 }
894 return *this;
895}
896
897
898// ----------------------------------------------------------------------------
899// SECTION: MOD operators: %, %=.
900// ----------------------------------------------------------------------------
901
902// Cases to consider when finding the remainder r = u % v:
903// Note that u = q * v + r for r < q.
904// 1. 0 % 0 or u % 0 => error
905// 2. 0 % v => 0 = 0 * v + 0
906// 3. u % v && u = v => u = 1 * u + 0 - u or v can be 1 or -1
907// 4. u % v && u < v => u = 0 * v + u - u can be 1 or -1
908// 5. u % v && u > v => u = q * v + r - v can be 1 or -1
909
910const CLASS_TYPE &
911CLASS_TYPE::operator %= (const CLASS_TYPE &v)
912{
913 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
914 div_by_zero(v.sgn); // case 1
915 vec_zero(ndigits, digit); // case 2
916 } else { // other cases
917 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
918 v.nbits, v.ndigits, v.digit);
919 }
920 return *this;
921}
922
923
924const CLASS_TYPE &
925CLASS_TYPE::operator %= (const OTHER_CLASS_TYPE &v)
926{
927 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
928 div_by_zero(v.sgn); // case 1
929 vec_zero(ndigits, digit); // case 2
930 } else { // other cases
931 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
932 v.nbits, v.ndigits, v.digit);
933 }
934
935 return *this;
936}
937
938
939const CLASS_TYPE &
940CLASS_TYPE::operator %= (int64 v)
941{
942 small_type vs = get_sign(v);
943
944 if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
945 div_by_zero(v); // case 1
946 vec_zero(ndigits, digit); // case 2
947 } else {
948 CONVERT_INT64_2(v);
949 // other cases
950 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
951 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
952 }
953 return *this;
954}
955
956
957const CLASS_TYPE &
958CLASS_TYPE::operator %= (uint64 v)
959{
960 if ((sgn == SC_ZERO) || (v == 0)) {
961 div_by_zero(v); // case 1
962 vec_zero(ndigits, digit); // case 2
963 } else {
964 CONVERT_INT64_2(v);
965 // other cases
966 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
967 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
968
969 }
970 return *this;
971}
972
973
974const CLASS_TYPE &
975CLASS_TYPE::operator %= (long v)
976{
977 small_type vs = get_sign(v);
978
979 if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
980 div_by_zero(v); // case 1
981 vec_zero(ndigits, digit); // case 2
982 } else {
983 CONVERT_LONG_2(v);
984 // other cases
985 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
986 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
987 }
988 return *this;
989}
990
991
992const CLASS_TYPE &
993CLASS_TYPE::operator %= (unsigned long v)
994{
995 if ((sgn == SC_ZERO) || (v == 0)) {
996 div_by_zero(v); // case 1
997 vec_zero(ndigits, digit); // case 2
998 } else {
999 CONVERT_LONG_2(v);
1000 // other cases
1001 MOD_ON_HELPER(sgn, nbits, ndigits, digit,
1002 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1003 }
1004 return *this;
1005}
1006
1007
1008// ----------------------------------------------------------------------------
1009// SECTION: Bitwise AND operators: &, &=
1010// ----------------------------------------------------------------------------
1011
1012// Cases to consider when computing u &v:
1013// 1. u & 0 = 0 &v = 0
1014// 2. u &v => sgn = +
1015// 3. (-u) & (-v) => sgn = -
1016// 4. u & (-v) => sgn = +
1017// 5. (-u) &v => sgn = +
1018
1019const CLASS_TYPE &
1020CLASS_TYPE::operator &= (const CLASS_TYPE &v)
1021{
1022 // u = *this
1023 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { // case 1
1024 makezero();
1025 } else { // other cases
1026 and_on_help(sgn, nbits, ndigits, digit,
1027 v.sgn, v.nbits, v.ndigits, v.digit);
1028 convert_2C_to_SM();
1029 }
1030 return *this;
1031}
1032
1033
1034const CLASS_TYPE &
1035CLASS_TYPE::operator &= (const OTHER_CLASS_TYPE &v)
1036{
1037 // u = *this
1038
1039 if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { // case 1
1040 makezero();
1041 } else { // other cases
1042 and_on_help(sgn, nbits, ndigits, digit,
1043 v.sgn, v.nbits, v.ndigits, v.digit);
1044 convert_2C_to_SM();
1045 }
1046 return *this;
1047}
1048
1049
1050const CLASS_TYPE &
1051CLASS_TYPE::operator &= (int64 v)
1052{
1053 // u = *this
1054 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1055 makezero();
1056 } else { // other cases
1057 CONVERT_INT64(v);
1058 and_on_help(sgn, nbits, ndigits, digit,
1059 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1060 convert_2C_to_SM();
1061 }
1062 return *this;
1063}
1064
1065
1066const CLASS_TYPE &
1067CLASS_TYPE::operator &= (uint64 v)
1068{
1069 // u = *this
1070 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1071 makezero();
1072 } else { // other cases
1073 CONVERT_INT64(v);
1074 and_on_help(sgn, nbits, ndigits, digit,
1075 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1076 convert_2C_to_SM();
1077 }
1078 return *this;
1079}
1080
1081
1082const CLASS_TYPE &
1083CLASS_TYPE::operator &= (long v)
1084{
1085 // u = *this
1086
1087 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1088 makezero();
1089 } else { // other cases
1090 CONVERT_LONG(v);
1091 and_on_help(sgn, nbits, ndigits, digit,
1092 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1093 convert_2C_to_SM();
1094 }
1095
1096 return *this;
1097}
1098
1099
1100const CLASS_TYPE &
1101CLASS_TYPE::operator &= (unsigned long v)
1102{
1103 // u = *this
1104 if ((sgn == SC_ZERO) || (v == 0)) { // case 1
1105 makezero();
1106 } else { // other cases
1107 CONVERT_LONG(v);
1108 and_on_help(sgn, nbits, ndigits, digit,
1109 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1110 convert_2C_to_SM();
1111 }
1112 return *this;
1113}
1114
1115
1116// ----------------------------------------------------------------------------
1117// SECTION: Bitwise OR operators: |, |=
1118// ----------------------------------------------------------------------------
1119
1120// Cases to consider when computing u | v:
1121// 1. u | 0 = u
1122// 2. 0 | v = v
1123// 3. u | v => sgn = +
1124// 4. (-u) | (-v) => sgn = -
1125// 5. u | (-v) => sgn = -
1126// 6. (-u) | v => sgn = -
1127
1128const CLASS_TYPE &
1129CLASS_TYPE::operator |= (const CLASS_TYPE &v)
1130{
1131 if (v.sgn == SC_ZERO) // case 1
1132 return *this;
1133 if (sgn == SC_ZERO) // case 2
1134 return (*this = v);
1135 // other cases
1136 or_on_help(sgn, nbits, ndigits, digit,
1137 v.sgn, v.nbits, v.ndigits, v.digit);
1138 convert_2C_to_SM();
1139 return *this;
1140}
1141
1142
1143const CLASS_TYPE &
1144CLASS_TYPE::operator |= (const OTHER_CLASS_TYPE &v)
1145{
1146 if (v.sgn == SC_ZERO) // case 1
1147 return *this;
1148 if (sgn == SC_ZERO) // case 2
1149 return (*this = v);
1150 // other cases
1151 or_on_help(sgn, nbits, ndigits, digit,
1152 v.sgn, v.nbits, v.ndigits, v.digit);
1153 convert_2C_to_SM();
1154 return *this;
1155}
1156
1157
1158const CLASS_TYPE&
1159CLASS_TYPE::operator |= (int64 v)
1160{
1161 if (v == 0) // case 1
1162 return *this;
1163 if (sgn == SC_ZERO) // case 2
1164 return (*this = v);
1165 // other cases
1166 CONVERT_INT64(v);
1167 or_on_help(sgn, nbits, ndigits, digit,
1168 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1169 convert_2C_to_SM();
1170 return *this;
1171}
1172
1173
1174const CLASS_TYPE&
1175CLASS_TYPE::operator |= (uint64 v)
1176{
1177 if (v == 0) // case 1
1178 return *this;
1179 if (sgn == SC_ZERO) // case 2
1180 return (*this = v);
1181 // other cases
1182 CONVERT_INT64(v);
1183 or_on_help(sgn, nbits, ndigits, digit,
1184 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1185 convert_2C_to_SM();
1186 return *this;
1187}
1188
1189
1190const CLASS_TYPE &
1191CLASS_TYPE::operator |= (long v)
1192{
1193 if (v == 0) // case 1
1194 return *this;
1195 if (sgn == SC_ZERO) // case 2
1196 return (*this = v);
1197 // other cases
1198 CONVERT_LONG(v);
1199 or_on_help(sgn, nbits, ndigits, digit,
1200 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1201 convert_2C_to_SM();
1202 return *this;
1203}
1204
1205
1206const CLASS_TYPE &
1207CLASS_TYPE::operator |= (unsigned long v)
1208{
1209 if (v == 0) // case 1
1210 return *this;
1211 if (sgn == SC_ZERO) // case 2
1212 return (*this = v);
1213 // other cases
1214 CONVERT_LONG(v);
1215 or_on_help(sgn, nbits, ndigits, digit,
1216 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1217 convert_2C_to_SM();
1218 return *this;
1219}
1220
1221
1222// ----------------------------------------------------------------------------
1223// SECTION: Bitwise XOR operators: ^, ^=
1224// ----------------------------------------------------------------------------
1225
1226// Cases to consider when computing u ^ v:
1227// Note that u ^ v = (~u &v) | (u & ~v).
1228// 1. u ^ 0 = u
1229// 2. 0 ^ v = v
1230// 3. u ^ v => sgn = +
1231// 4. (-u) ^ (-v) => sgn = -
1232// 5. u ^ (-v) => sgn = -
1233// 6. (-u) ^ v => sgn = +
1234
1235const CLASS_TYPE &
1236CLASS_TYPE::operator ^= (const CLASS_TYPE &v)
1237{
1238 // u = *this
1239 if (v.sgn == SC_ZERO) // case 1
1240 return *this;
1241 if (sgn == SC_ZERO) // case 2
1242 return (*this = v);
1243 // other cases
1244 xor_on_help(sgn, nbits, ndigits, digit,
1245 v.sgn, v.nbits, v.ndigits, v.digit);
1246 convert_2C_to_SM();
1247 return *this;
1248}
1249
1250
1251const CLASS_TYPE &
1252CLASS_TYPE::operator ^= (const OTHER_CLASS_TYPE &v)
1253{
1254 // u = *this
1255 if (v.sgn == SC_ZERO) // case 1
1256 return *this;
1257 if (sgn == SC_ZERO) // case 2
1258 return (*this = v);
1259 // other cases
1260 xor_on_help(sgn, nbits, ndigits, digit,
1261 v.sgn, v.nbits, v.ndigits, v.digit);
1262 convert_2C_to_SM();
1263 return *this;
1264}
1265
1266
1267const CLASS_TYPE&
1268CLASS_TYPE::operator ^= (int64 v)
1269{
1270 if (v == 0) // case 1
1271 return *this;
1272 if (sgn == SC_ZERO) // case 2
1273 return (*this = v);
1274 // other cases
1275 CONVERT_INT64(v);
1276 xor_on_help(sgn, nbits, ndigits, digit,
1277 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1278 convert_2C_to_SM();
1279 return *this;
1280}
1281
1282
1283const CLASS_TYPE &
1284CLASS_TYPE::operator ^= (uint64 v)
1285{
1286 if (v == 0) // case 1
1287 return *this;
1288 if (sgn == SC_ZERO) // case 2
1289 return (*this = v);
1290 // other cases
1291 CONVERT_INT64(v);
1292 xor_on_help(sgn, nbits, ndigits, digit,
1293 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1294 convert_2C_to_SM();
1295 return *this;
1296}
1297
1298
1299const CLASS_TYPE &
1300CLASS_TYPE::operator ^= (long v)
1301{
1302 if (v == 0) // case 1
1303 return *this;
1304 if (sgn == SC_ZERO) // case 2
1305 return (*this = v);
1306 // other cases
1307 CONVERT_LONG(v);
1308 xor_on_help(sgn, nbits, ndigits, digit,
1309 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1310 convert_2C_to_SM();
1311 return *this;
1312}
1313
1314
1315const CLASS_TYPE &
1316CLASS_TYPE::operator ^= (unsigned long v)
1317{
1318 if (v == 0) // case 1
1319 return *this;
1320 if (sgn == SC_ZERO) // case 2
1321 return (*this = v);
1322 // other cases
1323 CONVERT_LONG(v);
1324 xor_on_help(sgn, nbits, ndigits, digit,
1325 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1326 convert_2C_to_SM();
1327 return *this;
1328}
1329
1330
1331// ----------------------------------------------------------------------------
1332// SECTION: Bitwise NOT operator: ~
1333// ----------------------------------------------------------------------------
1334
1335CLASS_TYPE
1336operator ~ (const CLASS_TYPE &u)
1337{
1338 small_type s = u.sgn;
1339 if (s == SC_ZERO) {
1340 sc_digit d = 1;
1341 return CLASS_TYPE(SC_NEG, u.nbits, 1, &d, false);
1342 }
1343
1344 int nd = u.ndigits;
1345
1346#ifdef SC_MAX_NBITS
1347 sc_digit d[MAX_NDIGITS];
1348#else
1349 sc_digit *d = new sc_digit[nd];
1350#endif
1351
1352 vec_copy(nd, d, u.digit);
1353 if (s == SC_POS) {
1354 s = SC_NEG;
1355 vec_add_small_on(nd, d, 1);
1356 } else {
1357 s = SC_POS;
1358 vec_sub_small_on(nd, d, 1);
1359 if (check_for_zero(nd, d))
1360 s = SC_ZERO;
1361 }
1362 return CLASS_TYPE(s, u.nbits, nd, d);
1363}
1364
1365
1366// ----------------------------------------------------------------------------
1367// SECTION: LEFT SHIFT operators: <<, <<=
1368// ----------------------------------------------------------------------------
1369
1370CLASS_TYPE
1371operator << (const CLASS_TYPE &u, const CLASS_TYPE &v)
1372{
1373 if (v.sgn == SC_ZERO)
1374 return CLASS_TYPE(u);
1375#ifdef SC_SIGNED
1376 if (v.sgn == SC_NEG)
1377 return CLASS_TYPE(u);
1378#endif
1379 return operator << (u, v.to_ulong());
1380}
1381
1382
1383const CLASS_TYPE &
1384CLASS_TYPE::operator <<= (const CLASS_TYPE &v)
1385{
1386 if (v.sgn == SC_ZERO)
1387 return *this;
1388#ifdef SC_SIGNED
1389 if (v.sgn == SC_NEG)
1390 return *this;
1391#endif
1392 return operator <<= (v.to_ulong());
1393}
1394
1395
1396const CLASS_TYPE &
1397CLASS_TYPE::operator <<= (const OTHER_CLASS_TYPE &v)
1398{
1399 if (v.sgn == SC_ZERO)
1400 return *this;
1401#ifdef SC_UNSIGNED
1402 if (v.sgn == SC_NEG)
1403 return *this;
1404#endif
1405 return operator <<= (v.to_ulong());
1406}
1407
1408
1409CLASS_TYPE
1410operator << (const CLASS_TYPE &u, int64 v)
1411{
1412 if (v <= 0)
1413 return CLASS_TYPE(u);
1414 return operator << (u, (unsigned long)v);
1415}
1416
1417
1418CLASS_TYPE
1419operator << (const CLASS_TYPE &u, uint64 v)
1420{
1421 if (v == 0)
1422 return CLASS_TYPE(u);
1423 return operator << (u, (unsigned long)v);
1424}
1425
1426
1427const CLASS_TYPE &
1428CLASS_TYPE::operator <<= (int64 v)
1429{
1430 if (v <= 0)
1431 return *this;
1432 return operator <<= ((unsigned long)v);
1433}
1434
1435
1436const CLASS_TYPE &
1437CLASS_TYPE::operator <<= (uint64 v)
1438{
1439 if (v == 0)
1440 return *this;
1441 return operator <<= ((unsigned long)v);
1442}
1443
1444
1445CLASS_TYPE
1446operator << (const CLASS_TYPE &u, long v)
1447{
1448 if (v <= 0)
1449 return CLASS_TYPE(u);
1450 return operator << (u, (unsigned long)v);
1451}
1452
1453CLASS_TYPE
1454operator << (const CLASS_TYPE &u, unsigned long v)
1455{
1456 if (v == 0)
1457 return CLASS_TYPE(u);
1458 if (u.sgn == SC_ZERO)
1459 return CLASS_TYPE(u);
1460
1461 int nb = u.nbits + v;
1462 int nd = DIV_CEIL(nb);
1463
1464#ifdef SC_MAX_NBITS
1465 test_bound(nb);
1466 sc_digit d[MAX_NDIGITS];
1467#else
1468 sc_digit *d = new sc_digit[nd];
1469#endif
1470
1471 vec_copy_and_zero(nd, d, u.ndigits, u.digit);
1472 convert_SM_to_2C(u.sgn, nd, d);
1473 vec_shift_left(nd, d, v);
1474 small_type s = convert_signed_2C_to_SM(nb, nd, d);
1475 return CLASS_TYPE(s, nb, nd, d);
1476}
1477
1478
1479const CLASS_TYPE &
1480CLASS_TYPE::operator <<= (long v)
1481{
1482 if (v <= 0)
1483 return *this;
1484 return operator <<= ((unsigned long)v);
1485}
1486
1487
1488const CLASS_TYPE &
1489CLASS_TYPE::operator <<= (unsigned long v)
1490{
1491 if (v == 0)
1492 return *this;
1493 if (sgn == SC_ZERO)
1494 return *this;
1495 convert_SM_to_2C();
1496 vec_shift_left(ndigits, digit, v);
1497 convert_2C_to_SM();
1498 return *this;
1499}
1500
1501
1502// ----------------------------------------------------------------------------
1503// SECTION: RIGHT SHIFT operators: >>, >>=
1504// ----------------------------------------------------------------------------
1505
1506CLASS_TYPE
1507operator >> (const CLASS_TYPE &u, const CLASS_TYPE &v)
1508{
1509 if (v.sgn == SC_ZERO)
1510 return CLASS_TYPE(u);
1511#ifdef SC_SIGNED
1512 if (v.sgn == SC_NEG)
1513 return CLASS_TYPE(u);
1514#endif
1515 return operator >> (u, v.to_long());
1516}
1517
1518
1519const CLASS_TYPE &
1520CLASS_TYPE::operator >>= (const CLASS_TYPE &v)
1521{
1522 if (v.sgn == SC_ZERO)
1523 return *this;
1524#ifdef SC_SIGNED
1525 if (v.sgn == SC_NEG)
1526 return *this;
1527#endif
1528 return operator >>= (v.to_long());
1529}
1530
1531
1532const CLASS_TYPE &
1533CLASS_TYPE::operator >>= (const OTHER_CLASS_TYPE &v)
1534{
1535 if (v.sgn == SC_ZERO)
1536 return *this;
1537#ifdef SC_UNSIGNED
1538 if (v.sgn == SC_NEG)
1539 return *this;
1540#endif
1541 return operator >>= (v.to_ulong());
1542}
1543
1544
1545CLASS_TYPE
1546operator >> (const CLASS_TYPE &u, int64 v)
1547{
1548 if (v <= 0)
1549 return CLASS_TYPE(u);
1550 return operator >> (u, (unsigned long)v);
1551}
1552
1553
1554CLASS_TYPE
1555operator >> (const CLASS_TYPE &u, uint64 v)
1556{
1557 if (v == 0)
1558 return CLASS_TYPE(u);
1559 return operator >> (u, (unsigned long)v);
1560}
1561
1562const CLASS_TYPE &
1563CLASS_TYPE::operator >>= (int64 v)
1564{
1565 if (v <= 0)
1566 return *this;
1567 return operator >>= ((unsigned long)v);
1568}
1569
1570
1571const CLASS_TYPE &
1572CLASS_TYPE::operator >>= (uint64 v)
1573{
1574 if (v == 0)
1575 return *this;
1576 return operator >>= ((unsigned long)v);
1577}
1578
1579
1580CLASS_TYPE
1581operator >> (const CLASS_TYPE &u, long v)
1582{
1583 if (v <= 0)
1584 return CLASS_TYPE(u);
1585 return operator >> (u, (unsigned long)v);
1586}
1587
1588
1589CLASS_TYPE
1590operator >> (const CLASS_TYPE &u, unsigned long v)
1591{
1592 if (v == 0)
1593 return CLASS_TYPE(u);
1594 if (u.sgn == SC_ZERO)
1595 return CLASS_TYPE(u);
1596
1597 int nb = u.nbits;
1598 int nd = u.ndigits;
1599
1600#ifdef SC_MAX_NBITS
1601 sc_digit d[MAX_NDIGITS];
1602#else
1603 sc_digit *d = new sc_digit[nd];
1604#endif
1605
1606 vec_copy(nd, d, u.digit);
1607 convert_SM_to_2C(u.sgn, nd, d);
1608 if (u.sgn == SC_NEG)
1609 vec_shift_right(nd, d, v, DIGIT_MASK);
1610 else
1611 vec_shift_right(nd, d, v, 0);
1612 small_type s = convert_signed_2C_to_SM(nb, nd, d);
1613 return CLASS_TYPE(s, nb, nd, d);
1614}
1615
1616
1617const CLASS_TYPE &
1618CLASS_TYPE::operator >>= (long v)
1619{
1620 if (v <= 0)
1621 return *this;
1622 return operator >>= ((unsigned long)v);
1623}
1624
1625
1626const CLASS_TYPE &
1627CLASS_TYPE::operator >>= (unsigned long v)
1628{
1629 if (v == 0)
1630 return *this;
1631 if (sgn == SC_ZERO)
1632 return *this;
1633
1634 convert_SM_to_2C();
1635
1636 if (sgn == SC_NEG)
1637 vec_shift_right(ndigits, digit, v, DIGIT_MASK);
1638 else
1639 vec_shift_right(ndigits, digit, v, 0);
1640 convert_2C_to_SM();
1641 return *this;
1642}
1643
1644
1645// ----------------------------------------------------------------------------
1646// SECTION: EQUAL TO operator: ==
1647// ----------------------------------------------------------------------------
1648
1649// Defined in the sc_signed.cpp and sc_unsigned.cpp.
1650
1651
1652// ----------------------------------------------------------------------------
1653// SECTION: NOT_EQUAL operator: !=
1654// ----------------------------------------------------------------------------
1655
1656bool
1657operator != (const CLASS_TYPE &u, const CLASS_TYPE &v)
1658{
1659 return (!operator == (u, v));
1660}
1661
1662
1663bool
1664operator != (const CLASS_TYPE &u, int64 v)
1665{
1666 return (!operator == (u, v));
1667}
1668
1669
1670bool
1671operator != (int64 u, const CLASS_TYPE &v)
1672{
1673 return (!operator == (u, v));
1674}
1675
1676
1677bool
1678operator != (const CLASS_TYPE &u, uint64 v)
1679{
1680 return (!operator == (u, v));
1681}
1682
1683
1684bool
1685operator != (uint64 u, const CLASS_TYPE &v)
1686{
1687 return (!operator == (u, v));
1688}
1689
1690
1691bool
1692operator != (const CLASS_TYPE &u, long v)
1693{
1694 return (!operator == (u, v));
1695}
1696
1697
1698bool
1699operator != (long u, const CLASS_TYPE &v)
1700{
1701 return (!operator == (u, v));
1702}
1703
1704
1705bool
1706operator != (const CLASS_TYPE &u, unsigned long v)
1707{
1708 return (!operator == (u, v));
1709}
1710
1711
1712bool
1713operator != (unsigned long u, const CLASS_TYPE &v)
1714{
1715 return (!operator == (u, v));
1716}
1717
1718
1719// ----------------------------------------------------------------------------
1720// SECTION: LESS THAN operator: <
1721// ----------------------------------------------------------------------------
1722
1723// Defined in the sc_signed.cpp and sc_unsigned.cpp.
1724
1725
1726// ----------------------------------------------------------------------------
1727// SECTION: LESS THAN or EQUAL operator: <=
1728// ----------------------------------------------------------------------------
1729
1730bool
1731operator <= (const CLASS_TYPE &u, const CLASS_TYPE &v)
1732{
1733 return (operator < (u, v) || operator == (u, v));
1734}
1735
1736
1737bool
1738operator <= (const CLASS_TYPE &u, int64 v)
1739{
1740 return (operator < (u, v) || operator == (u, v));
1741}
1742
1743
1744bool
1745operator <= (int64 u, const CLASS_TYPE &v)
1746{
1747 return (operator < (u, v) || operator == (u, v));
1748}
1749
1750
1751bool
1752operator <= (const CLASS_TYPE &u, uint64 v)
1753{
1754 return (operator < (u, v) || operator == (u, v));
1755}
1756
1757
1758bool
1759operator <= (uint64 u, const CLASS_TYPE &v)
1760{
1761 return (operator < (u, v) || operator == (u, v));
1762}
1763
1764
1765bool
1766operator <= (const CLASS_TYPE &u, long v)
1767{
1768 return (operator < (u, v) || operator == (u, v));
1769}
1770
1771
1772bool
1773operator <= (long u, const CLASS_TYPE &v)
1774{
1775 return (operator < (u, v) || operator == (u, v));
1776}
1777
1778
1779bool
1780operator <= (const CLASS_TYPE &u, unsigned long v)
1781{
1782 return (operator < (u, v) || operator == (u, v));
1783}
1784
1785
1786bool
1787operator <= (unsigned long u, const CLASS_TYPE &v)
1788{
1789 return (operator < (u, v) || operator == (u, v));
1790}
1791
1792
1793// ----------------------------------------------------------------------------
1794// SECTION: GREATER THAN operator: >
1795// ----------------------------------------------------------------------------
1796
1797bool
1798operator > (const CLASS_TYPE &u, const CLASS_TYPE &v)
1799{
1800 return (!(operator <= (u, v)));
1801}
1802
1803
1804bool
1805operator > (const CLASS_TYPE &u, int64 v)
1806{
1807 return (!(operator <= (u, v)));
1808}
1809
1810
1811bool
1812operator > (int64 u, const CLASS_TYPE &v)
1813{
1814 return (!(operator <= (u, v)));
1815}
1816
1817
1818bool
1819operator > (const CLASS_TYPE &u, uint64 v)
1820{
1821 return (!(operator <= (u, v)));
1822}
1823
1824
1825bool
1826operator > (uint64 u, const CLASS_TYPE &v)
1827{
1828 return (!(operator <= (u, v)));
1829}
1830
1831
1832bool
1833operator > (const CLASS_TYPE &u, long v)
1834{
1835 return (!(operator <= (u, v)));
1836}
1837
1838
1839bool
1840operator > (long u, const CLASS_TYPE &v)
1841{
1842 return (!(operator <= (u, v)));
1843}
1844
1845
1846bool
1847operator > (const CLASS_TYPE &u, unsigned long v)
1848{
1849 return (!(operator <= (u, v)));
1850}
1851
1852
1853bool
1854operator > (unsigned long u, const CLASS_TYPE &v)
1855{
1856 return (!(operator <= (u, v)));
1857}
1858
1859
1860// ----------------------------------------------------------------------------
1861// SECTION: GREATER THAN or EQUAL operator: >=
1862// ----------------------------------------------------------------------------
1863
1864bool
1865operator >= (const CLASS_TYPE &u, const CLASS_TYPE &v)
1866{
1867 return (!(operator < (u, v)));
1868}
1869
1870
1871bool
1872operator >= (const CLASS_TYPE &u, int64 v)
1873{
1874 return (!(operator < (u, v)));
1875}
1876
1877
1878bool
1879operator >= (int64 u, const CLASS_TYPE &v)
1880{
1881 return (!(operator < (u, v)));
1882}
1883
1884
1885bool
1886operator >= (const CLASS_TYPE &u, uint64 v)
1887{
1888 return (!(operator < (u, v)));
1889}
1890
1891
1892bool
1893operator >= (uint64 u, const CLASS_TYPE &v)
1894{
1895 return (!(operator < (u, v)));
1896}
1897
1898
1899bool
1900operator >= (const CLASS_TYPE &u, long v)
1901{
1902 return (!(operator < (u, v)));
1903}
1904
1905
1906bool
1907operator >= (long u, const CLASS_TYPE &v)
1908{
1909 return (!(operator < (u, v)));
1910}
1911
1912
1913bool
1914operator >= (const CLASS_TYPE &u, unsigned long v)
1915{
1916 return (!(operator < (u, v)));
1917}
1918
1919
1920bool
1921operator >= (unsigned long u, const CLASS_TYPE &v)
1922{
1923 return (!(operator < (u, v)));
1924}
1925
1926
1927// ----------------------------------------------------------------------------
1928// SECTION: Public members - Other utils.
1929// ----------------------------------------------------------------------------
1930
1931// Convert to int64, long, or int.
1932#define TO_INTX(RET_TYPE, UP_RET_TYPE) \
1933if (sgn == SC_ZERO) \
1934 return 0; \
1935int vnd = sc_min((int)DIGITS_PER_ ## UP_RET_TYPE, ndigits); \
1936RET_TYPE v = 0; \
1937while (--vnd >= 0) \
1938 v = (v << BITS_PER_DIGIT) + digit[vnd]; \
1939if (sgn == SC_NEG) \
1940 return -v; \
1941else \
1942 return v;
1943
1944
1945int64
1946CLASS_TYPE::to_int64() const
1947{
1948 TO_INTX(int64, INT64);
1949}
1950
1951
1952long
1953CLASS_TYPE::to_long() const
1954{
1955 TO_INTX(long, LONG);
1956}
1957
1958
1959int
1960CLASS_TYPE::to_int() const
1961{
1962 TO_INTX(int, INT);
1963}
1964
1965
1966// Convert to unsigned int64, unsigned long or unsigned
1967// int. to_uint64, to_ulong, and to_uint have the same body except for
1968// the type of v defined inside.
1969uint64
1970CLASS_TYPE::to_uint64() const
1971{
1972 if (sgn == SC_ZERO)
1973 return 0;
1974
1975 int vnd = sc_min((int)DIGITS_PER_INT64, ndigits);
1976
1977 uint64 v = 0;
1978
1979 if (sgn == SC_NEG) {
1980#ifdef SC_MAX_NBITS
1981 sc_digit d[MAX_NDIGITS];
1982#else
1983 sc_digit *d = new sc_digit[ndigits];
1984#endif
1985 vec_copy(ndigits, d, digit);
1986 convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
1987 while (--vnd >= 0)
1988 v = (v << BITS_PER_DIGIT) + d[vnd];
1989#ifndef SC_MAX_NBITS
1990 delete [] d;
1991#endif
1992 } else {
1993 while (--vnd >= 0)
1994 v = (v << BITS_PER_DIGIT) + digit[vnd];
1995 }
1996 return v;
1997}
1998
1999
2000unsigned long
2001CLASS_TYPE::to_ulong() const
2002{
2003 if (sgn == SC_ZERO)
2004 return 0;
2005
2006 int vnd = sc_min((int)DIGITS_PER_LONG, ndigits);
2007 unsigned long v = 0;
2008
2009 if (sgn == SC_NEG) {
2010#ifdef SC_MAX_NBITS
2011 sc_digit d[MAX_NDIGITS];
2012#else
2013 sc_digit *d = new sc_digit[ndigits];
2014#endif
2015 vec_copy(ndigits, d, digit);
2016 convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
2017 while (--vnd >= 0)
2018 v = (v << BITS_PER_DIGIT) + d[vnd];
2019#ifndef SC_MAX_NBITS
2020 delete [] d;
2021#endif
2022 } else {
2023 while (--vnd >= 0)
2024 v = (v << BITS_PER_DIGIT) + digit[vnd];
2025 }
2026 return v;
2027}
2028
2029
2030unsigned int
2031CLASS_TYPE::to_uint() const
2032{
2033 if (sgn == SC_ZERO)
2034 return 0;
2035
2036 int vnd = sc_min((int)DIGITS_PER_INT, ndigits);
2037 unsigned int v = 0;
2038 if (sgn == SC_NEG) {
2039#ifdef SC_MAX_NBITS
2040 sc_digit d[MAX_NDIGITS];
2041#else
2042 sc_digit *d = new sc_digit[ndigits];
2043#endif
2044 vec_copy(ndigits, d, digit);
2045 convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
2046 while (--vnd >= 0)
2047 v = (v << BITS_PER_DIGIT) + d[vnd];
2048#ifndef SC_MAX_NBITS
2049 delete [] d;
2050#endif
2051 } else {
2052 while (--vnd >= 0)
2053 v = (v << BITS_PER_DIGIT) + digit[vnd];
2054 }
2055 return v;
2056}
2057
2058
2059// Convert to double.
2060double
2061CLASS_TYPE::to_double() const
2062{
2063 if (sgn == SC_ZERO)
2064 return (double) 0.0;
2065
2066 int vnd = ndigits;
2067 double v = 0.0;
2068 while (--vnd >= 0)
2069 v = v * DIGIT_RADIX + digit[vnd];
2070 if (sgn == SC_NEG)
2071 return -v;
2072 else
2073 return v;
2074}
2075
2076
2077// Return true if the bit i is 1, false otherwise. If i is outside the
2078// bounds, return 1/0 according to the sign of the number by assuming
2079// that the number has infinite length.
2080
2081bool
2082CLASS_TYPE::test(int i) const
2083{
2084#ifdef SC_SIGNED
2085 if (check_if_outside(i)) {
2086 if (sgn == SC_NEG)
2087 return 1;
2088 else
2089 return 0;
2090 }
2091#else
2092 if (check_if_outside(i))
2093 return 0;
2094#endif
2095
2096 int bit_num = bit_ord(i);
2097 int digit_num = digit_ord(i);
2098
2099 if (sgn == SC_NEG) {
2100#ifdef SC_MAX_NBITS
2101 sc_digit d[MAX_NDIGITS];
2102#else
2103 sc_digit *d = new sc_digit[ndigits];
2104#endif
2105 vec_copy(ndigits, d, digit);
2106 vec_complement(ndigits, d);
2107 bool val = ((d[digit_num] & one_and_zeros(bit_num)) != 0);
2108#ifndef SC_MAX_NBITS
2109 delete [] d;
2110#endif
2111 return val;
2112 } else {
2113 return ((digit[digit_num] & one_and_zeros(bit_num)) != 0);
2114 }
2115}
2116
2117
2118// Set the ith bit with 1.
2119void
2120CLASS_TYPE::set(int i)
2121{
2122 if (check_if_outside(i))
2123 return;
2124
2125 int bit_num = bit_ord(i);
2126 int digit_num = digit_ord(i);
2127
2128 convert_SM_to_2C();
2129 digit[digit_num] |= one_and_zeros(bit_num);
2130 digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
2131 convert_2C_to_SM();
2132}
2133
2134
2135// Set the ith bit with 0, i.e., clear the ith bit.
2136void
2137CLASS_TYPE::clear(int i)
2138{
2139 if (check_if_outside(i))
2140 return;
2141
2142 int bit_num = bit_ord(i);
2143 int digit_num = digit_ord(i);
2144
2145 convert_SM_to_2C();
2146 digit[digit_num] &= ~(one_and_zeros(bit_num));
2147 digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
2148 convert_2C_to_SM();
2149}
2150
2151
2152// Create a mirror image of the number.
2153void
2154CLASS_TYPE::reverse()
2155{
2156 convert_SM_to_2C();
2157 vec_reverse(length(), ndigits, digit, length() - 1);
2158 convert_2C_to_SM();
2159}
2160
2161
2162// Get a packed bit representation of the number.
2163void
2164CLASS_TYPE::get_packed_rep(sc_digit *buf) const
2165{
2166 int buf_ndigits = (length() - 1) / BITS_PER_DIGIT_TYPE + 1;
2167 // Initialize buf to zero.
2168 vec_zero(buf_ndigits, buf);
2169
2170 if (sgn == SC_ZERO)
2171 return;
2172
2173 const sc_digit *digit_or_d;
2174#ifdef SC_MAX_NBITS
2175 sc_digit d[MAX_NDIGITS];
2176#else
2177 sc_digit *d = new sc_digit[ndigits];
2178#endif
2179
2180 if (sgn == SC_POS) {
2181 digit_or_d = digit;
2182 } else {
2183 // If sgn is negative, we have to convert digit to its 2's
2184 // complement. Since this function is const, we can not do it on
2185 // digit. Since buf doesn't have overflow bits, we cannot also do
2186 // it on buf. Thus, we have to do the complementation on a copy of
2187 // digit, i.e., on d.
2188
2189 vec_copy(ndigits, d, digit);
2190 vec_complement(ndigits, d);
2191 buf[buf_ndigits - 1] = ~((sc_digit) 0);
2192 digit_or_d = d;
2193 }
2194
2195 // Copy the bits from digit to buf. The division and mod operations
2196 // below can be converted to addition/subtraction and comparison
2197 // operations at the expense of complicating the code. We can do it
2198 // if we see any performance problems.
2199
2200 for (int i = length() - 1; i >= 0; --i) {
2201
2202 if ((digit_or_d[digit_ord(i)] &
2203 one_and_zeros(bit_ord(i))) != 0) { // Test.
2204 buf[i / BITS_PER_DIGIT_TYPE] |=
2205 one_and_zeros(i % BITS_PER_DIGIT_TYPE); // Set.
2206 } else {
2207 buf[i / BITS_PER_DIGIT_TYPE] &=
2208 ~(one_and_zeros(i % BITS_PER_DIGIT_TYPE)); // Clear.
2209 }
2210 }
2211
2212#ifndef SC_MAX_NBITS
2213 delete[] d;
2214#endif
2215}
2216
2217
2218// Set a packed bit representation of the number.
2219void
2220CLASS_TYPE::set_packed_rep(sc_digit *buf)
2221{
2222 // Initialize digit to zero.
2223 vec_zero(ndigits, digit);
2224
2225 // Copy the bits from buf to digit.
2226 for (int i = length() - 1; i >= 0; --i) {
2227 if ((buf[i / BITS_PER_DIGIT_TYPE] &
2228 one_and_zeros(i % BITS_PER_DIGIT_TYPE)) != 0) { // Test.
2229 digit[digit_ord(i)] |= one_and_zeros(bit_ord(i)); // Set.
2230 } else {
2231 digit[digit_ord(i)] &= ~(one_and_zeros(bit_ord(i))); // Clear
2232 }
2233 }
2234 convert_2C_to_SM();
2235}
2236
2237
2238// ----------------------------------------------------------------------------
2239// SECTION: Private members.
2240// ----------------------------------------------------------------------------
2241
2242// Create a copy of v with sgn s.
2243CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE &v, small_type s) :
2244 sc_value_base(v), sgn(s), nbits(v.nbits), ndigits(v.ndigits), digit()
2245{
2246#ifndef SC_MAX_NBITS
2247 digit = new sc_digit[ndigits];
2248#endif
2249 vec_copy(ndigits, digit, v.digit);
2250}
2251
2252
2253// Create a copy of v where v is of the different type.
2254CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE &v, small_type s) :
2255 sc_value_base(v), sgn(s), nbits(num_bits(v.nbits)), ndigits(), digit()
2256{
2257#if (IF_SC_SIGNED == 1)
2258 ndigits = v.ndigits;
2259#else
2260 ndigits = DIV_CEIL(nbits);
2261#endif
2262
2263#ifndef SC_MAX_NBITS
2264 digit = new sc_digit[ndigits];
2265#endif
2266
2267 copy_digits(v.nbits, v.ndigits, v.digit);
2268}
2269
2270
2271// Create a signed number with (s, nb, nd, d) as its attributes (as
2272// defined in class CLASS_TYPE). If alloc is set, delete d.
2273CLASS_TYPE::CLASS_TYPE(
2274 small_type s, int nb, int nd, sc_digit *d, bool alloc) :
2275 sc_value_base(), sgn(s), nbits(num_bits(nb)), ndigits(), digit()
2276{
2277 ndigits = DIV_CEIL(nbits);
2278#ifndef SC_MAX_NBITS
2279 digit = new sc_digit[ndigits];
2280#endif
2281
2282 if (ndigits <= nd)
2283 vec_copy(ndigits, digit, d);
2284 else
2285 vec_copy_and_zero(ndigits, digit, nd, d);
2286
2287#ifndef SC_MAX_NBITS
2288 if (alloc)
2289 delete [] d;
2290#endif
2291}
2292
2293// This constructor is mainly used in finding a "range" of bits from a
2294// number of type CLASS_TYPE. The function range(l, r) can have
2295// arbitrary precedence between l and r. If l is smaller than r, then
2296// the output is the reverse of range(r, l).
2297CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE *u, int l, int r) :
2298 sc_value_base(), sgn(), nbits(), ndigits(), digit()
2299{
2300 bool reversed = false;
2301
2302 if (l < r) {
2303 reversed = true;
2304 int tmp = l;
2305 l = r;
2306 r = tmp;
2307 }
2308
2309 // at this point, l >= r
2310
2311 // make sure that l and r point to the bits of u
2312 r = sc_max(r, 0);
2313 l = sc_min(l, u->nbits - 1);
2314
2315 nbits = num_bits(l - r + 1);
2316
2317 // nbits can still be <= 0 because l and r have just been updated
2318 // with the bounds of u.
2319
2320 // if u == 0 or the range is out of bounds, return 0
2321 if (u->sgn == SC_ZERO || nbits <= num_bits(0)) {
2322 sgn = SC_ZERO;
2323 if (nbits <= num_bits(0)) {
2324 nbits = 1;
2325 }
2326 ndigits = DIV_CEIL(nbits);
2327#ifndef SC_MAX_NBITS
2328 digit = new sc_digit[ndigits];
2329#endif
2330 vec_zero(ndigits, digit);
2331 return;
2332 }
2333
2334 // The rest will be executed if u is not zero.
2335
2336 ndigits = DIV_CEIL(nbits);
2337
2338 // The number of bits up to and including l and r, respectively.
2339 int nl = l + 1;
2340 int nr = r + 1;
2341
2342 // The indices of the digits that have lth and rth bits, respectively.
2343 int left_digit = DIV_CEIL(nl) - 1;
2344 int right_digit = DIV_CEIL(nr) - 1;
2345
2346 int nd;
2347
2348 // The range is performed on the 2's complement representation, so
2349 // first get the indices for that.
2350 if (u->sgn == SC_NEG)
2351 nd = left_digit + 1;
2352 else
2353 nd = left_digit - right_digit + 1;
2354
2355 // Allocate memory for the range.
2356#ifdef SC_MAX_NBITS
2357 sc_digit d[MAX_NDIGITS];
2358#else
2359 digit = new sc_digit[ndigits];
2360 sc_digit *d = new sc_digit[nd];
2361#endif
2362
2363 // Getting the range on the 2's complement representation.
2364 if (u->sgn == SC_NEG) {
2365 vec_copy(nd, d, u->digit);
2366 vec_complement(nd, d); // d = -d;
2367 vec_shift_right(nd, d, r, DIGIT_MASK);
2368 } else {
2369 for (int i = right_digit; i <= left_digit; ++i)
2370 d[i - right_digit] = u->digit[i];
2371 vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
2372 }
2373
2374 vec_zero(ndigits, digit);
2375
2376 if (!reversed) {
2377 vec_copy(sc_min(nd, ndigits), digit, d);
2378 } else {
2379 // If l < r, i.e., reversed is set, reverse the bits of digit. d
2380 // will be used as a temporary store. The following code tries to
2381 // minimize the use of bit_ord and digit_ord, which use mod and
2382 // div operators. Since these operators are function calls to
2383 // standard library routines, they are slow. The main idea in
2384 // reversing is "read bits out of d from left to right and push
2385 // them into digit using right shifting."
2386
2387 // Take care of the last digit.
2388 int nd_less_1 = nd - 1;
2389
2390 // Deletions will start from the left end and move one position
2391 // after each deletion.
2392 sc_digit del_mask = one_and_zeros(bit_ord(l - r));
2393
2394 while (del_mask) {
2395 vec_shift_right(ndigits, digit, 1,
2396 ((d[nd_less_1] & del_mask) != 0));
2397 del_mask >>= 1;
2398 }
2399
2400 // Take care of the other digits if any.
2401
2402 // Insertion to digit will always occur at the left end.
2403 sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
2404
2405 for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
2406 // Deletions will start from the left end and move one position
2407 // after each deletion.
2408 del_mask = ins_mask;
2409 while (del_mask) {
2410 vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
2411 del_mask >>= 1;
2412 }
2413 }
2414
2415 if (u->sgn == SC_NEG)
2416 vec_shift_right(ndigits, digit,
2417 ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
2418 else
2419 vec_shift_right(ndigits, digit,
2420 ndigits * BITS_PER_DIGIT - length(), 0);
2421
2422
2423 } // if reversed.
2424
2425 convert_2C_to_SM();
2426
2427#ifndef SC_MAX_NBITS
2428 delete [] d;
2429#endif
2430}
2431
2432// This constructor is mainly used in finding a "range" of bits from a
2433// number of type OTHER_CLASS_TYPE. The function range(l, r) can have
2434// arbitrary precedence between l and r. If l is smaller than r, then
2435// the output is the reverse of range(r, l).
2436CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE *u, int l, int r) :
2437 sc_value_base(), sgn(), nbits(), ndigits(), digit()
2438{
2439 bool reversed = false;
2440
2441 if (l < r) {
2442 reversed = true;
2443 int tmp = l;
2444 l = r;
2445 r = tmp;
2446 }
2447
2448 // at this point, l >= r
2449
2450 // make sure that l and r point to the bits of u
2451 r = sc_max(r, 0);
2452 l = sc_min(l, u->nbits - 1);
2453
2454 nbits = num_bits(l - r + 1);
2455
2456 // nbits can still be <= 0 because l and r have just been updated
2457 // with the bounds of u.
2458
2459 // if u == 0 or the range is out of bounds, return 0
2460 if (u->sgn == SC_ZERO || nbits <= num_bits(0)) {
2461 sgn = SC_ZERO;
2462 if (nbits <= num_bits(0)) {
2463 nbits = 1;
2464 }
2465 ndigits = DIV_CEIL(nbits);
2466#ifndef SC_MAX_NBITS
2467 digit = new sc_digit[ndigits];
2468#endif
2469 vec_zero(ndigits, digit);
2470 return;
2471 }
2472
2473 // The rest will be executed if u is not zero.
2474
2475 ndigits = DIV_CEIL(nbits);
2476
2477 // The number of bits up to and including l and r, respectively.
2478 int nl = l + 1;
2479 int nr = r + 1;
2480
2481 // The indices of the digits that have lth and rth bits, respectively.
2482 int left_digit = DIV_CEIL(nl) - 1;
2483 int right_digit = DIV_CEIL(nr) - 1;
2484
2485 int nd;
2486
2487 // The range is performed on the 2's complement representation, so
2488 // first get the indices for that.
2489 if (u->sgn == SC_NEG)
2490 nd = left_digit + 1;
2491 else
2492 nd = left_digit - right_digit + 1;
2493
2494 // Allocate memory for the range.
2495#ifdef SC_MAX_NBITS
2496 sc_digit d[MAX_NDIGITS];
2497#else
2498 digit = new sc_digit[ndigits];
2499 sc_digit *d = new sc_digit[nd];
2500#endif
2501
2502 // Getting the range on the 2's complement representation.
2503 if (u->sgn == SC_NEG) {
2504 vec_copy(nd, d, u->digit);
2505 vec_complement(nd, d); // d = -d;
2506 vec_shift_right(nd, d, r, DIGIT_MASK);
2507 } else {
2508 for (int i = right_digit; i <= left_digit; ++i)
2509 d[i - right_digit] = u->digit[i];
2510 vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
2511 }
2512
2513 vec_zero(ndigits, digit);
2514
2515 if (!reversed) {
2516 vec_copy(sc_min(nd, ndigits), digit, d);
2517 } else {
2518 // If l < r, i.e., reversed is set, reverse the bits of digit. d
2519 // will be used as a temporary store. The following code tries to
2520 // minimize the use of bit_ord and digit_ord, which use mod and
2521 // div operators. Since these operators are function calls to
2522 // standard library routines, they are slow. The main idea in
2523 // reversing is "read bits out of d from left to right and push
2524 // them into digit using right shifting."
2525
2526 // Take care of the last digit.
2527 int nd_less_1 = nd - 1;
2528
2529 // Deletions will start from the left end and move one position
2530 // after each deletion.
2531 sc_digit del_mask = one_and_zeros(bit_ord(l - r));
2532
2533 while (del_mask) {
2534 vec_shift_right(ndigits, digit, 1,
2535 ((d[nd_less_1] & del_mask) != 0));
2536 del_mask >>= 1;
2537 }
2538
2539 // Take care of the other digits if any.
2540
2541 // Insertion to digit will always occur at the left end.
2542 sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
2543
2544 for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
2545 // Deletions will start from the left end and move one position
2546 // after each deletion.
2547 del_mask = ins_mask;
2548
2549 while (del_mask) {
2550 vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
2551 del_mask >>= 1;
2552 }
2553 }
2554
2555 if (u->sgn == SC_NEG)
2556 vec_shift_right(ndigits, digit,
2557 ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
2558 else
2559 vec_shift_right(ndigits, digit,
2560 ndigits * BITS_PER_DIGIT - length(), 0);
2561
2562
2563 } // if reversed.
2564
2565 convert_2C_to_SM();
2566
2567#ifndef SC_MAX_NBITS
2568 delete [] d;
2569#endif
2570}
2571
2572
2573// Print out all the physical attributes.
2574void
2575CLASS_TYPE::dump(::std::ostream &os) const
2576{
2577 // Save the current setting, and set the base to decimal.
2578 ::std::ios::fmtflags old_flags =
2579 os.setf(::std::ios::dec, ::std::ios::basefield);
2580
2581 os << "width = " << length() << ::std::endl;
2582 os << "value = " << *this << ::std::endl;
|