456 }
457 return *this;
458}
459
460const sc_signed &
461sc_signed::operator=(int64 v)
462{
463 sgn = get_sign(v);
464 // v >= 0 now.
465 if (sgn == SC_ZERO) {
466 vec_zero(ndigits, digit);
467 } else {
468 from_uint(ndigits, digit, (uint64)v);
469 if (nbits <= (int)BITS_PER_INT64)
470 convert_SM_to_2C_to_SM();
471 }
472 return *this;
473}
474
475const sc_signed &
476sc_signed::operator=(uint64 v)
477{
478 sgn = get_sign(v);
479 if (sgn == SC_ZERO) {
480 vec_zero(ndigits, digit);
481 } else {
482 from_uint(ndigits, digit, v);
483 if (nbits <= (int)BITS_PER_INT64)
484 convert_SM_to_2C_to_SM();
485 }
486 return *this;
487}
488
489const sc_signed &
490sc_signed::operator=(long v)
491{
492 sgn = get_sign(v);
493 // v >= 0 now.
494 if (sgn == SC_ZERO) {
495 vec_zero(ndigits, digit);
496 } else {
497 from_uint(ndigits, digit, (unsigned long)v);
498 if (nbits <= (int)BITS_PER_LONG)
499 convert_SM_to_2C_to_SM();
500 }
501 return *this;
502}
503
504const sc_signed &
505sc_signed::operator=(unsigned long v)
506{
507 sgn = get_sign(v);
508 if (sgn == SC_ZERO) {
509 vec_zero(ndigits, digit);
510 } else {
511 from_uint(ndigits, digit, v);
512 if (nbits <= (int)BITS_PER_LONG)
513 convert_SM_to_2C_to_SM();
514 }
515 return *this;
516}
517
518const sc_signed &
519sc_signed::operator=(double v)
520{
521 is_bad_double(v);
522 if (v < 0) {
523 v = -v;
524 sgn = SC_NEG;
525 } else {
526 sgn = SC_POS;
527 }
528
529 int i = 0;
530 while (std::floor(v) && (i < ndigits)) {
531 digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) &
532 DIGIT_MASK;
533 v /= DIGIT_RADIX;
534 }
535 vec_zero(i, ndigits, digit);
536 convert_SM_to_2C_to_SM();
537 return *this;
538}
539
540
541// ----------------------------------------------------------------------------
542
543const sc_signed &
544sc_signed::operator = (const sc_bv_base &v)
545{
546 int minlen = sc_min(nbits, v.length());
547 int i = 0;
548 for (; i < minlen; ++i) {
549 safe_set(i, v.get_bit(i), digit);
550 }
551 for (; i < nbits; ++i) {
552 safe_set(i, 0, digit); // zero-extend
553 }
554 convert_2C_to_SM();
555 return *this;
556}
557
558const sc_signed &
559sc_signed::operator = (const sc_lv_base &v)
560{
561 int minlen = sc_min(nbits, v.length());
562 int i = 0;
563 for (; i < minlen; ++i) {
564 safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit);
565 }
566 for (; i < nbits; ++i) {
567 safe_set(i, 0, digit); // zero-extend
568 }
569 convert_2C_to_SM();
570 return *this;
571}
572
573
574// explicit conversion to character string
575const std::string
576sc_signed::to_string(sc_numrep numrep) const
577{
578 int len = length();
579 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
580 return aa.to_string(numrep);
581}
582
583const std::string
584sc_signed::to_string(sc_numrep numrep, bool w_prefix) const
585{
586 int len = length();
587 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
588 return aa.to_string(numrep, w_prefix);
589}
590
591
592// ----------------------------------------------------------------------------
593// SECTION: Interfacing with sc_int_base
594// ----------------------------------------------------------------------------
595
596const sc_signed &
597sc_signed::operator = (const sc_int_base &v)
598{
599 return operator = ((int64)v);
600}
601
602
603sc_signed
604operator + (const sc_unsigned &u, const sc_int_base &v)
605{
606 return operator + (u, static_cast<int64>(v));
607}
608
609sc_signed
610operator + (const sc_int_base &u, const sc_unsigned &v)
611{
612 return operator + (static_cast<int64>(u), v);
613}
614
615sc_signed
616operator + (const sc_signed &u, const sc_int_base &v)
617{
618 return operator + (u, (int64)v);
619}
620
621sc_signed
622operator + (const sc_int_base &u, const sc_signed &v)
623{
624 return operator + ((int64)u, v);
625}
626
627const sc_signed &
628sc_signed::operator += (const sc_int_base &v)
629{
630 return operator += ((int64)v);
631}
632
633
634sc_signed
635operator - (const sc_unsigned &u, const sc_int_base &v)
636{
637 return operator - (u, (int64)v);
638}
639
640sc_signed
641operator - (const sc_int_base &u, const sc_unsigned &v)
642{
643 return operator - ((int64)u, v);
644}
645
646sc_signed
647operator - (const sc_signed &u, const sc_int_base &v)
648{
649 return operator - (u, (int64)v);
650}
651
652sc_signed
653operator - (const sc_int_base &u, const sc_signed &v)
654{
655 return operator - ((int64)u, v);
656}
657
658const sc_signed &
659sc_signed::operator -= (const sc_int_base &v)
660{
661 return operator -= ((int64)v);
662}
663
664
665sc_signed
666operator * (const sc_unsigned &u, const sc_int_base &v)
667{
668 return operator * (u, static_cast<int64>(v));
669}
670
671sc_signed
672operator * (const sc_int_base &u, const sc_unsigned &v)
673{
674 return operator * (static_cast<int64>(u), v);
675}
676
677sc_signed
678operator * (const sc_signed &u, const sc_int_base &v)
679{
680 return operator * (u, (int64)v);
681}
682
683sc_signed
684operator * (const sc_int_base &u, const sc_signed &v)
685{
686 return operator * ((int64)u, v);
687}
688
689const sc_signed &
690sc_signed::operator *= (const sc_int_base &v)
691{
692 return operator *= ((int64)v);
693}
694
695
696sc_signed
697operator / (const sc_unsigned &u, const sc_int_base &v)
698{
699 return operator / (u, static_cast<int64>(v));
700}
701
702sc_signed
703operator / (const sc_int_base &u, const sc_unsigned &v)
704{
705 return operator / (static_cast<int64>(u), v);
706}
707
708sc_signed
709operator / (const sc_signed &u, const sc_int_base &v)
710{
711 return operator / (u, (int64)v);
712}
713
714sc_signed
715operator / (const sc_int_base &u, const sc_signed &v)
716{
717 return operator / ((int64)u, v);
718}
719
720const sc_signed &
721sc_signed::operator /= (const sc_int_base &v)
722{
723 return operator /= ((int64)v);
724}
725
726
727sc_signed
728operator % (const sc_unsigned &u, const sc_int_base &v)
729{
730 return operator % (u, static_cast<int64>(v));
731}
732
733sc_signed
734operator % (const sc_int_base &u, const sc_unsigned &v)
735{
736 return operator % (static_cast<int64>(u), v);
737}
738
739sc_signed
740operator % (const sc_signed &u, const sc_int_base &v)
741{
742 return operator % (u, (int64)v);
743}
744
745sc_signed
746operator % (const sc_int_base &u, const sc_signed &v)
747{
748 return operator % ((int64)u, v);
749}
750
751const sc_signed &
752sc_signed::operator %= (const sc_int_base &v)
753{
754 return operator %= ((int64)v);
755}
756
757
758sc_signed
759operator & (const sc_unsigned &u, const sc_int_base &v)
760{
761 return operator & (u, static_cast<int64>(v));
762}
763
764sc_signed
765operator & (const sc_int_base &u, const sc_unsigned &v)
766{
767 return operator & (static_cast<int64>(u), v);
768}
769
770sc_signed
771operator & (const sc_signed &u, const sc_int_base &v)
772{
773 return operator & (u, (int64)v);
774}
775
776sc_signed
777operator & (const sc_int_base &u, const sc_signed &v)
778{
779 return operator & ((int64)u, v);
780}
781
782const sc_signed &
783sc_signed::operator &= (const sc_int_base &v)
784{
785 return operator &= ((int64)v);
786}
787
788
789sc_signed
790operator | (const sc_unsigned &u, const sc_int_base &v)
791{
792 return operator | (u, static_cast<int64>(v));
793}
794
795sc_signed
796operator | (const sc_int_base &u, const sc_unsigned &v)
797{
798 return operator | (static_cast<int64>(u), v);
799}
800
801sc_signed
802operator | (const sc_signed& u, const sc_int_base &v)
803{
804 return operator|(u, (int64)v);
805}
806
807sc_signed
808operator | (const sc_int_base &u, const sc_signed &v)
809{
810 return operator | ((int64)u, v);
811}
812
813const sc_signed &
814sc_signed::operator |= (const sc_int_base &v)
815{
816 return operator |= ((int64)v);
817}
818
819
820sc_signed
821operator ^ (const sc_unsigned &u, const sc_int_base &v)
822{
823 return operator ^ (u, static_cast<int64>(v));
824}
825
826sc_signed
827operator ^ (const sc_int_base &u, const sc_unsigned &v)
828{
829 return operator ^ (static_cast<int64>(u), v);
830}
831
832sc_signed
833operator ^ (const sc_signed &u, const sc_int_base &v)
834{
835 return operator ^ (u, (int64)v);
836}
837
838sc_signed
839operator ^ (const sc_int_base &u, const sc_signed &v)
840{
841 return operator ^ ((int64)u, v);
842}
843
844const sc_signed &
845sc_signed::operator ^= (const sc_int_base &v)
846{
847 return operator ^= ((int64)v);
848}
849
850
851sc_signed
852operator << (const sc_signed &u, const sc_int_base &v)
853{
854 return operator << (u, (int64)v);
855}
856
857const sc_signed &
858sc_signed::operator <<= (const sc_int_base &v)
859{
860 return operator <<= ((int64)v);
861}
862
863
864sc_signed
865operator >> (const sc_signed &u, const sc_int_base &v)
866{
867 return operator >> (u, (int64)v);
868}
869
870const sc_signed &
871sc_signed::operator >>= (const sc_int_base &v)
872{
873 return operator >>= ((int64)v);
874}
875
876
877bool
878operator == (const sc_signed &u, const sc_int_base &v)
879{
880 return operator == (u, (int64)v);
881}
882
883bool
884operator == (const sc_int_base &u, const sc_signed &v)
885{
886 return operator == ((int64)u, v);
887}
888
889
890bool
891operator != (const sc_signed &u, const sc_int_base &v)
892{
893 return operator != (u, (int64)v);
894}
895
896bool
897operator != (const sc_int_base &u, const sc_signed &v)
898{
899 return operator != ((int64)u, v);
900}
901
902
903bool
904operator < (const sc_signed &u, const sc_int_base &v)
905{
906 return operator < (u, (int64)v);
907}
908
909bool
910operator < (const sc_int_base &u, const sc_signed &v)
911{
912 return operator < ((int64)u, v);
913}
914
915
916bool
917operator <= (const sc_signed &u, const sc_int_base &v)
918{
919 return operator <= (u, (int64)v);
920}
921
922bool
923operator <= (const sc_int_base &u, const sc_signed &v)
924{
925 return operator <= ((int64)u, v);
926}
927
928
929bool
930operator > (const sc_signed &u, const sc_int_base &v)
931{
932 return operator > (u, (int64)v);
933}
934
935bool
936operator > (const sc_int_base &u, const sc_signed &v)
937{
938 return operator > ((int64)u, v);
939}
940
941
942bool
943operator >= (const sc_signed &u, const sc_int_base &v)
944{
945 return operator >= (u, (int64)v);
946}
947
948bool
949operator >= (const sc_int_base &u, const sc_signed &v)
950{
951 return operator >= ((int64)u, v);
952}
953
954
955// ----------------------------------------------------------------------------
956// SECTION: Interfacing with sc_uint_base
957// ----------------------------------------------------------------------------
958
959const sc_signed &
960sc_signed::operator = (const sc_uint_base &v)
961{
962 return operator = ((uint64)v);
963}
964
965
966sc_signed
967operator + (const sc_signed &u, const sc_uint_base &v)
968{
969 return operator + (u, (uint64)v);
970}
971
972sc_signed
973operator + (const sc_uint_base &u, const sc_signed &v)
974{
975 return operator + ((uint64)u, v);
976}
977
978const sc_signed &
979sc_signed::operator += (const sc_uint_base &v)
980{
981 return operator += ((uint64)v);
982}
983
984
985sc_signed
986operator - (const sc_unsigned &u, const sc_uint_base &v)
987{
988 return operator - (u, (uint64)v);
989}
990
991sc_signed
992operator - (const sc_uint_base &u, const sc_unsigned &v)
993{
994 return operator - ((uint64)u, v);
995}
996
997sc_signed
998operator - (const sc_signed &u, const sc_uint_base &v)
999{
1000 return operator - (u, (uint64)v);
1001}
1002
1003sc_signed
1004operator - (const sc_uint_base &u, const sc_signed &v)
1005{
1006 return operator - ((uint64)u, v);
1007}
1008
1009const sc_signed &
1010sc_signed::operator -= (const sc_uint_base &v)
1011{
1012 return operator -= ((uint64)v);
1013}
1014
1015
1016sc_signed
1017operator * (const sc_signed &u, const sc_uint_base &v)
1018{
1019 return operator * (u, (uint64)v);
1020}
1021
1022sc_signed
1023operator * (const sc_uint_base &u, const sc_signed &v)
1024{
1025 return operator * ((uint64)u, v);
1026}
1027
1028const sc_signed &
1029sc_signed::operator *= (const sc_uint_base &v)
1030{
1031 return operator *= ((uint64)v);
1032}
1033
1034
1035sc_signed
1036operator / (const sc_signed &u, const sc_uint_base &v)
1037{
1038 return operator / (u, (uint64)v);
1039}
1040
1041sc_signed
1042operator / (const sc_uint_base &u, const sc_signed &v)
1043{
1044 return operator / ((uint64)u, v);
1045}
1046
1047const sc_signed &
1048sc_signed::operator /= (const sc_uint_base &v)
1049{
1050 return operator /= ((uint64)v);
1051}
1052
1053
1054sc_signed
1055operator % (const sc_signed &u, const sc_uint_base &v)
1056{
1057 return operator % (u, (uint64)v);
1058}
1059
1060sc_signed
1061operator % (const sc_uint_base &u, const sc_signed &v)
1062{
1063 return operator % ((uint64)u, v);
1064}
1065
1066const sc_signed&
1067sc_signed::operator %= (const sc_uint_base &v)
1068{
1069 return operator %= ((uint64)v);
1070}
1071
1072
1073sc_signed
1074operator & (const sc_signed &u, const sc_uint_base &v)
1075{
1076 return operator & (u, (uint64)v);
1077}
1078
1079sc_signed
1080operator & (const sc_uint_base &u, const sc_signed &v)
1081{
1082 return operator & ((uint64)u, v);
1083}
1084
1085const sc_signed &
1086sc_signed::operator &= (const sc_uint_base &v)
1087{
1088 return operator &= ((uint64)v);
1089}
1090
1091
1092sc_signed
1093operator | (const sc_signed &u, const sc_uint_base &v)
1094{
1095 return operator | (u, (uint64)v);
1096}
1097
1098sc_signed
1099operator | (const sc_uint_base &u, const sc_signed &v)
1100{
1101 return operator | ((uint64)u, v);
1102}
1103
1104const sc_signed &
1105sc_signed::operator |= (const sc_uint_base &v)
1106{
1107 return operator |= ((uint64)v);
1108}
1109
1110
1111sc_signed
1112operator ^ (const sc_signed &u, const sc_uint_base &v)
1113{
1114 return operator ^ (u, (uint64)v);
1115}
1116
1117sc_signed
1118operator ^ (const sc_uint_base &u, const sc_signed &v)
1119{
1120 return operator ^ ((uint64)u, v);
1121}
1122
1123const sc_signed &
1124sc_signed::operator ^= (const sc_uint_base &v)
1125{
1126 return operator ^= ((uint64)v);
1127}
1128
1129
1130sc_signed
1131operator << (const sc_signed &u, const sc_uint_base &v)
1132{
1133 return operator << (u, (uint64)v);
1134}
1135
1136const sc_signed &
1137sc_signed::operator <<= (const sc_uint_base &v)
1138{
1139 return operator <<= ((uint64)v);
1140}
1141
1142
1143sc_signed
1144operator >> (const sc_signed& u, const sc_uint_base& v)
1145{
1146 return operator >> (u, (uint64)v);
1147}
1148
1149const sc_signed &
1150sc_signed::operator >>= (const sc_uint_base& v)
1151{
1152 return operator >>= ((uint64)v);
1153}
1154
1155
1156bool
1157operator == (const sc_signed &u, const sc_uint_base &v)
1158{
1159 return operator == (u, (uint64)v);
1160}
1161
1162bool
1163operator == (const sc_uint_base &u, const sc_signed &v)
1164{
1165 return operator == ((uint64)u, v);
1166}
1167
1168
1169bool
1170operator != (const sc_signed &u, const sc_uint_base &v)
1171{
1172 return operator != (u, (uint64)v);
1173}
1174
1175bool
1176operator != (const sc_uint_base &u, const sc_signed &v)
1177{
1178 return operator != ((uint64)u, v);
1179}
1180
1181
1182bool
1183operator < (const sc_signed &u, const sc_uint_base &v)
1184{
1185 return operator < (u, (uint64)v);
1186}
1187
1188bool
1189operator < (const sc_uint_base &u, const sc_signed &v)
1190{
1191 return operator < ((uint64)u, v);
1192}
1193
1194
1195bool
1196operator <= (const sc_signed &u, const sc_uint_base &v)
1197{
1198 return operator <= (u, (uint64)v);
1199}
1200
1201bool
1202operator <= (const sc_uint_base &u, const sc_signed &v)
1203{
1204 return operator <= ((uint64)u, v);
1205}
1206
1207
1208bool
1209operator > (const sc_signed &u, const sc_uint_base &v)
1210{
1211 return operator > (u, (uint64)v);
1212}
1213
1214bool
1215operator > (const sc_uint_base &u, const sc_signed &v)
1216{
1217 return operator > ((uint64)u, v);
1218}
1219
1220
1221bool
1222operator >= (const sc_signed &u, const sc_uint_base &v)
1223{
1224 return operator >= (u, (uint64)v);
1225}
1226
1227bool
1228operator >= (const sc_uint_base &u, const sc_signed &v)
1229{
1230 return operator >= ((uint64)u, v);
1231}
1232
1233
1234// ----------------------------------------------------------------------------
1235// SECTION: Input and output operators
1236// ----------------------------------------------------------------------------
1237
1238// Operators in this section are included from sc_nbcommon.cpp.
1239
1240
1241// ----------------------------------------------------------------------------
1242// SECTION: Operator macros.
1243// ----------------------------------------------------------------------------
1244
1245#define CONVERT_LONG(u) \
1246small_type u ## s = get_sign(u); \
1247sc_digit u ## d[DIGITS_PER_ULONG]; \
1248from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
1249
1250#define CONVERT_LONG_2(u) \
1251sc_digit u ## d[DIGITS_PER_ULONG]; \
1252from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
1253
1254#define CONVERT_INT(u) \
1255small_type u ## s = get_sign(u); \
1256sc_digit u ## d[DIGITS_PER_UINT]; \
1257from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
1258
1259#define CONVERT_INT_2(u) \
1260sc_digit u ## d[DIGITS_PER_UINT]; \
1261from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
1262
1263#define CONVERT_INT64(u) \
1264small_type u ## s = get_sign(u); \
1265sc_digit u ## d[DIGITS_PER_UINT64]; \
1266from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
1267
1268#define CONVERT_INT64_2(u) \
1269sc_digit u ## d[DIGITS_PER_UINT64]; \
1270from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
1271
1272
1273// ----------------------------------------------------------------------------
1274// SECTION: PLUS operators: +, +=, ++
1275// ----------------------------------------------------------------------------
1276
1277// Cases to consider when computing u + v:
1278// 1. 0 + v = v
1279// 2. u + 0 = u
1280// 3. if sgn(u) == sgn(v)
1281// 3.1 u + v = +(u + v) = sgn(u) * (u + v)
1282// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
1283// 4. if sgn(u) != sgn(v)
1284// 4.1 u + (-v) = u - v = sgn(u) * (u - v)
1285// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
1286//
1287// Specialization of above cases for computing ++u or u++:
1288// 1. 0 + 1 = 1
1289// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
1290// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
1291
1292sc_signed
1293operator + (const sc_unsigned &u, const sc_signed &v)
1294{
1295 if (u.sgn == SC_ZERO) // case 1
1296 return sc_signed(v);
1297
1298 if (v.sgn == SC_ZERO) // case 2
1299 return sc_signed(u);
1300
1301 // cases 3 and 4
1302 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1303 v.sgn, v.nbits, v.ndigits, v.digit);
1304}
1305
1306
1307sc_signed
1308operator + (const sc_signed &u, const sc_unsigned &v)
1309{
1310 if (u.sgn == SC_ZERO) // case 1
1311 return sc_signed(v);
1312
1313 if (v.sgn == SC_ZERO) // case 2
1314 return sc_signed(u);
1315
1316 // cases 3 and 4
1317 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1318 v.sgn, v.nbits, v.ndigits, v.digit);
1319}
1320
1321
1322sc_signed
1323operator + (const sc_signed &u, const sc_signed &v)
1324{
1325 if (u.sgn == SC_ZERO) // case 1
1326 return sc_signed(v);
1327
1328 if (v.sgn == SC_ZERO) // case 2
1329 return sc_signed(u);
1330
1331 // cases 3 and 4
1332 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1333 v.sgn, v.nbits, v.ndigits, v.digit);
1334}
1335
1336
1337sc_signed
1338operator + (const sc_signed &u, int64 v)
1339{
1340 if (v == 0) // case 2
1341 return sc_signed(u);
1342
1343 CONVERT_INT64(v);
1344
1345 if (u.sgn == SC_ZERO) // case 1
1346 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1347
1348 // cases 3 and 4
1349 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1350 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1351}
1352
1353
1354sc_signed
1355operator + (int64 u, const sc_signed &v)
1356{
1357 if (u == 0) // case 1
1358 return sc_signed(v);
1359
1360 CONVERT_INT64(u);
1361
1362 if (v.sgn == SC_ZERO) // case 2
1363 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1364
1365 // cases 3 and 4
1366 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1367 v.sgn, v.nbits, v.ndigits, v.digit);
1368}
1369
1370
1371sc_signed
1372operator + (const sc_unsigned &u, int64 v)
1373{
1374 if (v == 0) // case 2
1375 return sc_signed(u);
1376
1377 CONVERT_INT64(v);
1378
1379 if (u.sgn == SC_ZERO) // case 1
1380 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1381
1382 // cases 3 and 4
1383 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1384 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1385}
1386
1387
1388sc_signed
1389operator + (int64 u, const sc_unsigned &v)
1390{
1391 if (u == 0) // case 1
1392 return sc_signed(v);
1393
1394 CONVERT_INT64(u);
1395
1396 if (v.sgn == SC_ZERO) // case 2
1397 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1398
1399 // cases 3 and 4
1400 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1401 v.sgn, v.nbits, v.ndigits, v.digit);
1402}
1403
1404
1405sc_signed
1406operator + (const sc_signed &u, uint64 v)
1407{
1408 if (v == 0) // case 2
1409 return sc_signed(u);
1410
1411 CONVERT_INT64(v);
1412
1413 if (u.sgn == SC_ZERO) // case 1
1414 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1415
1416 // cases 3 and 4
1417 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1418 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1419}
1420
1421
1422sc_signed
1423operator + (uint64 u, const sc_signed &v)
1424{
1425 if (u == 0) // case 1
1426 return sc_signed(v);
1427
1428 CONVERT_INT64(u);
1429
1430 if (v.sgn == SC_ZERO) // case 2
1431 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1432
1433 // cases 3 and 4
1434 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1435 v.sgn, v.nbits, v.ndigits, v.digit);
1436}
1437
1438
1439sc_signed
1440operator + (const sc_signed &u, long v)
1441{
1442 if (v == 0) // case 2
1443 return sc_signed(u);
1444
1445 CONVERT_LONG(v);
1446
1447 if (u.sgn == SC_ZERO) // case 1
1448 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1449
1450 // cases 3 and 4
1451 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1452 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1453}
1454
1455
1456sc_signed
1457operator + (long u, const sc_signed &v)
1458{
1459 if (u == 0) // case 1
1460 return sc_signed(v);
1461
1462 CONVERT_LONG(u);
1463
1464 if (v.sgn == SC_ZERO) // case 2
1465 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1466
1467 // cases 3 and 4
1468 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1469 v.sgn, v.nbits, v.ndigits, v.digit);
1470}
1471
1472
1473sc_signed
1474operator + (const sc_unsigned &u, long v)
1475{
1476 if (v == 0) // case 2
1477 return sc_signed(u);
1478
1479 CONVERT_LONG(v);
1480
1481 if (u.sgn == SC_ZERO) // case 1
1482 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1483
1484 // cases 3 and 4
1485 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1486 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1487}
1488
1489
1490sc_signed
1491operator + (long u, const sc_unsigned &v)
1492{
1493 if (u == 0) // case 1
1494 return sc_signed(v);
1495
1496 CONVERT_LONG(u);
1497
1498 if (v.sgn == SC_ZERO) // case 2
1499 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1500
1501 // cases 3 and 4
1502 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1503 v.sgn, v.nbits, v.ndigits, v.digit);
1504}
1505
1506
1507sc_signed
1508operator + (const sc_signed &u, unsigned long v)
1509{
1510 if (v == 0) // case 2
1511 return sc_signed(u);
1512
1513 CONVERT_LONG(v);
1514
1515 if (u.sgn == SC_ZERO) // case 1
1516 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1517
1518 // cases 3 and 4
1519 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1520 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1521}
1522
1523
1524sc_signed
1525operator + (unsigned long u, const sc_signed &v)
1526{
1527 if (u == 0) // case 1
1528 return sc_signed(v);
1529
1530 CONVERT_LONG(u);
1531
1532 if (v.sgn == SC_ZERO) // case 2
1533 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1534
1535 // cases 3 and 4
1536 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1537 v.sgn, v.nbits, v.ndigits, v.digit);
1538}
1539
1540// The rest of the operators in this section are included from
1541// sc_nbcommon.cpp.
1542
1543// ----------------------------------------------------------------------------
1544// SECTION: MINUS operators: -, -=, --
1545// ----------------------------------------------------------------------------
1546
1547// Cases to consider when computing u + v:
1548// 1. u - 0 = u
1549// 2. 0 - v = -v
1550// 3. if sgn(u) != sgn(v)
1551// 3.1 u - (-v) = u + v = sgn(u) * (u + v)
1552// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
1553// 4. if sgn(u) == sgn(v)
1554// 4.1 u - v = +(u - v) = sgn(u) * (u - v)
1555// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
1556//
1557// Specialization of above cases for computing --u or u--:
1558// 1. 0 - 1 = -1
1559// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
1560// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
1561
1562sc_signed
1563operator - (const sc_unsigned &u, const sc_unsigned &v)
1564{
1565 if (v.sgn == SC_ZERO) // case 1
1566 return sc_signed(u);
1567
1568 if (u.sgn == SC_ZERO) // case 2
1569 return sc_signed(v, -v.sgn);
1570
1571 // cases 3 and 4
1572 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1573 -v.sgn, v.nbits, v.ndigits, v.digit);
1574}
1575
1576
1577sc_signed
1578operator - (const sc_unsigned &u, const sc_signed &v)
1579{
1580 if (v.sgn == SC_ZERO) // case 1
1581 return sc_signed(u);
1582
1583 if (u.sgn == SC_ZERO) // case 2
1584 return sc_signed(v, -v.sgn);
1585
1586 // cases 3 and 4
1587 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1588 -v.sgn, v.nbits, v.ndigits, v.digit);
1589}
1590
1591
1592sc_signed
1593operator - (const sc_signed &u, const sc_unsigned &v)
1594{
1595 if (v.sgn == SC_ZERO) // case 1
1596 return sc_signed(u);
1597
1598 if (u.sgn == SC_ZERO) // case 2
1599 return sc_signed(v, -v.sgn);
1600
1601 // cases 3 and 4
1602 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1603 -v.sgn, v.nbits, v.ndigits, v.digit);
1604}
1605
1606
1607sc_signed
1608operator - (const sc_signed &u, const sc_signed &v)
1609{
1610 if (v.sgn == SC_ZERO) // case 1
1611 return sc_signed(u);
1612
1613 if (u.sgn == SC_ZERO) // case 2
1614 return sc_signed(v, -v.sgn);
1615
1616 // cases 3 and 4
1617 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1618 -v.sgn, v.nbits, v.ndigits, v.digit);
1619}
1620
1621
1622sc_signed
1623operator - (const sc_signed &u, int64 v)
1624{
1625 if (v == 0) // case 1
1626 return sc_signed(u);
1627
1628 CONVERT_INT64(v);
1629
1630 if (u.sgn == SC_ZERO) // case 2
1631 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1632
1633 // cases 3 and 4
1634 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1635 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1636}
1637
1638
1639sc_signed
1640operator - (int64 u, const sc_signed &v)
1641{
1642 if (u == 0) // case 1
1643 return sc_signed(v, -v.sgn);
1644
1645 CONVERT_INT64(u);
1646
1647 if (v.sgn == SC_ZERO) // case 2
1648 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1649
1650 // cases 3 and 4
1651 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1652 -v.sgn, v.nbits, v.ndigits, v.digit);
1653}
1654
1655
1656sc_signed
1657operator - (const sc_unsigned &u, int64 v)
1658{
1659 if (v == 0) // case 1
1660 return sc_signed(u);
1661
1662 CONVERT_INT64(v);
1663
1664 if (u.sgn == SC_ZERO) // case 2
1665 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1666
1667 // cases 3 and 4
1668 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1669 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1670}
1671
1672
1673sc_signed
1674operator - (int64 u, const sc_unsigned &v)
1675{
1676 if (u == 0) // case 1
1677 return sc_signed(v, -v.sgn);
1678
1679 CONVERT_INT64(u);
1680
1681 if (v.sgn == SC_ZERO) // case 2
1682 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1683
1684 // cases 3 and 4
1685 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1686 -v.sgn, v.nbits, v.ndigits, v.digit);
1687}
1688
1689
1690sc_signed
1691operator - (const sc_signed &u, uint64 v)
1692{
1693 if (v == 0) // case 1
1694 return sc_signed(u);
1695
1696 CONVERT_INT64(v);
1697
1698 if (u.sgn == SC_ZERO) // case 2
1699 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1700
1701 // cases 3 and 4
1702
1703 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1704 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1705}
1706
1707
1708sc_signed
1709operator - (uint64 u, const sc_signed &v)
1710{
1711 if (u == 0) // case 1
1712 return sc_signed(v, -v.sgn);
1713
1714 CONVERT_INT64(u);
1715
1716 if (v.sgn == SC_ZERO) // case 2
1717 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1718
1719 // cases 3 and 4
1720 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1721 -v.sgn, v.nbits, v.ndigits, v.digit);
1722}
1723
1724
1725sc_signed
1726operator - (const sc_unsigned &u, uint64 v)
1727{
1728 if (v == 0) // case 1
1729 return sc_signed(u);
1730
1731 CONVERT_INT64(v);
1732
1733 if (u.sgn == SC_ZERO) // case 2
1734 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1735
1736 // cases 3 and 4
1737 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1738 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1739}
1740
1741
1742sc_signed
1743operator - (uint64 u, const sc_unsigned &v)
1744{
1745 if (u == 0) // case 1
1746 return sc_signed(v, -v.sgn);
1747
1748 CONVERT_INT64(u);
1749
1750 if (v.sgn == SC_ZERO) // case 2
1751 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1752
1753 // cases 3 and 4
1754 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1755 -v.sgn, v.nbits, v.ndigits, v.digit);
1756}
1757
1758
1759sc_signed
1760operator - (const sc_signed &u, long v)
1761{
1762 if (v == 0) // case 1
1763 return sc_signed(u);
1764
1765 CONVERT_LONG(v);
1766
1767 if (u.sgn == SC_ZERO) // case 2
1768 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1769
1770 // cases 3 and 4
1771 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1772 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1773}
1774
1775
1776sc_signed
1777operator - (long u, const sc_signed &v)
1778{
1779 if (u == 0) // case 1
1780 return sc_signed(v, -v.sgn);
1781
1782 CONVERT_LONG(u);
1783
1784 if (v.sgn == SC_ZERO) // case 2
1785 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1786
1787 // cases 3 and 4
1788 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1789 -v.sgn, v.nbits, v.ndigits, v.digit);
1790}
1791
1792
1793sc_signed
1794operator - (const sc_unsigned &u, long v)
1795{
1796 if (v == 0) // case 1
1797 return sc_signed(u);
1798
1799 CONVERT_LONG(v);
1800
1801 if (u.sgn == SC_ZERO) // case 2
1802 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1803
1804 // cases 3 and 4
1805 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1806 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1807}
1808
1809
1810sc_signed
1811operator - (long u, const sc_unsigned &v)
1812{
1813 if (u == 0) // case 1
1814 return sc_signed(v, -v.sgn);
1815
1816 CONVERT_LONG(u);
1817
1818 if (v.sgn == SC_ZERO) // case 2
1819 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1820
1821 // cases 3 and 4
1822 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1823 -v.sgn, v.nbits, v.ndigits, v.digit);
1824}
1825
1826
1827sc_signed
1828operator - (const sc_signed &u, unsigned long v)
1829{
1830 if (v == 0) // case 1
1831 return sc_signed(u);
1832
1833 CONVERT_LONG(v);
1834
1835 if (u.sgn == SC_ZERO) // case 2
1836 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1837
1838 // cases 3 and 4
1839 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1840 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1841}
1842
1843
1844sc_signed
1845operator - (unsigned long u, const sc_signed &v)
1846{
1847 if (u == 0) // case 1
1848 return sc_signed(v, -v.sgn);
1849
1850 CONVERT_LONG(u);
1851
1852 if (v.sgn == SC_ZERO) // case 2
1853 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1854
1855 // cases 3 and 4
1856 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1857 -v.sgn, v.nbits, v.ndigits, v.digit);
1858}
1859
1860
1861sc_signed
1862operator - (const sc_unsigned &u, unsigned long v)
1863{
1864 if (v == 0) // case 1
1865 return sc_signed(u);
1866
1867 CONVERT_LONG(v);
1868
1869 if (u.sgn == SC_ZERO) // case 2
1870 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1871
1872 // cases 3 and 4
1873 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1874 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1875}
1876
1877
1878sc_signed
1879operator - (unsigned long u, const sc_unsigned &v)
1880{
1881 if (u == 0) // case 1
1882 return sc_signed(v, -v.sgn);
1883
1884 CONVERT_LONG(u);
1885
1886 if (v.sgn == SC_ZERO) // case 2
1887 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1888
1889 // cases 3 and 4
1890 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1891 -v.sgn, v.nbits, v.ndigits, v.digit);
1892}
1893
1894// The rest of the operators in this section are included from
1895// sc_nbcommon.cpp.
1896
1897
1898// ----------------------------------------------------------------------------
1899// SECTION: MULTIPLICATION operators: *, *=
1900// ----------------------------------------------------------------------------
1901
1902// Cases to consider when computing u * v:
1903// 1. u * 0 = 0 * v = 0
1904// 2. 1 * v = v and -1 * v = -v
1905// 3. u * 1 = u and u * -1 = -u
1906// 4. u * v = u * v
1907
1908sc_signed
1909operator * (const sc_unsigned &u, const sc_signed &v)
1910{
1911 small_type s = mul_signs(u.sgn, v.sgn);
1912
1913 if (s == SC_ZERO) // case 1
1914 return sc_signed();
1915
1916 // cases 2-4
1917 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1918 v.nbits, v.ndigits, v.digit);
1919}
1920
1921
1922sc_signed
1923operator * (const sc_signed &u, const sc_unsigned &v)
1924{
1925 small_type s = mul_signs(u.sgn, v.sgn);
1926
1927 if (s == SC_ZERO) // case 1
1928 return sc_signed();
1929
1930 // cases 2-4
1931 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1932 v.nbits, v.ndigits, v.digit);
1933}
1934
1935
1936sc_signed
1937operator * (const sc_signed &u, const sc_signed &v)
1938{
1939 small_type s = mul_signs(u.sgn, v.sgn);
1940
1941 if (s == SC_ZERO) // case 1
1942 return sc_signed();
1943
1944 // cases 2-4
1945 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1946 v.nbits, v.ndigits, v.digit);
1947}
1948
1949
1950sc_signed
1951operator * (const sc_signed &u, int64 v)
1952{
1953 small_type s = mul_signs(u.sgn, get_sign(v));
1954
1955 if (s == SC_ZERO) // case 1
1956 return sc_signed();
1957
1958 CONVERT_INT64_2(v);
1959
1960 // cases 2-4
1961 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1962 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1963}
1964
1965
1966sc_signed
1967operator * (int64 u, const sc_signed &v)
1968{
1969 small_type s = mul_signs(v.sgn, get_sign(u));
1970
1971 if (s == SC_ZERO) // case 1
1972 return sc_signed();
1973
1974 CONVERT_INT64_2(u);
1975
1976 // cases 2-4
1977 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1978 v.nbits, v.ndigits, v.digit);
1979}
1980
1981
1982sc_signed
1983operator * (const sc_unsigned &u, int64 v)
1984{
1985 small_type s = mul_signs(u.sgn, get_sign(v));
1986
1987 if (s == SC_ZERO) // case 1
1988 return sc_signed();
1989
1990 CONVERT_INT64_2(v);
1991
1992 // cases 2-4
1993 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1994 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1995}
1996
1997
1998sc_signed
1999operator * (int64 u, const sc_unsigned &v)
2000{
2001 small_type s = mul_signs(v.sgn, get_sign(u));
2002
2003 if (s == SC_ZERO) // case 1
2004 return sc_signed();
2005
2006 CONVERT_INT64_2(u);
2007
2008 // cases 2-4
2009 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2010 v.nbits, v.ndigits, v.digit);
2011}
2012
2013
2014sc_signed
2015operator * (const sc_signed &u, uint64 v)
2016{
2017 small_type s = mul_signs(u.sgn, get_sign(v));
2018
2019 if (s == SC_ZERO) // case 1
2020 return sc_signed();
2021
2022 CONVERT_INT64_2(v);
2023
2024 // cases 2-4
2025 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2026 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2027}
2028
2029
2030sc_signed
2031operator * (uint64 u, const sc_signed &v)
2032{
2033 small_type s = mul_signs(v.sgn, get_sign(u));
2034
2035 if (s == SC_ZERO) // case 1
2036 return sc_signed();
2037
2038 CONVERT_INT64_2(u);
2039
2040 // cases 2-4
2041 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2042 v.nbits, v.ndigits, v.digit);
2043}
2044
2045
2046sc_signed
2047operator * (const sc_signed &u, long v)
2048{
2049 small_type s = mul_signs(u.sgn, get_sign(v));
2050
2051 if (s == SC_ZERO) // case 1
2052 return sc_signed();
2053
2054 CONVERT_LONG_2(v);
2055
2056 // cases 2-4
2057 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2058 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2059}
2060
2061
2062sc_signed
2063operator * (long u, const sc_signed &v)
2064{
2065 small_type s = mul_signs(v.sgn, get_sign(u));
2066
2067 if (s == SC_ZERO) // case 1
2068 return sc_signed();
2069
2070 CONVERT_LONG_2(u);
2071
2072 // cases 2-4
2073 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2074 v.nbits, v.ndigits, v.digit);
2075}
2076
2077
2078sc_signed
2079operator * (const sc_unsigned &u, long v)
2080{
2081 small_type s = mul_signs(u.sgn, get_sign(v));
2082
2083 if (s == SC_ZERO) // case 1
2084 return sc_signed();
2085
2086 CONVERT_LONG_2(v);
2087
2088 // cases 2-4
2089 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2090 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2091}
2092
2093
2094sc_signed
2095operator * (long u, const sc_unsigned &v)
2096{
2097 small_type s = mul_signs(v.sgn, get_sign(u));
2098
2099 if (s == SC_ZERO) // case 1
2100 return sc_signed();
2101
2102 CONVERT_LONG_2(u);
2103
2104 // cases 2-4
2105 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2106 v.nbits, v.ndigits, v.digit);
2107}
2108
2109
2110sc_signed
2111operator * (const sc_signed &u, unsigned long v)
2112{
2113 small_type s = mul_signs(u.sgn, get_sign(v));
2114
2115 if (s == SC_ZERO) // case 1
2116 return sc_signed();
2117
2118 CONVERT_LONG_2(v);
2119
2120 // else cases 2-4
2121 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2122 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2123}
2124
2125sc_signed
2126operator * (unsigned long u, const sc_signed &v)
2127{
2128 small_type s = mul_signs(v.sgn, get_sign(u));
2129
2130 if (s == SC_ZERO) // case 1
2131 return sc_signed();
2132
2133 CONVERT_LONG_2(u);
2134
2135 // cases 2-4
2136 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2137 v.nbits, v.ndigits, v.digit);
2138}
2139
2140// The rest of the operators in this section are included from
2141// sc_nbcommon.cpp.
2142
2143
2144// ----------------------------------------------------------------------------
2145// SECTION: DIVISION operators: /, /=
2146// ----------------------------------------------------------------------------
2147
2148// Cases to consider when finding the quotient q = floor(u/v):
2149// Note that u = q * v + r for r < q.
2150// 1. 0 / 0 or u / 0 => error
2151// 2. 0 / v => 0 = 0 * v + 0
2152// 3. u / v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
2153// 4. u / v & &u < v => u = 0 * v + u - u can be 1 or -1
2154// 5. u / v & &u > v => u = q * v + r - v can be 1 or -1
2155
2156sc_signed
2157operator / (const sc_unsigned &u, const sc_signed &v)
2158{
2159 small_type s = mul_signs(u.sgn, v.sgn);
2160
2161 if (s == SC_ZERO) {
2162 div_by_zero(v.sgn); // case 1
2163 return sc_signed(); // case 2
2164 }
2165
2166 // other cases
2167 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2168 v.nbits, v.ndigits, v.digit);
2169}
2170
2171
2172sc_signed
2173operator / (const sc_signed &u, const sc_unsigned &v)
2174{
2175 small_type s = mul_signs(u.sgn, v.sgn);
2176
2177 if (s == SC_ZERO) {
2178 div_by_zero(v.sgn); // case 1
2179 return sc_signed(); // case 2
2180 }
2181
2182 // other cases
2183 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2184 v.nbits, v.ndigits, v.digit);
2185}
2186
2187
2188sc_signed
2189operator / (const sc_signed &u, const sc_signed &v)
2190{
2191 small_type s = mul_signs(u.sgn, v.sgn);
2192
2193 if (s == SC_ZERO) {
2194 div_by_zero(v.sgn); // case 1
2195 return sc_signed(); // case 2
2196 }
2197
2198 // other cases
2199 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2200 v.nbits, v.ndigits, v.digit);
2201}
2202
2203
2204sc_signed
2205operator / (const sc_signed &u, int64 v)
2206{
2207 small_type s = mul_signs(u.sgn, get_sign(v));
2208
2209 if (s == SC_ZERO) {
2210 div_by_zero(v); // case 1
2211 return sc_signed(); // case 2
2212 }
2213
2214 CONVERT_INT64_2(v);
2215
2216 // other cases
2217 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2218 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2219}
2220
2221
2222sc_signed
2223operator / (int64 u, const sc_signed &v)
2224{
2225 small_type s = mul_signs(v.sgn, get_sign(u));
2226
2227 if (s == SC_ZERO) {
2228 div_by_zero(v.sgn); // case 1
2229 return sc_signed(); // case 2
2230 }
2231
2232 CONVERT_INT64_2(u);
2233
2234 // other cases
2235 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2236 v.nbits, v.ndigits, v.digit);
2237}
2238
2239
2240sc_signed
2241operator / (const sc_unsigned &u, int64 v)
2242{
2243 small_type s = mul_signs(u.sgn, get_sign(v));
2244
2245 if (s == SC_ZERO) {
2246 div_by_zero(v); // case 1
2247 return sc_signed(); // case 2
2248 }
2249
2250 CONVERT_INT64_2(v);
2251
2252 // other cases
2253 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2254 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2255}
2256
2257
2258sc_signed
2259operator / (int64 u, const sc_unsigned &v)
2260{
2261 small_type s = mul_signs(v.sgn, get_sign(u));
2262
2263 if (s == SC_ZERO) {
2264 div_by_zero(v.sgn); // case 1
2265 return sc_signed(); // case 2
2266 }
2267
2268 CONVERT_INT64_2(u);
2269
2270 // other cases
2271 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2272 v.nbits, v.ndigits, v.digit);
2273}
2274
2275
2276sc_signed
2277operator / (const sc_signed &u, uint64 v)
2278{
2279 small_type s = mul_signs(u.sgn, get_sign(v));
2280
2281 if (s == SC_ZERO) {
2282 div_by_zero(v); // case 1
2283 return sc_signed(); // case 2
2284 }
2285
2286 CONVERT_INT64_2(v);
2287
2288 // other cases
2289 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2290 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2291}
2292
2293
2294sc_signed
2295operator / (uint64 u, const sc_signed &v)
2296{
2297 small_type s = mul_signs(v.sgn, get_sign(u));
2298
2299 if (s == SC_ZERO) {
2300 div_by_zero(v.sgn); // case 1
2301 return sc_signed(); // case 2
2302
2303 }
2304
2305 CONVERT_INT64_2(u);
2306
2307 // other cases
2308 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2309 v.nbits, v.ndigits, v.digit);
2310}
2311
2312
2313sc_signed
2314operator / (const sc_signed &u, long v)
2315{
2316 small_type s = mul_signs(u.sgn, get_sign(v));
2317
2318 if (s == SC_ZERO) {
2319 div_by_zero(v); // case 1
2320 return sc_signed(); // case 2
2321 }
2322
2323 CONVERT_LONG_2(v);
2324
2325 // other cases
2326 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2327 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2328}
2329
2330
2331sc_signed
2332operator / (long u, const sc_signed &v)
2333{
2334 small_type s = mul_signs(v.sgn, get_sign(u));
2335
2336 if (s == SC_ZERO) {
2337 div_by_zero(v.sgn); // case 1
2338 return sc_signed(); // case 2
2339 }
2340
2341 CONVERT_LONG_2(u);
2342
2343 // other cases
2344 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2345 v.nbits, v.ndigits, v.digit);
2346}
2347
2348
2349sc_signed
2350operator / (const sc_unsigned &u, long v)
2351{
2352 small_type s = mul_signs(u.sgn, get_sign(v));
2353
2354 if (s == SC_ZERO) {
2355 div_by_zero(v); // case 1
2356 return sc_signed(); // case 2
2357 }
2358
2359 CONVERT_LONG_2(v);
2360
2361 // other cases
2362 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2363 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2364}
2365
2366
2367sc_signed
2368operator / (long u, const sc_unsigned &v)
2369{
2370 small_type s = mul_signs(v.sgn, get_sign(u));
2371
2372 if (s == SC_ZERO) {
2373 div_by_zero(v.sgn); // case 1
2374 return sc_signed(); // case 2
2375 }
2376
2377 CONVERT_LONG_2(u);
2378
2379 // other cases
2380 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2381 v.nbits, v.ndigits, v.digit);
2382}
2383
2384
2385sc_signed
2386operator / (const sc_signed &u, unsigned long v)
2387{
2388 small_type s = mul_signs(u.sgn, get_sign(v));
2389
2390 if (s == SC_ZERO) {
2391 div_by_zero(v); // case 1
2392 return sc_signed(); // case 2
2393 }
2394
2395 CONVERT_LONG_2(v);
2396
2397 // other cases
2398 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2399 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2400}
2401
2402
2403sc_signed
2404operator / (unsigned long u, const sc_signed &v)
2405{
2406 small_type s = mul_signs(v.sgn, get_sign(u));
2407
2408 if (s == SC_ZERO) {
2409 div_by_zero(v.sgn); // case 1
2410 return sc_signed(); // case 2
2411
2412 }
2413
2414 CONVERT_LONG_2(u);
2415
2416 // other cases
2417 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2418 v.nbits, v.ndigits, v.digit);
2419}
2420
2421// The rest of the operators in this section are included from
2422// sc_nbcommon.cpp.
2423
2424
2425// ----------------------------------------------------------------------------
2426// SECTION: MOD operators: %, %=.
2427// ----------------------------------------------------------------------------
2428
2429// Cases to consider when finding the remainder r = u % v:
2430// Note that u = q * v + r for r < q.
2431// 1. 0 % 0 or u % 0 => error
2432// 2. 0 % v => 0 = 0 * v + 0
2433// 3. u % v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
2434// 4. u % v & &u < v => u = 0 * v + u - u can be 1 or -1
2435// 5. u % v & &u > v => u = q * v + r - v can be 1 or -1
2436
2437sc_signed
2438operator % (const sc_unsigned &u, const sc_signed &v)
2439{
2440 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
2441 div_by_zero(v.sgn); // case 1
2442 return sc_signed(); // case 2
2443 }
2444
2445 // other cases
2446 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2447 v.nbits, v.ndigits, v.digit);
2448}
2449
2450
2451sc_signed
2452operator % (const sc_signed &u, const sc_unsigned &v)
2453{
2454 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
2455 div_by_zero(v.sgn); // case 1
2456 return sc_signed(); // case 2
2457 }
2458
2459 // other cases
2460 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2461 v.nbits, v.ndigits, v.digit);
2462}
2463
2464
2465sc_signed
2466operator % (const sc_signed &u, const sc_signed &v)
2467{
2468 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
2469 div_by_zero(v.sgn); // case 1
2470 return sc_signed(); // case 2
2471 }
2472
2473 // other cases
2474 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2475 v.nbits, v.ndigits, v.digit);
2476}
2477
2478
2479sc_signed
2480operator % (const sc_signed &u, int64 v)
2481{
2482 small_type vs = get_sign(v);
2483
2484 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2485 div_by_zero(v); // case 1
2486 return sc_signed(); // case 2
2487 }
2488
2489 CONVERT_INT64_2(v);
2490
2491 // other cases
2492 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2493 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2494}
2495
2496
2497sc_signed
2498operator % (int64 u, const sc_signed &v)
2499{
2500 small_type us = get_sign(u);
2501
2502 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2503 div_by_zero(v.sgn); // case 1
2504 return sc_signed(); // case 2
2505 }
2506
2507 CONVERT_INT64_2(u);
2508
2509 // other cases
2510 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2511 v.nbits, v.ndigits, v.digit);
2512}
2513
2514
2515sc_signed
2516operator % (const sc_unsigned &u, int64 v)
2517{
2518 small_type vs = get_sign(v);
2519
2520 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2521 div_by_zero(v); // case 1
2522 return sc_signed(); // case 2
2523 }
2524
2525 CONVERT_INT64_2(v);
2526
2527 // other cases
2528 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2529 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2530}
2531
2532
2533sc_signed
2534operator % (int64 u, const sc_unsigned &v)
2535{
2536 small_type us = get_sign(u);
2537
2538 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2539 div_by_zero(v.sgn); // case 1
2540 return sc_signed(); // case 2
2541 }
2542
2543 CONVERT_INT64_2(u);
2544
2545 // other cases
2546 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2547 v.nbits, v.ndigits, v.digit);
2548}
2549
2550
2551sc_signed
2552operator % (const sc_signed &u, uint64 v)
2553{
2554 if ((u.sgn == SC_ZERO) || (v == 0)) {
2555 div_by_zero(v); // case 1
2556 return sc_signed(); // case 2
2557 }
2558
2559 CONVERT_INT64_2(v);
2560
2561 // other cases
2562 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2563 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2564}
2565
2566
2567sc_signed
2568operator % (uint64 u, const sc_signed &v)
2569{
2570 if ((u == 0) || (v.sgn == SC_ZERO)) {
2571 div_by_zero(v.sgn); // case 1
2572 return sc_signed(); // case 2
2573 }
2574
2575 CONVERT_INT64(u);
2576
2577 // other cases
2578 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2579 v.nbits, v.ndigits, v.digit);
2580}
2581
2582
2583sc_signed
2584operator % (const sc_signed &u, long v)
2585{
2586 small_type vs = get_sign(v);
2587
2588 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2589 div_by_zero(v); // case 1
2590 return sc_signed(); // case 2
2591 }
2592
2593 CONVERT_LONG_2(v);
2594
2595 // other cases
2596 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2597 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2598}
2599
2600
2601sc_signed
2602operator % (long u, const sc_signed &v)
2603{
2604 small_type us = get_sign(u);
2605
2606 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2607 div_by_zero(v.sgn); // case 1
2608 return sc_signed(); // case 2
2609 }
2610
2611 CONVERT_LONG_2(u);
2612
2613 // other cases
2614 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2615 v.nbits, v.ndigits, v.digit);
2616}
2617
2618
2619sc_signed
2620operator % (const sc_unsigned &u, long v)
2621{
2622
2623 small_type vs = get_sign(v);
2624
2625 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2626 div_by_zero(v); // case 1
2627 return sc_signed(); // case 2
2628 }
2629
2630 CONVERT_LONG_2(v);
2631
2632 // other cases
2633 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2634 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2635}
2636
2637
2638sc_signed
2639operator % (long u, const sc_unsigned &v)
2640{
2641 small_type us = get_sign(u);
2642
2643 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2644 div_by_zero(v.sgn); // case 1
2645 return sc_signed(); // case 2
2646 }
2647
2648 CONVERT_LONG_2(u);
2649
2650 // other cases
2651 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2652 v.nbits, v.ndigits, v.digit);
2653}
2654
2655
2656sc_signed
2657operator % (const sc_signed &u, unsigned long v)
2658{
2659 if ((u.sgn == SC_ZERO) || (v == 0)) {
2660 div_by_zero(v); // case 1
2661 return sc_signed(); // case 2
2662 }
2663
2664 CONVERT_LONG_2(v);
2665
2666 // other cases
2667 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2668 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2669}
2670
2671
2672sc_signed
2673operator % (unsigned long u, const sc_signed &v)
2674{
2675 if ((u == 0) || (v.sgn == SC_ZERO)) {
2676 div_by_zero(v.sgn); // case 1
2677 return sc_signed(); // case 2
2678 }
2679
2680 CONVERT_LONG(u);
2681
2682 // other cases
2683 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2684 v.nbits, v.ndigits, v.digit);
2685}
2686
2687// The rest of the operators in this section are included from
2688// sc_nbcommon.cpp.
2689
2690
2691// ----------------------------------------------------------------------------
2692// SECTION: Bitwise AND operators: &, &=
2693// ----------------------------------------------------------------------------
2694
2695// Cases to consider when computing u &v:
2696// 1. u & 0 = 0 &v = 0
2697// 2. u &v => sgn = +
2698// 3. (-u) & (-v) => sgn = -
2699// 4. u & (-v) => sgn = +
2700// 5. (-u) &v => sgn = +
2701
2702sc_signed
2703operator & (const sc_unsigned &u, const sc_signed &v)
2704{
2705 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
2706 return sc_signed();
2707
2708 // other cases
2709 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2710 v.sgn, v.nbits, v.ndigits, v.digit);
2711}
2712
2713
2714sc_signed
2715operator & (const sc_signed &u, const sc_unsigned &v)
2716{
2717 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
2718 return sc_signed();
2719
2720 // other cases
2721 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2722 v.sgn, v.nbits, v.ndigits, v.digit);
2723}
2724
2725
2726sc_signed
2727operator & (const sc_signed &u, const sc_signed &v)
2728{
2729 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
2730 return sc_signed();
2731
2732 // other cases
2733 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2734 v.sgn, v.nbits, v.ndigits, v.digit);
2735}
2736
2737
2738sc_signed
2739operator & (const sc_signed &u, int64 v)
2740{
2741 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2742 return sc_signed();
2743
2744 CONVERT_INT64(v);
2745
2746 // other cases
2747 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2748 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2749}
2750
2751
2752sc_signed
2753operator & (int64 u, const sc_signed &v)
2754{
2755 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2756 return sc_signed();
2757
2758 CONVERT_INT64(u);
2759
2760 // other cases
2761 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2762 v.sgn, v.nbits, v.ndigits, v.digit);
2763}
2764
2765
2766sc_signed
2767operator & (const sc_unsigned &u, int64 v)
2768{
2769 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2770 return sc_signed();
2771
2772 CONVERT_INT64(v);
2773
2774 // other cases
2775 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2776 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2777}
2778
2779
2780sc_signed
2781operator & (int64 u, const sc_unsigned &v)
2782{
2783 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2784 return sc_signed();
2785
2786 CONVERT_INT64(u);
2787
2788 // other cases
2789 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2790 v.sgn, v.nbits, v.ndigits, v.digit);
2791}
2792
2793
2794sc_signed
2795operator & (const sc_signed &u, uint64 v)
2796{
2797 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2798 return sc_signed();
2799
2800 CONVERT_INT64(v);
2801
2802 // other cases
2803 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2804 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2805}
2806
2807
2808sc_signed
2809operator & (uint64 u, const sc_signed &v)
2810{
2811 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2812 return sc_signed();
2813
2814 CONVERT_INT64(u);
2815
2816 // other cases
2817 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2818 v.sgn, v.nbits, v.ndigits, v.digit);
2819}
2820
2821
2822sc_signed
2823operator & (const sc_signed &u, long v)
2824{
2825 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2826 return sc_signed();
2827
2828 CONVERT_LONG(v);
2829
2830 // other cases
2831 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2832 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2833}
2834
2835
2836sc_signed
2837operator & (long u, const sc_signed &v)
2838{
2839 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2840 return sc_signed();
2841
2842 CONVERT_LONG(u);
2843
2844 // other cases
2845 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2846 v.sgn, v.nbits, v.ndigits, v.digit);
2847}
2848
2849
2850sc_signed
2851operator & (const sc_unsigned &u, long v)
2852{
2853 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2854 return sc_signed();
2855
2856 CONVERT_LONG(v);
2857
2858 // other cases
2859 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2860 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2861}
2862
2863
2864sc_signed
2865operator & (long u, const sc_unsigned &v)
2866{
2867 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2868 return sc_signed();
2869
2870 CONVERT_LONG(u);
2871
2872 // other cases
2873 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2874 v.sgn, v.nbits, v.ndigits, v.digit);
2875}
2876
2877
2878sc_signed
2879operator & (const sc_signed &u, unsigned long v)
2880{
2881 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2882 return sc_signed();
2883
2884 CONVERT_LONG(v);
2885
2886 // other cases
2887 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2888 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2889}
2890
2891
2892sc_signed
2893operator & (unsigned long u, const sc_signed &v)
2894{
2895 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2896 return sc_signed();
2897
2898 CONVERT_LONG(u);
2899
2900 // other cases
2901 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2902 v.sgn, v.nbits, v.ndigits, v.digit);
2903}
2904
2905// The rest of the operators in this section are included from
2906// sc_nbcommon.cpp.
2907
2908
2909// ----------------------------------------------------------------------------
2910// SECTION: Bitwise OR operators: |, |=
2911// ----------------------------------------------------------------------------
2912
2913// Cases to consider when computing u | v:
2914// 1. u | 0 = u
2915// 2. 0 | v = v
2916// 3. u | v => sgn = +
2917// 4. (-u) | (-v) => sgn = -
2918// 5. u | (-v) => sgn = -
2919// 6. (-u) | v => sgn = -
2920
2921sc_signed
2922operator | (const sc_unsigned &u, const sc_signed &v)
2923{
2924 if (v.sgn == SC_ZERO) // case 1
2925 return sc_signed(u);
2926
2927 if (u.sgn == SC_ZERO) // case 2
2928 return sc_signed(v);
2929
2930 // other cases
2931 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2932 v.sgn, v.nbits, v.ndigits, v.digit);
2933}
2934
2935
2936sc_signed
2937operator | (const sc_signed &u, const sc_unsigned &v)
2938{
2939 if (v.sgn == SC_ZERO) // case 1
2940 return sc_signed(u);
2941
2942 if (u.sgn == SC_ZERO) // case 2
2943 return sc_signed(v);
2944
2945 // other cases
2946 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2947 v.sgn, v.nbits, v.ndigits, v.digit);
2948}
2949
2950
2951sc_signed
2952operator | (const sc_signed &u, const sc_signed &v)
2953{
2954 if (v.sgn == SC_ZERO) // case 1
2955 return sc_signed(u);
2956
2957 if (u.sgn == SC_ZERO) // case 2
2958 return sc_signed(v);
2959
2960 // other cases
2961 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2962 v.sgn, v.nbits, v.ndigits, v.digit);
2963}
2964
2965
2966sc_signed
2967operator | (const sc_signed &u, int64 v)
2968{
2969 if (v == 0) // case 1
2970 return sc_signed(u);
2971
2972 CONVERT_INT64(v);
2973
2974 if (u.sgn == SC_ZERO) // case 2
2975 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
2976
2977 // other cases
2978 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2979 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2980}
2981
2982
2983sc_signed
2984operator | (int64 u, const sc_signed &v)
2985{
2986 if (u == 0)
2987 return sc_signed(v);
2988
2989 CONVERT_INT64(u);
2990
2991 if (v.sgn == SC_ZERO)
2992 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
2993
2994 // other cases
2995 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2996 v.sgn, v.nbits, v.ndigits, v.digit);
2997}
2998
2999
3000sc_signed
3001operator | (const sc_unsigned &u, int64 v)
3002{
3003 if (v == 0) // case 1
3004 return sc_signed(u);
3005
3006 CONVERT_INT64(v);
3007
3008 if (u.sgn == SC_ZERO) // case 2
3009 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3010
3011 // other cases
3012 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3013 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3014}
3015
3016
3017sc_signed
3018operator | (int64 u, const sc_unsigned &v)
3019{
3020 if (u == 0)
3021 return sc_signed(v);
3022
3023 CONVERT_INT64(u);
3024
3025 if (v.sgn == SC_ZERO)
3026 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3027
3028 // other cases
3029 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3030 v.sgn, v.nbits, v.ndigits, v.digit);
3031}
3032
3033
3034sc_signed
3035operator | (const sc_signed &u, uint64 v)
3036{
3037 if (v == 0) // case 1
3038 return sc_signed(u);
3039
3040 CONVERT_INT64(v);
3041
3042 if (u.sgn == SC_ZERO) // case 2
3043 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3044
3045 // other cases
3046 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3047 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3048}
3049
3050
3051sc_signed
3052operator | (uint64 u, const sc_signed &v)
3053{
3054 if (u == 0)
3055 return sc_signed(v);
3056
3057 CONVERT_INT64(u);
3058
3059 if (v.sgn == SC_ZERO)
3060 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3061
3062 // other cases
3063 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3064 v.sgn, v.nbits, v.ndigits, v.digit);
3065}
3066
3067
3068sc_signed
3069operator | (const sc_signed &u, long v)
3070{
3071 if (v == 0) // case 1
3072 return sc_signed(u);
3073
3074 CONVERT_LONG(v);
3075
3076 if (u.sgn == SC_ZERO) // case 2
3077 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3078
3079 // other cases
3080 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3081 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3082}
3083
3084
3085sc_signed
3086operator | (long u, const sc_signed &v)
3087{
3088 if (u == 0)
3089 return sc_signed(v);
3090
3091 CONVERT_LONG(u);
3092
3093 if (v.sgn == SC_ZERO)
3094 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3095
3096 // other cases
3097 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3098 v.sgn, v.nbits, v.ndigits, v.digit);
3099}
3100
3101
3102sc_signed
3103operator | (const sc_unsigned &u, long v)
3104{
3105 if (v == 0) // case 1
3106 return sc_signed(u);
3107
3108 CONVERT_LONG(v);
3109
3110 if (u.sgn == SC_ZERO) // case 2
3111 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3112
3113 // other cases
3114 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3115 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3116}
3117
3118
3119sc_signed
3120operator | (long u, const sc_unsigned &v)
3121{
3122 if (u == 0)
3123 return sc_signed(v);
3124
3125 CONVERT_LONG(u);
3126
3127 if (v.sgn == SC_ZERO)
3128 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3129
3130 // other cases
3131 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3132 v.sgn, v.nbits, v.ndigits, v.digit);
3133}
3134
3135
3136sc_signed
3137operator | (const sc_signed &u, unsigned long v)
3138{
3139 if (v == 0) // case 1
3140 return sc_signed(u);
3141
3142 CONVERT_LONG(v);
3143
3144 if (u.sgn == SC_ZERO) // case 2
3145 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3146
3147 // other cases
3148 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3149 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3150}
3151
3152
3153sc_signed
3154operator | (unsigned long u, const sc_signed &v)
3155{
3156 if (u == 0)
3157 return sc_signed(v);
3158
3159 CONVERT_LONG(u);
3160
3161 if (v.sgn == SC_ZERO)
3162 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3163
3164 // other cases
3165 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3166 v.sgn, v.nbits, v.ndigits, v.digit);
3167}
3168
3169// The rest of the operators in this section are included from
3170// sc_nbcommon.cpp.
3171
3172
3173// ----------------------------------------------------------------------------
3174// SECTION: Bitwise XOR operators: ^, ^=
3175// ----------------------------------------------------------------------------
3176
3177// Cases to consider when computing u ^ v:
3178// Note that u ^ v = (~u &v) | (u & ~v).
3179// 1. u ^ 0 = u
3180// 2. 0 ^ v = v
3181// 3. u ^ v => sgn = +
3182// 4. (-u) ^ (-v) => sgn = -
3183// 5. u ^ (-v) => sgn = -
3184// 6. (-u) ^ v => sgn = +
3185
3186sc_signed
3187operator ^ (const sc_unsigned &u, const sc_signed &v)
3188{
3189
3190 if (v.sgn == SC_ZERO) // case 1
3191 return sc_signed(u);
3192
3193 if (u.sgn == SC_ZERO) // case 2
3194 return sc_signed(v);
3195
3196 // other cases
3197 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3198 v.sgn, v.nbits, v.ndigits, v.digit);
3199
3200}
3201
3202
3203sc_signed
3204operator ^ (const sc_signed &u, const sc_unsigned &v)
3205{
3206 if (v.sgn == SC_ZERO) // case 1
3207 return sc_signed(u);
3208
3209 if (u.sgn == SC_ZERO) // case 2
3210 return sc_signed(v);
3211
3212 // other cases
3213 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3214 v.sgn, v.nbits, v.ndigits, v.digit);
3215}
3216
3217
3218sc_signed
3219operator ^ (const sc_signed &u, const sc_signed &v)
3220{
3221 if (v.sgn == SC_ZERO) // case 1
3222 return sc_signed(u);
3223
3224 if (u.sgn == SC_ZERO) // case 2
3225 return sc_signed(v);
3226
3227 // other cases
3228 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3229 v.sgn, v.nbits, v.ndigits, v.digit);
3230}
3231
3232
3233sc_signed
3234operator ^ (const sc_signed &u, int64 v)
3235{
3236 if (v == 0) // case 1
3237 return sc_signed(u);
3238
3239 CONVERT_INT64(v);
3240
3241 if (u.sgn == SC_ZERO) // case 2
3242 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3243
3244 // other cases
3245 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3246 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3247}
3248
3249
3250sc_signed
3251operator ^ (int64 u, const sc_signed &v)
3252{
3253 if (u == 0)
3254 return sc_signed(v);
3255
3256 CONVERT_INT64(u);
3257
3258 if (v.sgn == SC_ZERO)
3259 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3260
3261 // other cases
3262 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3263 v.sgn, v.nbits, v.ndigits, v.digit);
3264}
3265
3266
3267sc_signed
3268operator ^ (const sc_unsigned &u, int64 v)
3269{
3270 if (v == 0) // case 1
3271 return sc_signed(u);
3272
3273 CONVERT_INT64(v);
3274
3275 if (u.sgn == SC_ZERO) // case 2
3276 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3277
3278 // other cases
3279 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3280 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3281}
3282
3283
3284sc_signed
3285operator ^ (int64 u, const sc_unsigned &v)
3286{
3287 if (u == 0)
3288 return sc_signed(v);
3289
3290 CONVERT_INT64(u);
3291
3292 if (v.sgn == SC_ZERO)
3293 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3294
3295 // other cases
3296 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3297 v.sgn, v.nbits, v.ndigits, v.digit);
3298}
3299
3300
3301sc_signed
3302operator ^ (const sc_signed &u, uint64 v)
3303{
3304 if (v == 0) // case 1
3305 return sc_signed(u);
3306
3307 CONVERT_INT64(v);
3308
3309 if (u.sgn == SC_ZERO) // case 2
3310 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3311
3312 // other cases
3313 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3314 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3315}
3316
3317sc_signed
3318operator ^ (uint64 u, const sc_signed &v)
3319{
3320 if (u == 0)
3321 return sc_signed(v);
3322
3323 CONVERT_INT64(u);
3324
3325 if (v.sgn == SC_ZERO)
3326 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3327
3328 // other cases
3329 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3330 v.sgn, v.nbits, v.ndigits, v.digit);
3331}
3332
3333
3334sc_signed
3335operator ^ (const sc_signed &u, long v)
3336{
3337 if (v == 0) // case 1
3338 return sc_signed(u);
3339
3340 CONVERT_LONG(v);
3341
3342 if (u.sgn == SC_ZERO) // case 2
3343 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3344
3345 // other cases
3346 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3347 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3348}
3349
3350
3351sc_signed
3352operator ^ (long u, const sc_signed &v)
3353{
3354 if (u == 0)
3355 return sc_signed(v);
3356
3357 CONVERT_LONG(u);
3358
3359 if (v.sgn == SC_ZERO)
3360 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3361
3362 // other cases
3363 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3364 v.sgn, v.nbits, v.ndigits, v.digit);
3365}
3366
3367
3368sc_signed
3369operator ^ (const sc_unsigned &u, long v)
3370{
3371 if (v == 0) // case 1
3372 return sc_signed(u);
3373
3374 CONVERT_LONG(v);
3375
3376 if (u.sgn == SC_ZERO) // case 2
3377 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3378
3379 // other cases
3380 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3381 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3382}
3383
3384
3385sc_signed
3386operator ^ (long u, const sc_unsigned &v)
3387{
3388 if (u == 0)
3389 return sc_signed(v);
3390
3391 CONVERT_LONG(u);
3392
3393 if (v.sgn == SC_ZERO)
3394 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3395
3396 // other cases
3397 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3398 v.sgn, v.nbits, v.ndigits, v.digit);
3399}
3400
3401
3402sc_signed
3403operator ^ (const sc_signed &u, unsigned long v)
3404{
3405 if (v == 0) // case 1
3406 return sc_signed(u);
3407
3408 CONVERT_LONG(v);
3409
3410 if (u.sgn == SC_ZERO) // case 2
3411 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3412
3413 // other cases
3414 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3415 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3416}
3417
3418sc_signed
3419operator ^ (unsigned long u, const sc_signed &v)
3420{
3421 if (u == 0)
3422 return sc_signed(v);
3423
3424 CONVERT_LONG(u);
3425
3426 if (v.sgn == SC_ZERO)
3427 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3428
3429 // other cases
3430 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3431 v.sgn, v.nbits, v.ndigits, v.digit);
3432}
3433
3434// The rest of the operators in this section are included from
3435// sc_nbcommon.cpp.
3436
3437
3438// ----------------------------------------------------------------------------
3439// SECTION: Bitwise NOT operator: ~
3440// ----------------------------------------------------------------------------
3441
3442// Operators in this section are included from sc_nbcommon.cpp.
3443
3444
3445// ----------------------------------------------------------------------------
3446// SECTION: LEFT SHIFT operators: <<, <<=
3447// ----------------------------------------------------------------------------
3448
3449sc_signed
3450operator << (const sc_signed &u, const sc_unsigned &v)
3451{
3452 if (v.sgn == SC_ZERO)
3453 return sc_signed(u);
3454
3455 return operator << (u, v.to_ulong());
3456}
3457
3458// The rest of the operators in this section are included from
3459// sc_nbcommon.cpp.
3460
3461
3462// ----------------------------------------------------------------------------
3463// SECTION: RIGHT SHIFT operators: >>, >>=
3464// ----------------------------------------------------------------------------
3465
3466sc_signed
3467operator >> (const sc_signed &u, const sc_unsigned &v)
3468{
3469 if (v.sgn == SC_ZERO)
3470 return sc_signed(u);
3471
3472 return operator >> (u, v.to_ulong());
3473}
3474
3475// The rest of the operators in this section are included from
3476// sc_nbcommon.cpp.
3477
3478
3479// ----------------------------------------------------------------------------
3480// SECTION: Unary arithmetic operators.
3481// ----------------------------------------------------------------------------
3482
3483sc_signed
3484operator + (const sc_signed &u)
3485{
3486 return sc_signed(u);
3487}
3488
3489sc_signed
3490operator - (const sc_signed &u)
3491{
3492 return sc_signed(u, -u.sgn);
3493}
3494
3495sc_signed
3496operator - (const sc_unsigned &u)
3497{
3498 return sc_signed(u, -u.sgn);
3499}
3500
3501
3502// ----------------------------------------------------------------------------
3503// SECTION: EQUAL operator: ==
3504// ----------------------------------------------------------------------------
3505
3506bool
3507operator == (const sc_signed &u, const sc_signed &v)
3508{
3509 if (u.sgn != v.sgn)
3510 return false;
3511
3512 if (&u == &v)
3513 return true;
3514
3515 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) != 0)
3516 return false;
3517
3518 return true;
3519}
3520
3521
3522bool
3523operator == (const sc_signed &u, int64 v)
3524{
3525 CONVERT_INT64(v);
3526
3527 if (u.sgn != vs)
3528 return false;
3529
3530 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
3531 return false;
3532
3533 return true;
3534}
3535
3536
3537bool
3538operator == (int64 u, const sc_signed &v)
3539{
3540 CONVERT_INT64(u);
3541
3542 if (us != v.sgn)
3543 return false;
3544
3545 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
3546 return false;
3547
3548 return true;
3549}
3550
3551
3552bool
3553operator == (const sc_signed &u, uint64 v)
3554{
3555 CONVERT_INT64(v);
3556
3557 if (u.sgn != vs)
3558 return false;
3559
3560 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
3561 return false;
3562
3563 return true;
3564}
3565
3566
3567bool
3568operator == (uint64 u, const sc_signed &v)
3569{
3570 CONVERT_INT64(u);
3571
3572 if (us != v.sgn)
3573 return false;
3574
3575 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
3576 return false;
3577
3578 return true;
3579}
3580
3581
3582bool
3583operator == (const sc_signed &u, long v)
3584{
3585 CONVERT_LONG(v);
3586
3587 if (u.sgn != vs)
3588 return false;
3589
3590 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
3591 return false;
3592
3593 return true;
3594}
3595
3596
3597bool
3598operator == (long u, const sc_signed &v)
3599{
3600 CONVERT_LONG(u);
3601
3602 if (us != v.sgn)
3603 return false;
3604
3605 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
3606 return false;
3607
3608 return true;
3609}
3610
3611
3612bool
3613operator == (const sc_signed &u, unsigned long v)
3614{
3615 CONVERT_LONG(v);
3616
3617 if (u.sgn != vs)
3618 return false;
3619
3620 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
3621 return false;
3622
3623 return true;
3624}
3625
3626
3627bool
3628operator == (unsigned long u, const sc_signed &v)
3629{
3630 CONVERT_LONG(u);
3631
3632 if (us != v.sgn)
3633 return false;
3634
3635 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
3636 return false;
3637
3638 return true;
3639}
3640
3641
3642// ----------------------------------------------------------------------------
3643// SECTION: NOT_EQUAL operator: !=
3644// ----------------------------------------------------------------------------
3645
3646// Operators in this section are included from sc_nbcommon.cpp.
3647
3648
3649// ----------------------------------------------------------------------------
3650// SECTION: LESS THAN operator: <
3651// ----------------------------------------------------------------------------
3652
3653bool
3654operator < (const sc_signed &u, const sc_signed &v)
3655{
3656 if (u.sgn < v.sgn)
3657 return true;
3658
3659 if (u.sgn > v.sgn)
3660 return false;
3661
3662 // u.sgn == v.sgn
3663
3664 if (&u == &v)
3665 return false;
3666
3667 if (u.sgn == SC_POS) {
3668 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) < 0)
3669 return true;
3670 } else if (u.sgn == SC_NEG) {
3671 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) > 0)
3672 return true;
3673 }
3674
3675 return false;
3676}
3677
3678
3679bool
3680operator < (const sc_signed &u, int64 v)
3681{
3682 CONVERT_INT64(v);
3683
3684 if (u.sgn < vs)
3685 return true;
3686
3687 if (u.sgn > vs)
3688 return false;
3689
3690 // u.sgn == vs
3691
3692 if (vs == SC_POS) {
3693 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
3694 return true;
3695 } else if (vs == SC_NEG) {
3696 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) > 0)
3697 return true;
3698 }
3699
3700 return false;
3701}
3702
3703
3704bool
3705operator < (int64 u, const sc_signed &v)
3706{
3707 CONVERT_INT64(u);
3708
3709 if (us < v.sgn)
3710 return true;
3711
3712 if (us > v.sgn)
3713 return false;
3714
3715 // us == v.sgn
3716
3717 if (us == SC_POS) {
3718 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
3719 return true;
3720 } else if (us == SC_NEG) {
3721 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) > 0)
3722 return true;
3723 }
3724
3725 return false;
3726}
3727
3728
3729bool
3730operator < (const sc_signed &u, uint64 v)
3731{
3732 CONVERT_INT64(v);
3733
3734 if (u.sgn < vs)
3735 return true;
3736
3737 if (u.sgn > vs)
3738 return false;
3739
3740 // u.sgn == vs
3741
3742 if (vs == SC_POS) {
3743 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
3744 return true;
3745 }
3746
3747 return false;
3748}
3749
3750
3751bool
3752operator < (uint64 u, const sc_signed &v)
3753{
3754 CONVERT_INT64(u);
3755
3756 if (us < v.sgn)
3757 return true;
3758
3759 if (us > v.sgn)
3760 return false;
3761
3762 // us == v.sgn
3763
3764 if (us == SC_POS) {
3765 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
3766 return true;
3767 }
3768
3769 return false;
3770}
3771
3772
3773bool
3774operator < (const sc_signed &u, long v)
3775{
3776 CONVERT_LONG(v);
3777
3778 if (u.sgn < vs)
3779 return true;
3780
3781 if (u.sgn > vs)
3782 return false;
3783
3784 // u.sgn == vs
3785
3786 if (vs == SC_POS) {
3787 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
3788 return true;
3789
3790 } else if (vs == SC_NEG) {
3791 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) > 0)
3792 return true;
3793 }
3794
3795 return false;
3796}
3797
3798
3799bool
3800operator < (long u, const sc_signed &v)
3801{
3802 CONVERT_LONG(u);
3803
3804 if (us < v.sgn)
3805 return true;
3806
3807 if (us > v.sgn)
3808 return false;
3809
3810 // us == v.sgn
3811
3812 if (us == SC_POS) {
3813 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
3814 return true;
3815 } else if (us == SC_NEG) {
3816 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) > 0)
3817 return true;
3818 }
3819
3820 return false;
3821}
3822
3823
3824bool
3825operator < (const sc_signed &u, unsigned long v)
3826{
3827 CONVERT_LONG(v);
3828
3829 if (u.sgn < vs)
3830 return true;
3831
3832 if (u.sgn > vs)
3833 return false;
3834
3835 // u.sgn == vs
3836
3837 if (vs == SC_POS) {
3838 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
3839 return true;
3840 }
3841
3842 return false;
3843}
3844
3845
3846bool
3847operator < (unsigned long u, const sc_signed &v)
3848{
3849 CONVERT_LONG(u);
3850
3851 if (us < v.sgn)
3852 return true;
3853
3854 if (us > v.sgn)
3855 return false;
3856
3857 // us == v.sgn
3858
3859 if (us == SC_POS) {
3860 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
3861 return true;
3862 }
3863
3864 return false;
3865}
3866
3867
3868// ---------------------------------------------------------------------------
3869// SECTION: LESS THAN or EQUAL operator: <=
3870// ---------------------------------------------------------------------------
3871
3872// Operators in this section are included from sc_nbcommon.cpp.
3873
3874
3875// ---------------------------------------------------------------------------
3876// SECTION: GREATER THAN operator: >
3877// ---------------------------------------------------------------------------
3878
3879// Operators in this section are included from sc_nbcommon.cpp.
3880
3881
3882// ---------------------------------------------------------------------------
3883// SECTION: GREATER THAN or EQUAL operator: >=
3884// ---------------------------------------------------------------------------
3885
3886// Operators in this section are included from sc_nbcommon.cpp.
3887
3888
3889// ---------------------------------------------------------------------------
3890// SECTION: Public members - Other utils.
3891// ---------------------------------------------------------------------------
3892
3893bool
3894sc_signed::iszero() const
3895{
3896 if (sgn == SC_ZERO)
3897 return true;
3898 else if (sgn != SC_NOSIGN)
3899 return false;
3900 else
3901 return check_for_zero(ndigits, digit);
3902}
3903
3904
3905bool
3906sc_signed::sign() const
3907{
3908 if (sgn == SC_NEG)
3909 return 1;
3910 else if (sgn != SC_NOSIGN)
3911 return 0;
3912 else
3913 return ((digit[ndigits - 1] & one_and_zeros(bit_ord(nbits - 1))) != 0);
3914}
3915
3916// The rest of the utils in this section are included from sc_nbcommon.cpp.
3917
3918
3919// ----------------------------------------------------------------------------
3920// SECTION: Private members.
3921// ----------------------------------------------------------------------------
3922
3923// The private members in this section are included from sc_nbcommon.cpp.
3924
3925#define CLASS_TYPE sc_signed
3926#define CLASS_TYPE_STR "sc_signed"
3927
3928#define ADD_HELPER add_signed_friend
3929#define SUB_HELPER sub_signed_friend
3930#define MUL_HELPER mul_signed_friend
3931#define DIV_HELPER div_signed_friend
3932#define MOD_HELPER mod_signed_friend
3933#define AND_HELPER and_signed_friend
3934#define OR_HELPER or_signed_friend
3935#define XOR_HELPER xor_signed_friend
3936
3937#include "sc_nbfriends.inc"
3938
3939#undef SC_UNSIGNED
3940#define SC_SIGNED
3941#define IF_SC_SIGNED 1 // 1 = sc_signed
3942#define CLASS_TYPE_SUBREF sc_signed_subref_r
3943#define OTHER_CLASS_TYPE sc_unsigned
3944#define OTHER_CLASS_TYPE_SUBREF sc_unsigned_subref_r
3945
3946#define MUL_ON_HELPER mul_on_help_signed
3947#define DIV_ON_HELPER div_on_help_signed
3948#define MOD_ON_HELPER mod_on_help_signed
3949
3950#include "sc_nbcommon.inc"
3951
3952#undef MOD_ON_HELPER
3953#undef DIV_ON_HELPER
3954#undef MUL_ON_HELPER
3955
3956#undef OTHER_CLASS_TYPE_SUBREF
3957#undef OTHER_CLASS_TYPE
3958#undef CLASS_TYPE_SUBREF
3959#undef IF_SC_SIGNED
3960#undef SC_SIGNED
3961
3962#undef XOR_HELPER
3963#undef OR_HELPER
3964#undef AND_HELPER
3965#undef MOD_HELPER
3966#undef DIV_HELPER
3967#undef MUL_HELPER
3968#undef SUB_HELPER
3969#undef ADD_HELPER
3970
3971#undef CLASS_TYPE
3972#undef CLASS_TYPE_STR
3973
3974#include "sc_signed_bitref.inc"
3975#include "sc_signed_subref.inc"
3976
3977#undef CONVERT_LONG
3978#undef CONVERT_LONG_2
3979#undef CONVERT_INT64
3980#undef CONVERT_INT64_2
3981
3982} // namespace sc_dt
| 457 }
458 return *this;
459}
460
461const sc_signed &
462sc_signed::operator=(int64 v)
463{
464 sgn = get_sign(v);
465 // v >= 0 now.
466 if (sgn == SC_ZERO) {
467 vec_zero(ndigits, digit);
468 } else {
469 from_uint(ndigits, digit, (uint64)v);
470 if (nbits <= (int)BITS_PER_INT64)
471 convert_SM_to_2C_to_SM();
472 }
473 return *this;
474}
475
476const sc_signed &
477sc_signed::operator=(uint64 v)
478{
479 sgn = get_sign(v);
480 if (sgn == SC_ZERO) {
481 vec_zero(ndigits, digit);
482 } else {
483 from_uint(ndigits, digit, v);
484 if (nbits <= (int)BITS_PER_INT64)
485 convert_SM_to_2C_to_SM();
486 }
487 return *this;
488}
489
490const sc_signed &
491sc_signed::operator=(long v)
492{
493 sgn = get_sign(v);
494 // v >= 0 now.
495 if (sgn == SC_ZERO) {
496 vec_zero(ndigits, digit);
497 } else {
498 from_uint(ndigits, digit, (unsigned long)v);
499 if (nbits <= (int)BITS_PER_LONG)
500 convert_SM_to_2C_to_SM();
501 }
502 return *this;
503}
504
505const sc_signed &
506sc_signed::operator=(unsigned long v)
507{
508 sgn = get_sign(v);
509 if (sgn == SC_ZERO) {
510 vec_zero(ndigits, digit);
511 } else {
512 from_uint(ndigits, digit, v);
513 if (nbits <= (int)BITS_PER_LONG)
514 convert_SM_to_2C_to_SM();
515 }
516 return *this;
517}
518
519const sc_signed &
520sc_signed::operator=(double v)
521{
522 is_bad_double(v);
523 if (v < 0) {
524 v = -v;
525 sgn = SC_NEG;
526 } else {
527 sgn = SC_POS;
528 }
529
530 int i = 0;
531 while (std::floor(v) && (i < ndigits)) {
532 digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) &
533 DIGIT_MASK;
534 v /= DIGIT_RADIX;
535 }
536 vec_zero(i, ndigits, digit);
537 convert_SM_to_2C_to_SM();
538 return *this;
539}
540
541
542// ----------------------------------------------------------------------------
543
544const sc_signed &
545sc_signed::operator = (const sc_bv_base &v)
546{
547 int minlen = sc_min(nbits, v.length());
548 int i = 0;
549 for (; i < minlen; ++i) {
550 safe_set(i, v.get_bit(i), digit);
551 }
552 for (; i < nbits; ++i) {
553 safe_set(i, 0, digit); // zero-extend
554 }
555 convert_2C_to_SM();
556 return *this;
557}
558
559const sc_signed &
560sc_signed::operator = (const sc_lv_base &v)
561{
562 int minlen = sc_min(nbits, v.length());
563 int i = 0;
564 for (; i < minlen; ++i) {
565 safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit);
566 }
567 for (; i < nbits; ++i) {
568 safe_set(i, 0, digit); // zero-extend
569 }
570 convert_2C_to_SM();
571 return *this;
572}
573
574
575// explicit conversion to character string
576const std::string
577sc_signed::to_string(sc_numrep numrep) const
578{
579 int len = length();
580 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
581 return aa.to_string(numrep);
582}
583
584const std::string
585sc_signed::to_string(sc_numrep numrep, bool w_prefix) const
586{
587 int len = length();
588 sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
589 return aa.to_string(numrep, w_prefix);
590}
591
592
593// ----------------------------------------------------------------------------
594// SECTION: Interfacing with sc_int_base
595// ----------------------------------------------------------------------------
596
597const sc_signed &
598sc_signed::operator = (const sc_int_base &v)
599{
600 return operator = ((int64)v);
601}
602
603
604sc_signed
605operator + (const sc_unsigned &u, const sc_int_base &v)
606{
607 return operator + (u, static_cast<int64>(v));
608}
609
610sc_signed
611operator + (const sc_int_base &u, const sc_unsigned &v)
612{
613 return operator + (static_cast<int64>(u), v);
614}
615
616sc_signed
617operator + (const sc_signed &u, const sc_int_base &v)
618{
619 return operator + (u, (int64)v);
620}
621
622sc_signed
623operator + (const sc_int_base &u, const sc_signed &v)
624{
625 return operator + ((int64)u, v);
626}
627
628const sc_signed &
629sc_signed::operator += (const sc_int_base &v)
630{
631 return operator += ((int64)v);
632}
633
634
635sc_signed
636operator - (const sc_unsigned &u, const sc_int_base &v)
637{
638 return operator - (u, (int64)v);
639}
640
641sc_signed
642operator - (const sc_int_base &u, const sc_unsigned &v)
643{
644 return operator - ((int64)u, v);
645}
646
647sc_signed
648operator - (const sc_signed &u, const sc_int_base &v)
649{
650 return operator - (u, (int64)v);
651}
652
653sc_signed
654operator - (const sc_int_base &u, const sc_signed &v)
655{
656 return operator - ((int64)u, v);
657}
658
659const sc_signed &
660sc_signed::operator -= (const sc_int_base &v)
661{
662 return operator -= ((int64)v);
663}
664
665
666sc_signed
667operator * (const sc_unsigned &u, const sc_int_base &v)
668{
669 return operator * (u, static_cast<int64>(v));
670}
671
672sc_signed
673operator * (const sc_int_base &u, const sc_unsigned &v)
674{
675 return operator * (static_cast<int64>(u), v);
676}
677
678sc_signed
679operator * (const sc_signed &u, const sc_int_base &v)
680{
681 return operator * (u, (int64)v);
682}
683
684sc_signed
685operator * (const sc_int_base &u, const sc_signed &v)
686{
687 return operator * ((int64)u, v);
688}
689
690const sc_signed &
691sc_signed::operator *= (const sc_int_base &v)
692{
693 return operator *= ((int64)v);
694}
695
696
697sc_signed
698operator / (const sc_unsigned &u, const sc_int_base &v)
699{
700 return operator / (u, static_cast<int64>(v));
701}
702
703sc_signed
704operator / (const sc_int_base &u, const sc_unsigned &v)
705{
706 return operator / (static_cast<int64>(u), v);
707}
708
709sc_signed
710operator / (const sc_signed &u, const sc_int_base &v)
711{
712 return operator / (u, (int64)v);
713}
714
715sc_signed
716operator / (const sc_int_base &u, const sc_signed &v)
717{
718 return operator / ((int64)u, v);
719}
720
721const sc_signed &
722sc_signed::operator /= (const sc_int_base &v)
723{
724 return operator /= ((int64)v);
725}
726
727
728sc_signed
729operator % (const sc_unsigned &u, const sc_int_base &v)
730{
731 return operator % (u, static_cast<int64>(v));
732}
733
734sc_signed
735operator % (const sc_int_base &u, const sc_unsigned &v)
736{
737 return operator % (static_cast<int64>(u), v);
738}
739
740sc_signed
741operator % (const sc_signed &u, const sc_int_base &v)
742{
743 return operator % (u, (int64)v);
744}
745
746sc_signed
747operator % (const sc_int_base &u, const sc_signed &v)
748{
749 return operator % ((int64)u, v);
750}
751
752const sc_signed &
753sc_signed::operator %= (const sc_int_base &v)
754{
755 return operator %= ((int64)v);
756}
757
758
759sc_signed
760operator & (const sc_unsigned &u, const sc_int_base &v)
761{
762 return operator & (u, static_cast<int64>(v));
763}
764
765sc_signed
766operator & (const sc_int_base &u, const sc_unsigned &v)
767{
768 return operator & (static_cast<int64>(u), v);
769}
770
771sc_signed
772operator & (const sc_signed &u, const sc_int_base &v)
773{
774 return operator & (u, (int64)v);
775}
776
777sc_signed
778operator & (const sc_int_base &u, const sc_signed &v)
779{
780 return operator & ((int64)u, v);
781}
782
783const sc_signed &
784sc_signed::operator &= (const sc_int_base &v)
785{
786 return operator &= ((int64)v);
787}
788
789
790sc_signed
791operator | (const sc_unsigned &u, const sc_int_base &v)
792{
793 return operator | (u, static_cast<int64>(v));
794}
795
796sc_signed
797operator | (const sc_int_base &u, const sc_unsigned &v)
798{
799 return operator | (static_cast<int64>(u), v);
800}
801
802sc_signed
803operator | (const sc_signed& u, const sc_int_base &v)
804{
805 return operator|(u, (int64)v);
806}
807
808sc_signed
809operator | (const sc_int_base &u, const sc_signed &v)
810{
811 return operator | ((int64)u, v);
812}
813
814const sc_signed &
815sc_signed::operator |= (const sc_int_base &v)
816{
817 return operator |= ((int64)v);
818}
819
820
821sc_signed
822operator ^ (const sc_unsigned &u, const sc_int_base &v)
823{
824 return operator ^ (u, static_cast<int64>(v));
825}
826
827sc_signed
828operator ^ (const sc_int_base &u, const sc_unsigned &v)
829{
830 return operator ^ (static_cast<int64>(u), v);
831}
832
833sc_signed
834operator ^ (const sc_signed &u, const sc_int_base &v)
835{
836 return operator ^ (u, (int64)v);
837}
838
839sc_signed
840operator ^ (const sc_int_base &u, const sc_signed &v)
841{
842 return operator ^ ((int64)u, v);
843}
844
845const sc_signed &
846sc_signed::operator ^= (const sc_int_base &v)
847{
848 return operator ^= ((int64)v);
849}
850
851
852sc_signed
853operator << (const sc_signed &u, const sc_int_base &v)
854{
855 return operator << (u, (int64)v);
856}
857
858const sc_signed &
859sc_signed::operator <<= (const sc_int_base &v)
860{
861 return operator <<= ((int64)v);
862}
863
864
865sc_signed
866operator >> (const sc_signed &u, const sc_int_base &v)
867{
868 return operator >> (u, (int64)v);
869}
870
871const sc_signed &
872sc_signed::operator >>= (const sc_int_base &v)
873{
874 return operator >>= ((int64)v);
875}
876
877
878bool
879operator == (const sc_signed &u, const sc_int_base &v)
880{
881 return operator == (u, (int64)v);
882}
883
884bool
885operator == (const sc_int_base &u, const sc_signed &v)
886{
887 return operator == ((int64)u, v);
888}
889
890
891bool
892operator != (const sc_signed &u, const sc_int_base &v)
893{
894 return operator != (u, (int64)v);
895}
896
897bool
898operator != (const sc_int_base &u, const sc_signed &v)
899{
900 return operator != ((int64)u, v);
901}
902
903
904bool
905operator < (const sc_signed &u, const sc_int_base &v)
906{
907 return operator < (u, (int64)v);
908}
909
910bool
911operator < (const sc_int_base &u, const sc_signed &v)
912{
913 return operator < ((int64)u, v);
914}
915
916
917bool
918operator <= (const sc_signed &u, const sc_int_base &v)
919{
920 return operator <= (u, (int64)v);
921}
922
923bool
924operator <= (const sc_int_base &u, const sc_signed &v)
925{
926 return operator <= ((int64)u, v);
927}
928
929
930bool
931operator > (const sc_signed &u, const sc_int_base &v)
932{
933 return operator > (u, (int64)v);
934}
935
936bool
937operator > (const sc_int_base &u, const sc_signed &v)
938{
939 return operator > ((int64)u, v);
940}
941
942
943bool
944operator >= (const sc_signed &u, const sc_int_base &v)
945{
946 return operator >= (u, (int64)v);
947}
948
949bool
950operator >= (const sc_int_base &u, const sc_signed &v)
951{
952 return operator >= ((int64)u, v);
953}
954
955
956// ----------------------------------------------------------------------------
957// SECTION: Interfacing with sc_uint_base
958// ----------------------------------------------------------------------------
959
960const sc_signed &
961sc_signed::operator = (const sc_uint_base &v)
962{
963 return operator = ((uint64)v);
964}
965
966
967sc_signed
968operator + (const sc_signed &u, const sc_uint_base &v)
969{
970 return operator + (u, (uint64)v);
971}
972
973sc_signed
974operator + (const sc_uint_base &u, const sc_signed &v)
975{
976 return operator + ((uint64)u, v);
977}
978
979const sc_signed &
980sc_signed::operator += (const sc_uint_base &v)
981{
982 return operator += ((uint64)v);
983}
984
985
986sc_signed
987operator - (const sc_unsigned &u, const sc_uint_base &v)
988{
989 return operator - (u, (uint64)v);
990}
991
992sc_signed
993operator - (const sc_uint_base &u, const sc_unsigned &v)
994{
995 return operator - ((uint64)u, v);
996}
997
998sc_signed
999operator - (const sc_signed &u, const sc_uint_base &v)
1000{
1001 return operator - (u, (uint64)v);
1002}
1003
1004sc_signed
1005operator - (const sc_uint_base &u, const sc_signed &v)
1006{
1007 return operator - ((uint64)u, v);
1008}
1009
1010const sc_signed &
1011sc_signed::operator -= (const sc_uint_base &v)
1012{
1013 return operator -= ((uint64)v);
1014}
1015
1016
1017sc_signed
1018operator * (const sc_signed &u, const sc_uint_base &v)
1019{
1020 return operator * (u, (uint64)v);
1021}
1022
1023sc_signed
1024operator * (const sc_uint_base &u, const sc_signed &v)
1025{
1026 return operator * ((uint64)u, v);
1027}
1028
1029const sc_signed &
1030sc_signed::operator *= (const sc_uint_base &v)
1031{
1032 return operator *= ((uint64)v);
1033}
1034
1035
1036sc_signed
1037operator / (const sc_signed &u, const sc_uint_base &v)
1038{
1039 return operator / (u, (uint64)v);
1040}
1041
1042sc_signed
1043operator / (const sc_uint_base &u, const sc_signed &v)
1044{
1045 return operator / ((uint64)u, v);
1046}
1047
1048const sc_signed &
1049sc_signed::operator /= (const sc_uint_base &v)
1050{
1051 return operator /= ((uint64)v);
1052}
1053
1054
1055sc_signed
1056operator % (const sc_signed &u, const sc_uint_base &v)
1057{
1058 return operator % (u, (uint64)v);
1059}
1060
1061sc_signed
1062operator % (const sc_uint_base &u, const sc_signed &v)
1063{
1064 return operator % ((uint64)u, v);
1065}
1066
1067const sc_signed&
1068sc_signed::operator %= (const sc_uint_base &v)
1069{
1070 return operator %= ((uint64)v);
1071}
1072
1073
1074sc_signed
1075operator & (const sc_signed &u, const sc_uint_base &v)
1076{
1077 return operator & (u, (uint64)v);
1078}
1079
1080sc_signed
1081operator & (const sc_uint_base &u, const sc_signed &v)
1082{
1083 return operator & ((uint64)u, v);
1084}
1085
1086const sc_signed &
1087sc_signed::operator &= (const sc_uint_base &v)
1088{
1089 return operator &= ((uint64)v);
1090}
1091
1092
1093sc_signed
1094operator | (const sc_signed &u, const sc_uint_base &v)
1095{
1096 return operator | (u, (uint64)v);
1097}
1098
1099sc_signed
1100operator | (const sc_uint_base &u, const sc_signed &v)
1101{
1102 return operator | ((uint64)u, v);
1103}
1104
1105const sc_signed &
1106sc_signed::operator |= (const sc_uint_base &v)
1107{
1108 return operator |= ((uint64)v);
1109}
1110
1111
1112sc_signed
1113operator ^ (const sc_signed &u, const sc_uint_base &v)
1114{
1115 return operator ^ (u, (uint64)v);
1116}
1117
1118sc_signed
1119operator ^ (const sc_uint_base &u, const sc_signed &v)
1120{
1121 return operator ^ ((uint64)u, v);
1122}
1123
1124const sc_signed &
1125sc_signed::operator ^= (const sc_uint_base &v)
1126{
1127 return operator ^= ((uint64)v);
1128}
1129
1130
1131sc_signed
1132operator << (const sc_signed &u, const sc_uint_base &v)
1133{
1134 return operator << (u, (uint64)v);
1135}
1136
1137const sc_signed &
1138sc_signed::operator <<= (const sc_uint_base &v)
1139{
1140 return operator <<= ((uint64)v);
1141}
1142
1143
1144sc_signed
1145operator >> (const sc_signed& u, const sc_uint_base& v)
1146{
1147 return operator >> (u, (uint64)v);
1148}
1149
1150const sc_signed &
1151sc_signed::operator >>= (const sc_uint_base& v)
1152{
1153 return operator >>= ((uint64)v);
1154}
1155
1156
1157bool
1158operator == (const sc_signed &u, const sc_uint_base &v)
1159{
1160 return operator == (u, (uint64)v);
1161}
1162
1163bool
1164operator == (const sc_uint_base &u, const sc_signed &v)
1165{
1166 return operator == ((uint64)u, v);
1167}
1168
1169
1170bool
1171operator != (const sc_signed &u, const sc_uint_base &v)
1172{
1173 return operator != (u, (uint64)v);
1174}
1175
1176bool
1177operator != (const sc_uint_base &u, const sc_signed &v)
1178{
1179 return operator != ((uint64)u, v);
1180}
1181
1182
1183bool
1184operator < (const sc_signed &u, const sc_uint_base &v)
1185{
1186 return operator < (u, (uint64)v);
1187}
1188
1189bool
1190operator < (const sc_uint_base &u, const sc_signed &v)
1191{
1192 return operator < ((uint64)u, v);
1193}
1194
1195
1196bool
1197operator <= (const sc_signed &u, const sc_uint_base &v)
1198{
1199 return operator <= (u, (uint64)v);
1200}
1201
1202bool
1203operator <= (const sc_uint_base &u, const sc_signed &v)
1204{
1205 return operator <= ((uint64)u, v);
1206}
1207
1208
1209bool
1210operator > (const sc_signed &u, const sc_uint_base &v)
1211{
1212 return operator > (u, (uint64)v);
1213}
1214
1215bool
1216operator > (const sc_uint_base &u, const sc_signed &v)
1217{
1218 return operator > ((uint64)u, v);
1219}
1220
1221
1222bool
1223operator >= (const sc_signed &u, const sc_uint_base &v)
1224{
1225 return operator >= (u, (uint64)v);
1226}
1227
1228bool
1229operator >= (const sc_uint_base &u, const sc_signed &v)
1230{
1231 return operator >= ((uint64)u, v);
1232}
1233
1234
1235// ----------------------------------------------------------------------------
1236// SECTION: Input and output operators
1237// ----------------------------------------------------------------------------
1238
1239// Operators in this section are included from sc_nbcommon.cpp.
1240
1241
1242// ----------------------------------------------------------------------------
1243// SECTION: Operator macros.
1244// ----------------------------------------------------------------------------
1245
1246#define CONVERT_LONG(u) \
1247small_type u ## s = get_sign(u); \
1248sc_digit u ## d[DIGITS_PER_ULONG]; \
1249from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
1250
1251#define CONVERT_LONG_2(u) \
1252sc_digit u ## d[DIGITS_PER_ULONG]; \
1253from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
1254
1255#define CONVERT_INT(u) \
1256small_type u ## s = get_sign(u); \
1257sc_digit u ## d[DIGITS_PER_UINT]; \
1258from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
1259
1260#define CONVERT_INT_2(u) \
1261sc_digit u ## d[DIGITS_PER_UINT]; \
1262from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
1263
1264#define CONVERT_INT64(u) \
1265small_type u ## s = get_sign(u); \
1266sc_digit u ## d[DIGITS_PER_UINT64]; \
1267from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
1268
1269#define CONVERT_INT64_2(u) \
1270sc_digit u ## d[DIGITS_PER_UINT64]; \
1271from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
1272
1273
1274// ----------------------------------------------------------------------------
1275// SECTION: PLUS operators: +, +=, ++
1276// ----------------------------------------------------------------------------
1277
1278// Cases to consider when computing u + v:
1279// 1. 0 + v = v
1280// 2. u + 0 = u
1281// 3. if sgn(u) == sgn(v)
1282// 3.1 u + v = +(u + v) = sgn(u) * (u + v)
1283// 3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
1284// 4. if sgn(u) != sgn(v)
1285// 4.1 u + (-v) = u - v = sgn(u) * (u - v)
1286// 4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
1287//
1288// Specialization of above cases for computing ++u or u++:
1289// 1. 0 + 1 = 1
1290// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
1291// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
1292
1293sc_signed
1294operator + (const sc_unsigned &u, const sc_signed &v)
1295{
1296 if (u.sgn == SC_ZERO) // case 1
1297 return sc_signed(v);
1298
1299 if (v.sgn == SC_ZERO) // case 2
1300 return sc_signed(u);
1301
1302 // cases 3 and 4
1303 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1304 v.sgn, v.nbits, v.ndigits, v.digit);
1305}
1306
1307
1308sc_signed
1309operator + (const sc_signed &u, const sc_unsigned &v)
1310{
1311 if (u.sgn == SC_ZERO) // case 1
1312 return sc_signed(v);
1313
1314 if (v.sgn == SC_ZERO) // case 2
1315 return sc_signed(u);
1316
1317 // cases 3 and 4
1318 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1319 v.sgn, v.nbits, v.ndigits, v.digit);
1320}
1321
1322
1323sc_signed
1324operator + (const sc_signed &u, const sc_signed &v)
1325{
1326 if (u.sgn == SC_ZERO) // case 1
1327 return sc_signed(v);
1328
1329 if (v.sgn == SC_ZERO) // case 2
1330 return sc_signed(u);
1331
1332 // cases 3 and 4
1333 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1334 v.sgn, v.nbits, v.ndigits, v.digit);
1335}
1336
1337
1338sc_signed
1339operator + (const sc_signed &u, int64 v)
1340{
1341 if (v == 0) // case 2
1342 return sc_signed(u);
1343
1344 CONVERT_INT64(v);
1345
1346 if (u.sgn == SC_ZERO) // case 1
1347 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1348
1349 // cases 3 and 4
1350 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1351 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1352}
1353
1354
1355sc_signed
1356operator + (int64 u, const sc_signed &v)
1357{
1358 if (u == 0) // case 1
1359 return sc_signed(v);
1360
1361 CONVERT_INT64(u);
1362
1363 if (v.sgn == SC_ZERO) // case 2
1364 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1365
1366 // cases 3 and 4
1367 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1368 v.sgn, v.nbits, v.ndigits, v.digit);
1369}
1370
1371
1372sc_signed
1373operator + (const sc_unsigned &u, int64 v)
1374{
1375 if (v == 0) // case 2
1376 return sc_signed(u);
1377
1378 CONVERT_INT64(v);
1379
1380 if (u.sgn == SC_ZERO) // case 1
1381 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1382
1383 // cases 3 and 4
1384 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1385 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1386}
1387
1388
1389sc_signed
1390operator + (int64 u, const sc_unsigned &v)
1391{
1392 if (u == 0) // case 1
1393 return sc_signed(v);
1394
1395 CONVERT_INT64(u);
1396
1397 if (v.sgn == SC_ZERO) // case 2
1398 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1399
1400 // cases 3 and 4
1401 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1402 v.sgn, v.nbits, v.ndigits, v.digit);
1403}
1404
1405
1406sc_signed
1407operator + (const sc_signed &u, uint64 v)
1408{
1409 if (v == 0) // case 2
1410 return sc_signed(u);
1411
1412 CONVERT_INT64(v);
1413
1414 if (u.sgn == SC_ZERO) // case 1
1415 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1416
1417 // cases 3 and 4
1418 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1419 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1420}
1421
1422
1423sc_signed
1424operator + (uint64 u, const sc_signed &v)
1425{
1426 if (u == 0) // case 1
1427 return sc_signed(v);
1428
1429 CONVERT_INT64(u);
1430
1431 if (v.sgn == SC_ZERO) // case 2
1432 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1433
1434 // cases 3 and 4
1435 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1436 v.sgn, v.nbits, v.ndigits, v.digit);
1437}
1438
1439
1440sc_signed
1441operator + (const sc_signed &u, long v)
1442{
1443 if (v == 0) // case 2
1444 return sc_signed(u);
1445
1446 CONVERT_LONG(v);
1447
1448 if (u.sgn == SC_ZERO) // case 1
1449 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1450
1451 // cases 3 and 4
1452 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1453 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1454}
1455
1456
1457sc_signed
1458operator + (long u, const sc_signed &v)
1459{
1460 if (u == 0) // case 1
1461 return sc_signed(v);
1462
1463 CONVERT_LONG(u);
1464
1465 if (v.sgn == SC_ZERO) // case 2
1466 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1467
1468 // cases 3 and 4
1469 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1470 v.sgn, v.nbits, v.ndigits, v.digit);
1471}
1472
1473
1474sc_signed
1475operator + (const sc_unsigned &u, long v)
1476{
1477 if (v == 0) // case 2
1478 return sc_signed(u);
1479
1480 CONVERT_LONG(v);
1481
1482 if (u.sgn == SC_ZERO) // case 1
1483 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1484
1485 // cases 3 and 4
1486 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1487 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1488}
1489
1490
1491sc_signed
1492operator + (long u, const sc_unsigned &v)
1493{
1494 if (u == 0) // case 1
1495 return sc_signed(v);
1496
1497 CONVERT_LONG(u);
1498
1499 if (v.sgn == SC_ZERO) // case 2
1500 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1501
1502 // cases 3 and 4
1503 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1504 v.sgn, v.nbits, v.ndigits, v.digit);
1505}
1506
1507
1508sc_signed
1509operator + (const sc_signed &u, unsigned long v)
1510{
1511 if (v == 0) // case 2
1512 return sc_signed(u);
1513
1514 CONVERT_LONG(v);
1515
1516 if (u.sgn == SC_ZERO) // case 1
1517 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1518
1519 // cases 3 and 4
1520 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1521 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1522}
1523
1524
1525sc_signed
1526operator + (unsigned long u, const sc_signed &v)
1527{
1528 if (u == 0) // case 1
1529 return sc_signed(v);
1530
1531 CONVERT_LONG(u);
1532
1533 if (v.sgn == SC_ZERO) // case 2
1534 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1535
1536 // cases 3 and 4
1537 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1538 v.sgn, v.nbits, v.ndigits, v.digit);
1539}
1540
1541// The rest of the operators in this section are included from
1542// sc_nbcommon.cpp.
1543
1544// ----------------------------------------------------------------------------
1545// SECTION: MINUS operators: -, -=, --
1546// ----------------------------------------------------------------------------
1547
1548// Cases to consider when computing u + v:
1549// 1. u - 0 = u
1550// 2. 0 - v = -v
1551// 3. if sgn(u) != sgn(v)
1552// 3.1 u - (-v) = u + v = sgn(u) * (u + v)
1553// 3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
1554// 4. if sgn(u) == sgn(v)
1555// 4.1 u - v = +(u - v) = sgn(u) * (u - v)
1556// 4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
1557//
1558// Specialization of above cases for computing --u or u--:
1559// 1. 0 - 1 = -1
1560// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
1561// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
1562
1563sc_signed
1564operator - (const sc_unsigned &u, const sc_unsigned &v)
1565{
1566 if (v.sgn == SC_ZERO) // case 1
1567 return sc_signed(u);
1568
1569 if (u.sgn == SC_ZERO) // case 2
1570 return sc_signed(v, -v.sgn);
1571
1572 // cases 3 and 4
1573 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1574 -v.sgn, v.nbits, v.ndigits, v.digit);
1575}
1576
1577
1578sc_signed
1579operator - (const sc_unsigned &u, const sc_signed &v)
1580{
1581 if (v.sgn == SC_ZERO) // case 1
1582 return sc_signed(u);
1583
1584 if (u.sgn == SC_ZERO) // case 2
1585 return sc_signed(v, -v.sgn);
1586
1587 // cases 3 and 4
1588 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1589 -v.sgn, v.nbits, v.ndigits, v.digit);
1590}
1591
1592
1593sc_signed
1594operator - (const sc_signed &u, const sc_unsigned &v)
1595{
1596 if (v.sgn == SC_ZERO) // case 1
1597 return sc_signed(u);
1598
1599 if (u.sgn == SC_ZERO) // case 2
1600 return sc_signed(v, -v.sgn);
1601
1602 // cases 3 and 4
1603 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1604 -v.sgn, v.nbits, v.ndigits, v.digit);
1605}
1606
1607
1608sc_signed
1609operator - (const sc_signed &u, const sc_signed &v)
1610{
1611 if (v.sgn == SC_ZERO) // case 1
1612 return sc_signed(u);
1613
1614 if (u.sgn == SC_ZERO) // case 2
1615 return sc_signed(v, -v.sgn);
1616
1617 // cases 3 and 4
1618 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1619 -v.sgn, v.nbits, v.ndigits, v.digit);
1620}
1621
1622
1623sc_signed
1624operator - (const sc_signed &u, int64 v)
1625{
1626 if (v == 0) // case 1
1627 return sc_signed(u);
1628
1629 CONVERT_INT64(v);
1630
1631 if (u.sgn == SC_ZERO) // case 2
1632 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1633
1634 // cases 3 and 4
1635 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1636 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1637}
1638
1639
1640sc_signed
1641operator - (int64 u, const sc_signed &v)
1642{
1643 if (u == 0) // case 1
1644 return sc_signed(v, -v.sgn);
1645
1646 CONVERT_INT64(u);
1647
1648 if (v.sgn == SC_ZERO) // case 2
1649 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1650
1651 // cases 3 and 4
1652 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1653 -v.sgn, v.nbits, v.ndigits, v.digit);
1654}
1655
1656
1657sc_signed
1658operator - (const sc_unsigned &u, int64 v)
1659{
1660 if (v == 0) // case 1
1661 return sc_signed(u);
1662
1663 CONVERT_INT64(v);
1664
1665 if (u.sgn == SC_ZERO) // case 2
1666 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1667
1668 // cases 3 and 4
1669 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1670 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1671}
1672
1673
1674sc_signed
1675operator - (int64 u, const sc_unsigned &v)
1676{
1677 if (u == 0) // case 1
1678 return sc_signed(v, -v.sgn);
1679
1680 CONVERT_INT64(u);
1681
1682 if (v.sgn == SC_ZERO) // case 2
1683 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1684
1685 // cases 3 and 4
1686 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1687 -v.sgn, v.nbits, v.ndigits, v.digit);
1688}
1689
1690
1691sc_signed
1692operator - (const sc_signed &u, uint64 v)
1693{
1694 if (v == 0) // case 1
1695 return sc_signed(u);
1696
1697 CONVERT_INT64(v);
1698
1699 if (u.sgn == SC_ZERO) // case 2
1700 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1701
1702 // cases 3 and 4
1703
1704 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1705 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1706}
1707
1708
1709sc_signed
1710operator - (uint64 u, const sc_signed &v)
1711{
1712 if (u == 0) // case 1
1713 return sc_signed(v, -v.sgn);
1714
1715 CONVERT_INT64(u);
1716
1717 if (v.sgn == SC_ZERO) // case 2
1718 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1719
1720 // cases 3 and 4
1721 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1722 -v.sgn, v.nbits, v.ndigits, v.digit);
1723}
1724
1725
1726sc_signed
1727operator - (const sc_unsigned &u, uint64 v)
1728{
1729 if (v == 0) // case 1
1730 return sc_signed(u);
1731
1732 CONVERT_INT64(v);
1733
1734 if (u.sgn == SC_ZERO) // case 2
1735 return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
1736
1737 // cases 3 and 4
1738 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1739 -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1740}
1741
1742
1743sc_signed
1744operator - (uint64 u, const sc_unsigned &v)
1745{
1746 if (u == 0) // case 1
1747 return sc_signed(v, -v.sgn);
1748
1749 CONVERT_INT64(u);
1750
1751 if (v.sgn == SC_ZERO) // case 2
1752 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
1753
1754 // cases 3 and 4
1755 return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1756 -v.sgn, v.nbits, v.ndigits, v.digit);
1757}
1758
1759
1760sc_signed
1761operator - (const sc_signed &u, long v)
1762{
1763 if (v == 0) // case 1
1764 return sc_signed(u);
1765
1766 CONVERT_LONG(v);
1767
1768 if (u.sgn == SC_ZERO) // case 2
1769 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1770
1771 // cases 3 and 4
1772 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1773 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1774}
1775
1776
1777sc_signed
1778operator - (long u, const sc_signed &v)
1779{
1780 if (u == 0) // case 1
1781 return sc_signed(v, -v.sgn);
1782
1783 CONVERT_LONG(u);
1784
1785 if (v.sgn == SC_ZERO) // case 2
1786 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1787
1788 // cases 3 and 4
1789 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1790 -v.sgn, v.nbits, v.ndigits, v.digit);
1791}
1792
1793
1794sc_signed
1795operator - (const sc_unsigned &u, long v)
1796{
1797 if (v == 0) // case 1
1798 return sc_signed(u);
1799
1800 CONVERT_LONG(v);
1801
1802 if (u.sgn == SC_ZERO) // case 2
1803 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1804
1805 // cases 3 and 4
1806 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1807 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1808}
1809
1810
1811sc_signed
1812operator - (long u, const sc_unsigned &v)
1813{
1814 if (u == 0) // case 1
1815 return sc_signed(v, -v.sgn);
1816
1817 CONVERT_LONG(u);
1818
1819 if (v.sgn == SC_ZERO) // case 2
1820 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1821
1822 // cases 3 and 4
1823 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1824 -v.sgn, v.nbits, v.ndigits, v.digit);
1825}
1826
1827
1828sc_signed
1829operator - (const sc_signed &u, unsigned long v)
1830{
1831 if (v == 0) // case 1
1832 return sc_signed(u);
1833
1834 CONVERT_LONG(v);
1835
1836 if (u.sgn == SC_ZERO) // case 2
1837 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1838
1839 // cases 3 and 4
1840 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1841 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1842}
1843
1844
1845sc_signed
1846operator - (unsigned long u, const sc_signed &v)
1847{
1848 if (u == 0) // case 1
1849 return sc_signed(v, -v.sgn);
1850
1851 CONVERT_LONG(u);
1852
1853 if (v.sgn == SC_ZERO) // case 2
1854 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1855
1856 // cases 3 and 4
1857 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1858 -v.sgn, v.nbits, v.ndigits, v.digit);
1859}
1860
1861
1862sc_signed
1863operator - (const sc_unsigned &u, unsigned long v)
1864{
1865 if (v == 0) // case 1
1866 return sc_signed(u);
1867
1868 CONVERT_LONG(v);
1869
1870 if (u.sgn == SC_ZERO) // case 2
1871 return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
1872
1873 // cases 3 and 4
1874 return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
1875 -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
1876}
1877
1878
1879sc_signed
1880operator - (unsigned long u, const sc_unsigned &v)
1881{
1882 if (u == 0) // case 1
1883 return sc_signed(v, -v.sgn);
1884
1885 CONVERT_LONG(u);
1886
1887 if (v.sgn == SC_ZERO) // case 2
1888 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
1889
1890 // cases 3 and 4
1891 return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
1892 -v.sgn, v.nbits, v.ndigits, v.digit);
1893}
1894
1895// The rest of the operators in this section are included from
1896// sc_nbcommon.cpp.
1897
1898
1899// ----------------------------------------------------------------------------
1900// SECTION: MULTIPLICATION operators: *, *=
1901// ----------------------------------------------------------------------------
1902
1903// Cases to consider when computing u * v:
1904// 1. u * 0 = 0 * v = 0
1905// 2. 1 * v = v and -1 * v = -v
1906// 3. u * 1 = u and u * -1 = -u
1907// 4. u * v = u * v
1908
1909sc_signed
1910operator * (const sc_unsigned &u, const sc_signed &v)
1911{
1912 small_type s = mul_signs(u.sgn, v.sgn);
1913
1914 if (s == SC_ZERO) // case 1
1915 return sc_signed();
1916
1917 // cases 2-4
1918 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1919 v.nbits, v.ndigits, v.digit);
1920}
1921
1922
1923sc_signed
1924operator * (const sc_signed &u, const sc_unsigned &v)
1925{
1926 small_type s = mul_signs(u.sgn, v.sgn);
1927
1928 if (s == SC_ZERO) // case 1
1929 return sc_signed();
1930
1931 // cases 2-4
1932 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1933 v.nbits, v.ndigits, v.digit);
1934}
1935
1936
1937sc_signed
1938operator * (const sc_signed &u, const sc_signed &v)
1939{
1940 small_type s = mul_signs(u.sgn, v.sgn);
1941
1942 if (s == SC_ZERO) // case 1
1943 return sc_signed();
1944
1945 // cases 2-4
1946 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1947 v.nbits, v.ndigits, v.digit);
1948}
1949
1950
1951sc_signed
1952operator * (const sc_signed &u, int64 v)
1953{
1954 small_type s = mul_signs(u.sgn, get_sign(v));
1955
1956 if (s == SC_ZERO) // case 1
1957 return sc_signed();
1958
1959 CONVERT_INT64_2(v);
1960
1961 // cases 2-4
1962 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1963 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1964}
1965
1966
1967sc_signed
1968operator * (int64 u, const sc_signed &v)
1969{
1970 small_type s = mul_signs(v.sgn, get_sign(u));
1971
1972 if (s == SC_ZERO) // case 1
1973 return sc_signed();
1974
1975 CONVERT_INT64_2(u);
1976
1977 // cases 2-4
1978 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
1979 v.nbits, v.ndigits, v.digit);
1980}
1981
1982
1983sc_signed
1984operator * (const sc_unsigned &u, int64 v)
1985{
1986 small_type s = mul_signs(u.sgn, get_sign(v));
1987
1988 if (s == SC_ZERO) // case 1
1989 return sc_signed();
1990
1991 CONVERT_INT64_2(v);
1992
1993 // cases 2-4
1994 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
1995 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
1996}
1997
1998
1999sc_signed
2000operator * (int64 u, const sc_unsigned &v)
2001{
2002 small_type s = mul_signs(v.sgn, get_sign(u));
2003
2004 if (s == SC_ZERO) // case 1
2005 return sc_signed();
2006
2007 CONVERT_INT64_2(u);
2008
2009 // cases 2-4
2010 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2011 v.nbits, v.ndigits, v.digit);
2012}
2013
2014
2015sc_signed
2016operator * (const sc_signed &u, uint64 v)
2017{
2018 small_type s = mul_signs(u.sgn, get_sign(v));
2019
2020 if (s == SC_ZERO) // case 1
2021 return sc_signed();
2022
2023 CONVERT_INT64_2(v);
2024
2025 // cases 2-4
2026 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2027 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2028}
2029
2030
2031sc_signed
2032operator * (uint64 u, const sc_signed &v)
2033{
2034 small_type s = mul_signs(v.sgn, get_sign(u));
2035
2036 if (s == SC_ZERO) // case 1
2037 return sc_signed();
2038
2039 CONVERT_INT64_2(u);
2040
2041 // cases 2-4
2042 return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2043 v.nbits, v.ndigits, v.digit);
2044}
2045
2046
2047sc_signed
2048operator * (const sc_signed &u, long v)
2049{
2050 small_type s = mul_signs(u.sgn, get_sign(v));
2051
2052 if (s == SC_ZERO) // case 1
2053 return sc_signed();
2054
2055 CONVERT_LONG_2(v);
2056
2057 // cases 2-4
2058 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2059 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2060}
2061
2062
2063sc_signed
2064operator * (long u, const sc_signed &v)
2065{
2066 small_type s = mul_signs(v.sgn, get_sign(u));
2067
2068 if (s == SC_ZERO) // case 1
2069 return sc_signed();
2070
2071 CONVERT_LONG_2(u);
2072
2073 // cases 2-4
2074 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2075 v.nbits, v.ndigits, v.digit);
2076}
2077
2078
2079sc_signed
2080operator * (const sc_unsigned &u, long v)
2081{
2082 small_type s = mul_signs(u.sgn, get_sign(v));
2083
2084 if (s == SC_ZERO) // case 1
2085 return sc_signed();
2086
2087 CONVERT_LONG_2(v);
2088
2089 // cases 2-4
2090 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2091 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2092}
2093
2094
2095sc_signed
2096operator * (long u, const sc_unsigned &v)
2097{
2098 small_type s = mul_signs(v.sgn, get_sign(u));
2099
2100 if (s == SC_ZERO) // case 1
2101 return sc_signed();
2102
2103 CONVERT_LONG_2(u);
2104
2105 // cases 2-4
2106 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2107 v.nbits, v.ndigits, v.digit);
2108}
2109
2110
2111sc_signed
2112operator * (const sc_signed &u, unsigned long v)
2113{
2114 small_type s = mul_signs(u.sgn, get_sign(v));
2115
2116 if (s == SC_ZERO) // case 1
2117 return sc_signed();
2118
2119 CONVERT_LONG_2(v);
2120
2121 // else cases 2-4
2122 return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
2123 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2124}
2125
2126sc_signed
2127operator * (unsigned long u, const sc_signed &v)
2128{
2129 small_type s = mul_signs(v.sgn, get_sign(u));
2130
2131 if (s == SC_ZERO) // case 1
2132 return sc_signed();
2133
2134 CONVERT_LONG_2(u);
2135
2136 // cases 2-4
2137 return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2138 v.nbits, v.ndigits, v.digit);
2139}
2140
2141// The rest of the operators in this section are included from
2142// sc_nbcommon.cpp.
2143
2144
2145// ----------------------------------------------------------------------------
2146// SECTION: DIVISION operators: /, /=
2147// ----------------------------------------------------------------------------
2148
2149// Cases to consider when finding the quotient q = floor(u/v):
2150// Note that u = q * v + r for r < q.
2151// 1. 0 / 0 or u / 0 => error
2152// 2. 0 / v => 0 = 0 * v + 0
2153// 3. u / v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
2154// 4. u / v & &u < v => u = 0 * v + u - u can be 1 or -1
2155// 5. u / v & &u > v => u = q * v + r - v can be 1 or -1
2156
2157sc_signed
2158operator / (const sc_unsigned &u, const sc_signed &v)
2159{
2160 small_type s = mul_signs(u.sgn, v.sgn);
2161
2162 if (s == SC_ZERO) {
2163 div_by_zero(v.sgn); // case 1
2164 return sc_signed(); // case 2
2165 }
2166
2167 // other cases
2168 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2169 v.nbits, v.ndigits, v.digit);
2170}
2171
2172
2173sc_signed
2174operator / (const sc_signed &u, const sc_unsigned &v)
2175{
2176 small_type s = mul_signs(u.sgn, v.sgn);
2177
2178 if (s == SC_ZERO) {
2179 div_by_zero(v.sgn); // case 1
2180 return sc_signed(); // case 2
2181 }
2182
2183 // other cases
2184 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2185 v.nbits, v.ndigits, v.digit);
2186}
2187
2188
2189sc_signed
2190operator / (const sc_signed &u, const sc_signed &v)
2191{
2192 small_type s = mul_signs(u.sgn, v.sgn);
2193
2194 if (s == SC_ZERO) {
2195 div_by_zero(v.sgn); // case 1
2196 return sc_signed(); // case 2
2197 }
2198
2199 // other cases
2200 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2201 v.nbits, v.ndigits, v.digit);
2202}
2203
2204
2205sc_signed
2206operator / (const sc_signed &u, int64 v)
2207{
2208 small_type s = mul_signs(u.sgn, get_sign(v));
2209
2210 if (s == SC_ZERO) {
2211 div_by_zero(v); // case 1
2212 return sc_signed(); // case 2
2213 }
2214
2215 CONVERT_INT64_2(v);
2216
2217 // other cases
2218 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2219 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2220}
2221
2222
2223sc_signed
2224operator / (int64 u, const sc_signed &v)
2225{
2226 small_type s = mul_signs(v.sgn, get_sign(u));
2227
2228 if (s == SC_ZERO) {
2229 div_by_zero(v.sgn); // case 1
2230 return sc_signed(); // case 2
2231 }
2232
2233 CONVERT_INT64_2(u);
2234
2235 // other cases
2236 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2237 v.nbits, v.ndigits, v.digit);
2238}
2239
2240
2241sc_signed
2242operator / (const sc_unsigned &u, int64 v)
2243{
2244 small_type s = mul_signs(u.sgn, get_sign(v));
2245
2246 if (s == SC_ZERO) {
2247 div_by_zero(v); // case 1
2248 return sc_signed(); // case 2
2249 }
2250
2251 CONVERT_INT64_2(v);
2252
2253 // other cases
2254 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2255 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2256}
2257
2258
2259sc_signed
2260operator / (int64 u, const sc_unsigned &v)
2261{
2262 small_type s = mul_signs(v.sgn, get_sign(u));
2263
2264 if (s == SC_ZERO) {
2265 div_by_zero(v.sgn); // case 1
2266 return sc_signed(); // case 2
2267 }
2268
2269 CONVERT_INT64_2(u);
2270
2271 // other cases
2272 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2273 v.nbits, v.ndigits, v.digit);
2274}
2275
2276
2277sc_signed
2278operator / (const sc_signed &u, uint64 v)
2279{
2280 small_type s = mul_signs(u.sgn, get_sign(v));
2281
2282 if (s == SC_ZERO) {
2283 div_by_zero(v); // case 1
2284 return sc_signed(); // case 2
2285 }
2286
2287 CONVERT_INT64_2(v);
2288
2289 // other cases
2290 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2291 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2292}
2293
2294
2295sc_signed
2296operator / (uint64 u, const sc_signed &v)
2297{
2298 small_type s = mul_signs(v.sgn, get_sign(u));
2299
2300 if (s == SC_ZERO) {
2301 div_by_zero(v.sgn); // case 1
2302 return sc_signed(); // case 2
2303
2304 }
2305
2306 CONVERT_INT64_2(u);
2307
2308 // other cases
2309 return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2310 v.nbits, v.ndigits, v.digit);
2311}
2312
2313
2314sc_signed
2315operator / (const sc_signed &u, long v)
2316{
2317 small_type s = mul_signs(u.sgn, get_sign(v));
2318
2319 if (s == SC_ZERO) {
2320 div_by_zero(v); // case 1
2321 return sc_signed(); // case 2
2322 }
2323
2324 CONVERT_LONG_2(v);
2325
2326 // other cases
2327 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2328 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2329}
2330
2331
2332sc_signed
2333operator / (long u, const sc_signed &v)
2334{
2335 small_type s = mul_signs(v.sgn, get_sign(u));
2336
2337 if (s == SC_ZERO) {
2338 div_by_zero(v.sgn); // case 1
2339 return sc_signed(); // case 2
2340 }
2341
2342 CONVERT_LONG_2(u);
2343
2344 // other cases
2345 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2346 v.nbits, v.ndigits, v.digit);
2347}
2348
2349
2350sc_signed
2351operator / (const sc_unsigned &u, long v)
2352{
2353 small_type s = mul_signs(u.sgn, get_sign(v));
2354
2355 if (s == SC_ZERO) {
2356 div_by_zero(v); // case 1
2357 return sc_signed(); // case 2
2358 }
2359
2360 CONVERT_LONG_2(v);
2361
2362 // other cases
2363 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2364 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2365}
2366
2367
2368sc_signed
2369operator / (long u, const sc_unsigned &v)
2370{
2371 small_type s = mul_signs(v.sgn, get_sign(u));
2372
2373 if (s == SC_ZERO) {
2374 div_by_zero(v.sgn); // case 1
2375 return sc_signed(); // case 2
2376 }
2377
2378 CONVERT_LONG_2(u);
2379
2380 // other cases
2381 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2382 v.nbits, v.ndigits, v.digit);
2383}
2384
2385
2386sc_signed
2387operator / (const sc_signed &u, unsigned long v)
2388{
2389 small_type s = mul_signs(u.sgn, get_sign(v));
2390
2391 if (s == SC_ZERO) {
2392 div_by_zero(v); // case 1
2393 return sc_signed(); // case 2
2394 }
2395
2396 CONVERT_LONG_2(v);
2397
2398 // other cases
2399 return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
2400 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2401}
2402
2403
2404sc_signed
2405operator / (unsigned long u, const sc_signed &v)
2406{
2407 small_type s = mul_signs(v.sgn, get_sign(u));
2408
2409 if (s == SC_ZERO) {
2410 div_by_zero(v.sgn); // case 1
2411 return sc_signed(); // case 2
2412
2413 }
2414
2415 CONVERT_LONG_2(u);
2416
2417 // other cases
2418 return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2419 v.nbits, v.ndigits, v.digit);
2420}
2421
2422// The rest of the operators in this section are included from
2423// sc_nbcommon.cpp.
2424
2425
2426// ----------------------------------------------------------------------------
2427// SECTION: MOD operators: %, %=.
2428// ----------------------------------------------------------------------------
2429
2430// Cases to consider when finding the remainder r = u % v:
2431// Note that u = q * v + r for r < q.
2432// 1. 0 % 0 or u % 0 => error
2433// 2. 0 % v => 0 = 0 * v + 0
2434// 3. u % v & &u = v => u = 1 * u + 0 - u or v can be 1 or -1
2435// 4. u % v & &u < v => u = 0 * v + u - u can be 1 or -1
2436// 5. u % v & &u > v => u = q * v + r - v can be 1 or -1
2437
2438sc_signed
2439operator % (const sc_unsigned &u, const sc_signed &v)
2440{
2441 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
2442 div_by_zero(v.sgn); // case 1
2443 return sc_signed(); // case 2
2444 }
2445
2446 // other cases
2447 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2448 v.nbits, v.ndigits, v.digit);
2449}
2450
2451
2452sc_signed
2453operator % (const sc_signed &u, const sc_unsigned &v)
2454{
2455 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
2456 div_by_zero(v.sgn); // case 1
2457 return sc_signed(); // case 2
2458 }
2459
2460 // other cases
2461 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2462 v.nbits, v.ndigits, v.digit);
2463}
2464
2465
2466sc_signed
2467operator % (const sc_signed &u, const sc_signed &v)
2468{
2469 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
2470 div_by_zero(v.sgn); // case 1
2471 return sc_signed(); // case 2
2472 }
2473
2474 // other cases
2475 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2476 v.nbits, v.ndigits, v.digit);
2477}
2478
2479
2480sc_signed
2481operator % (const sc_signed &u, int64 v)
2482{
2483 small_type vs = get_sign(v);
2484
2485 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2486 div_by_zero(v); // case 1
2487 return sc_signed(); // case 2
2488 }
2489
2490 CONVERT_INT64_2(v);
2491
2492 // other cases
2493 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2494 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2495}
2496
2497
2498sc_signed
2499operator % (int64 u, const sc_signed &v)
2500{
2501 small_type us = get_sign(u);
2502
2503 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2504 div_by_zero(v.sgn); // case 1
2505 return sc_signed(); // case 2
2506 }
2507
2508 CONVERT_INT64_2(u);
2509
2510 // other cases
2511 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2512 v.nbits, v.ndigits, v.digit);
2513}
2514
2515
2516sc_signed
2517operator % (const sc_unsigned &u, int64 v)
2518{
2519 small_type vs = get_sign(v);
2520
2521 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2522 div_by_zero(v); // case 1
2523 return sc_signed(); // case 2
2524 }
2525
2526 CONVERT_INT64_2(v);
2527
2528 // other cases
2529 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2530 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2531}
2532
2533
2534sc_signed
2535operator % (int64 u, const sc_unsigned &v)
2536{
2537 small_type us = get_sign(u);
2538
2539 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2540 div_by_zero(v.sgn); // case 1
2541 return sc_signed(); // case 2
2542 }
2543
2544 CONVERT_INT64_2(u);
2545
2546 // other cases
2547 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2548 v.nbits, v.ndigits, v.digit);
2549}
2550
2551
2552sc_signed
2553operator % (const sc_signed &u, uint64 v)
2554{
2555 if ((u.sgn == SC_ZERO) || (v == 0)) {
2556 div_by_zero(v); // case 1
2557 return sc_signed(); // case 2
2558 }
2559
2560 CONVERT_INT64_2(v);
2561
2562 // other cases
2563 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2564 BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2565}
2566
2567
2568sc_signed
2569operator % (uint64 u, const sc_signed &v)
2570{
2571 if ((u == 0) || (v.sgn == SC_ZERO)) {
2572 div_by_zero(v.sgn); // case 1
2573 return sc_signed(); // case 2
2574 }
2575
2576 CONVERT_INT64(u);
2577
2578 // other cases
2579 return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2580 v.nbits, v.ndigits, v.digit);
2581}
2582
2583
2584sc_signed
2585operator % (const sc_signed &u, long v)
2586{
2587 small_type vs = get_sign(v);
2588
2589 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2590 div_by_zero(v); // case 1
2591 return sc_signed(); // case 2
2592 }
2593
2594 CONVERT_LONG_2(v);
2595
2596 // other cases
2597 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2598 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2599}
2600
2601
2602sc_signed
2603operator % (long u, const sc_signed &v)
2604{
2605 small_type us = get_sign(u);
2606
2607 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2608 div_by_zero(v.sgn); // case 1
2609 return sc_signed(); // case 2
2610 }
2611
2612 CONVERT_LONG_2(u);
2613
2614 // other cases
2615 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2616 v.nbits, v.ndigits, v.digit);
2617}
2618
2619
2620sc_signed
2621operator % (const sc_unsigned &u, long v)
2622{
2623
2624 small_type vs = get_sign(v);
2625
2626 if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
2627 div_by_zero(v); // case 1
2628 return sc_signed(); // case 2
2629 }
2630
2631 CONVERT_LONG_2(v);
2632
2633 // other cases
2634 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2635 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2636}
2637
2638
2639sc_signed
2640operator % (long u, const sc_unsigned &v)
2641{
2642 small_type us = get_sign(u);
2643
2644 if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
2645 div_by_zero(v.sgn); // case 1
2646 return sc_signed(); // case 2
2647 }
2648
2649 CONVERT_LONG_2(u);
2650
2651 // other cases
2652 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2653 v.nbits, v.ndigits, v.digit);
2654}
2655
2656
2657sc_signed
2658operator % (const sc_signed &u, unsigned long v)
2659{
2660 if ((u.sgn == SC_ZERO) || (v == 0)) {
2661 div_by_zero(v); // case 1
2662 return sc_signed(); // case 2
2663 }
2664
2665 CONVERT_LONG_2(v);
2666
2667 // other cases
2668 return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2669 BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2670}
2671
2672
2673sc_signed
2674operator % (unsigned long u, const sc_signed &v)
2675{
2676 if ((u == 0) || (v.sgn == SC_ZERO)) {
2677 div_by_zero(v.sgn); // case 1
2678 return sc_signed(); // case 2
2679 }
2680
2681 CONVERT_LONG(u);
2682
2683 // other cases
2684 return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2685 v.nbits, v.ndigits, v.digit);
2686}
2687
2688// The rest of the operators in this section are included from
2689// sc_nbcommon.cpp.
2690
2691
2692// ----------------------------------------------------------------------------
2693// SECTION: Bitwise AND operators: &, &=
2694// ----------------------------------------------------------------------------
2695
2696// Cases to consider when computing u &v:
2697// 1. u & 0 = 0 &v = 0
2698// 2. u &v => sgn = +
2699// 3. (-u) & (-v) => sgn = -
2700// 4. u & (-v) => sgn = +
2701// 5. (-u) &v => sgn = +
2702
2703sc_signed
2704operator & (const sc_unsigned &u, const sc_signed &v)
2705{
2706 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
2707 return sc_signed();
2708
2709 // other cases
2710 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2711 v.sgn, v.nbits, v.ndigits, v.digit);
2712}
2713
2714
2715sc_signed
2716operator & (const sc_signed &u, const sc_unsigned &v)
2717{
2718 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
2719 return sc_signed();
2720
2721 // other cases
2722 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2723 v.sgn, v.nbits, v.ndigits, v.digit);
2724}
2725
2726
2727sc_signed
2728operator & (const sc_signed &u, const sc_signed &v)
2729{
2730 if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
2731 return sc_signed();
2732
2733 // other cases
2734 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2735 v.sgn, v.nbits, v.ndigits, v.digit);
2736}
2737
2738
2739sc_signed
2740operator & (const sc_signed &u, int64 v)
2741{
2742 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2743 return sc_signed();
2744
2745 CONVERT_INT64(v);
2746
2747 // other cases
2748 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2749 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2750}
2751
2752
2753sc_signed
2754operator & (int64 u, const sc_signed &v)
2755{
2756 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2757 return sc_signed();
2758
2759 CONVERT_INT64(u);
2760
2761 // other cases
2762 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2763 v.sgn, v.nbits, v.ndigits, v.digit);
2764}
2765
2766
2767sc_signed
2768operator & (const sc_unsigned &u, int64 v)
2769{
2770 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2771 return sc_signed();
2772
2773 CONVERT_INT64(v);
2774
2775 // other cases
2776 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2777 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2778}
2779
2780
2781sc_signed
2782operator & (int64 u, const sc_unsigned &v)
2783{
2784 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2785 return sc_signed();
2786
2787 CONVERT_INT64(u);
2788
2789 // other cases
2790 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2791 v.sgn, v.nbits, v.ndigits, v.digit);
2792}
2793
2794
2795sc_signed
2796operator & (const sc_signed &u, uint64 v)
2797{
2798 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2799 return sc_signed();
2800
2801 CONVERT_INT64(v);
2802
2803 // other cases
2804 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2805 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2806}
2807
2808
2809sc_signed
2810operator & (uint64 u, const sc_signed &v)
2811{
2812 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2813 return sc_signed();
2814
2815 CONVERT_INT64(u);
2816
2817 // other cases
2818 return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2819 v.sgn, v.nbits, v.ndigits, v.digit);
2820}
2821
2822
2823sc_signed
2824operator & (const sc_signed &u, long v)
2825{
2826 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2827 return sc_signed();
2828
2829 CONVERT_LONG(v);
2830
2831 // other cases
2832 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2833 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2834}
2835
2836
2837sc_signed
2838operator & (long u, const sc_signed &v)
2839{
2840 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2841 return sc_signed();
2842
2843 CONVERT_LONG(u);
2844
2845 // other cases
2846 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2847 v.sgn, v.nbits, v.ndigits, v.digit);
2848}
2849
2850
2851sc_signed
2852operator & (const sc_unsigned &u, long v)
2853{
2854 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2855 return sc_signed();
2856
2857 CONVERT_LONG(v);
2858
2859 // other cases
2860 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2861 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2862}
2863
2864
2865sc_signed
2866operator & (long u, const sc_unsigned &v)
2867{
2868 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2869 return sc_signed();
2870
2871 CONVERT_LONG(u);
2872
2873 // other cases
2874 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2875 v.sgn, v.nbits, v.ndigits, v.digit);
2876}
2877
2878
2879sc_signed
2880operator & (const sc_signed &u, unsigned long v)
2881{
2882 if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
2883 return sc_signed();
2884
2885 CONVERT_LONG(v);
2886
2887 // other cases
2888 return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2889 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
2890}
2891
2892
2893sc_signed
2894operator & (unsigned long u, const sc_signed &v)
2895{
2896 if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
2897 return sc_signed();
2898
2899 CONVERT_LONG(u);
2900
2901 // other cases
2902 return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
2903 v.sgn, v.nbits, v.ndigits, v.digit);
2904}
2905
2906// The rest of the operators in this section are included from
2907// sc_nbcommon.cpp.
2908
2909
2910// ----------------------------------------------------------------------------
2911// SECTION: Bitwise OR operators: |, |=
2912// ----------------------------------------------------------------------------
2913
2914// Cases to consider when computing u | v:
2915// 1. u | 0 = u
2916// 2. 0 | v = v
2917// 3. u | v => sgn = +
2918// 4. (-u) | (-v) => sgn = -
2919// 5. u | (-v) => sgn = -
2920// 6. (-u) | v => sgn = -
2921
2922sc_signed
2923operator | (const sc_unsigned &u, const sc_signed &v)
2924{
2925 if (v.sgn == SC_ZERO) // case 1
2926 return sc_signed(u);
2927
2928 if (u.sgn == SC_ZERO) // case 2
2929 return sc_signed(v);
2930
2931 // other cases
2932 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2933 v.sgn, v.nbits, v.ndigits, v.digit);
2934}
2935
2936
2937sc_signed
2938operator | (const sc_signed &u, const sc_unsigned &v)
2939{
2940 if (v.sgn == SC_ZERO) // case 1
2941 return sc_signed(u);
2942
2943 if (u.sgn == SC_ZERO) // case 2
2944 return sc_signed(v);
2945
2946 // other cases
2947 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2948 v.sgn, v.nbits, v.ndigits, v.digit);
2949}
2950
2951
2952sc_signed
2953operator | (const sc_signed &u, const sc_signed &v)
2954{
2955 if (v.sgn == SC_ZERO) // case 1
2956 return sc_signed(u);
2957
2958 if (u.sgn == SC_ZERO) // case 2
2959 return sc_signed(v);
2960
2961 // other cases
2962 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2963 v.sgn, v.nbits, v.ndigits, v.digit);
2964}
2965
2966
2967sc_signed
2968operator | (const sc_signed &u, int64 v)
2969{
2970 if (v == 0) // case 1
2971 return sc_signed(u);
2972
2973 CONVERT_INT64(v);
2974
2975 if (u.sgn == SC_ZERO) // case 2
2976 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
2977
2978 // other cases
2979 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
2980 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
2981}
2982
2983
2984sc_signed
2985operator | (int64 u, const sc_signed &v)
2986{
2987 if (u == 0)
2988 return sc_signed(v);
2989
2990 CONVERT_INT64(u);
2991
2992 if (v.sgn == SC_ZERO)
2993 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
2994
2995 // other cases
2996 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
2997 v.sgn, v.nbits, v.ndigits, v.digit);
2998}
2999
3000
3001sc_signed
3002operator | (const sc_unsigned &u, int64 v)
3003{
3004 if (v == 0) // case 1
3005 return sc_signed(u);
3006
3007 CONVERT_INT64(v);
3008
3009 if (u.sgn == SC_ZERO) // case 2
3010 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3011
3012 // other cases
3013 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3014 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3015}
3016
3017
3018sc_signed
3019operator | (int64 u, const sc_unsigned &v)
3020{
3021 if (u == 0)
3022 return sc_signed(v);
3023
3024 CONVERT_INT64(u);
3025
3026 if (v.sgn == SC_ZERO)
3027 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3028
3029 // other cases
3030 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3031 v.sgn, v.nbits, v.ndigits, v.digit);
3032}
3033
3034
3035sc_signed
3036operator | (const sc_signed &u, uint64 v)
3037{
3038 if (v == 0) // case 1
3039 return sc_signed(u);
3040
3041 CONVERT_INT64(v);
3042
3043 if (u.sgn == SC_ZERO) // case 2
3044 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3045
3046 // other cases
3047 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3048 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3049}
3050
3051
3052sc_signed
3053operator | (uint64 u, const sc_signed &v)
3054{
3055 if (u == 0)
3056 return sc_signed(v);
3057
3058 CONVERT_INT64(u);
3059
3060 if (v.sgn == SC_ZERO)
3061 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3062
3063 // other cases
3064 return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3065 v.sgn, v.nbits, v.ndigits, v.digit);
3066}
3067
3068
3069sc_signed
3070operator | (const sc_signed &u, long v)
3071{
3072 if (v == 0) // case 1
3073 return sc_signed(u);
3074
3075 CONVERT_LONG(v);
3076
3077 if (u.sgn == SC_ZERO) // case 2
3078 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3079
3080 // other cases
3081 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3082 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3083}
3084
3085
3086sc_signed
3087operator | (long u, const sc_signed &v)
3088{
3089 if (u == 0)
3090 return sc_signed(v);
3091
3092 CONVERT_LONG(u);
3093
3094 if (v.sgn == SC_ZERO)
3095 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3096
3097 // other cases
3098 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3099 v.sgn, v.nbits, v.ndigits, v.digit);
3100}
3101
3102
3103sc_signed
3104operator | (const sc_unsigned &u, long v)
3105{
3106 if (v == 0) // case 1
3107 return sc_signed(u);
3108
3109 CONVERT_LONG(v);
3110
3111 if (u.sgn == SC_ZERO) // case 2
3112 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3113
3114 // other cases
3115 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3116 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3117}
3118
3119
3120sc_signed
3121operator | (long u, const sc_unsigned &v)
3122{
3123 if (u == 0)
3124 return sc_signed(v);
3125
3126 CONVERT_LONG(u);
3127
3128 if (v.sgn == SC_ZERO)
3129 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3130
3131 // other cases
3132 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3133 v.sgn, v.nbits, v.ndigits, v.digit);
3134}
3135
3136
3137sc_signed
3138operator | (const sc_signed &u, unsigned long v)
3139{
3140 if (v == 0) // case 1
3141 return sc_signed(u);
3142
3143 CONVERT_LONG(v);
3144
3145 if (u.sgn == SC_ZERO) // case 2
3146 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3147
3148 // other cases
3149 return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3150 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3151}
3152
3153
3154sc_signed
3155operator | (unsigned long u, const sc_signed &v)
3156{
3157 if (u == 0)
3158 return sc_signed(v);
3159
3160 CONVERT_LONG(u);
3161
3162 if (v.sgn == SC_ZERO)
3163 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3164
3165 // other cases
3166 return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3167 v.sgn, v.nbits, v.ndigits, v.digit);
3168}
3169
3170// The rest of the operators in this section are included from
3171// sc_nbcommon.cpp.
3172
3173
3174// ----------------------------------------------------------------------------
3175// SECTION: Bitwise XOR operators: ^, ^=
3176// ----------------------------------------------------------------------------
3177
3178// Cases to consider when computing u ^ v:
3179// Note that u ^ v = (~u &v) | (u & ~v).
3180// 1. u ^ 0 = u
3181// 2. 0 ^ v = v
3182// 3. u ^ v => sgn = +
3183// 4. (-u) ^ (-v) => sgn = -
3184// 5. u ^ (-v) => sgn = -
3185// 6. (-u) ^ v => sgn = +
3186
3187sc_signed
3188operator ^ (const sc_unsigned &u, const sc_signed &v)
3189{
3190
3191 if (v.sgn == SC_ZERO) // case 1
3192 return sc_signed(u);
3193
3194 if (u.sgn == SC_ZERO) // case 2
3195 return sc_signed(v);
3196
3197 // other cases
3198 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3199 v.sgn, v.nbits, v.ndigits, v.digit);
3200
3201}
3202
3203
3204sc_signed
3205operator ^ (const sc_signed &u, const sc_unsigned &v)
3206{
3207 if (v.sgn == SC_ZERO) // case 1
3208 return sc_signed(u);
3209
3210 if (u.sgn == SC_ZERO) // case 2
3211 return sc_signed(v);
3212
3213 // other cases
3214 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3215 v.sgn, v.nbits, v.ndigits, v.digit);
3216}
3217
3218
3219sc_signed
3220operator ^ (const sc_signed &u, const sc_signed &v)
3221{
3222 if (v.sgn == SC_ZERO) // case 1
3223 return sc_signed(u);
3224
3225 if (u.sgn == SC_ZERO) // case 2
3226 return sc_signed(v);
3227
3228 // other cases
3229 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3230 v.sgn, v.nbits, v.ndigits, v.digit);
3231}
3232
3233
3234sc_signed
3235operator ^ (const sc_signed &u, int64 v)
3236{
3237 if (v == 0) // case 1
3238 return sc_signed(u);
3239
3240 CONVERT_INT64(v);
3241
3242 if (u.sgn == SC_ZERO) // case 2
3243 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3244
3245 // other cases
3246 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3247 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3248}
3249
3250
3251sc_signed
3252operator ^ (int64 u, const sc_signed &v)
3253{
3254 if (u == 0)
3255 return sc_signed(v);
3256
3257 CONVERT_INT64(u);
3258
3259 if (v.sgn == SC_ZERO)
3260 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3261
3262 // other cases
3263 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3264 v.sgn, v.nbits, v.ndigits, v.digit);
3265}
3266
3267
3268sc_signed
3269operator ^ (const sc_unsigned &u, int64 v)
3270{
3271 if (v == 0) // case 1
3272 return sc_signed(u);
3273
3274 CONVERT_INT64(v);
3275
3276 if (u.sgn == SC_ZERO) // case 2
3277 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3278
3279 // other cases
3280 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3281 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3282}
3283
3284
3285sc_signed
3286operator ^ (int64 u, const sc_unsigned &v)
3287{
3288 if (u == 0)
3289 return sc_signed(v);
3290
3291 CONVERT_INT64(u);
3292
3293 if (v.sgn == SC_ZERO)
3294 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3295
3296 // other cases
3297 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3298 v.sgn, v.nbits, v.ndigits, v.digit);
3299}
3300
3301
3302sc_signed
3303operator ^ (const sc_signed &u, uint64 v)
3304{
3305 if (v == 0) // case 1
3306 return sc_signed(u);
3307
3308 CONVERT_INT64(v);
3309
3310 if (u.sgn == SC_ZERO) // case 2
3311 return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
3312
3313 // other cases
3314 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3315 vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
3316}
3317
3318sc_signed
3319operator ^ (uint64 u, const sc_signed &v)
3320{
3321 if (u == 0)
3322 return sc_signed(v);
3323
3324 CONVERT_INT64(u);
3325
3326 if (v.sgn == SC_ZERO)
3327 return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
3328
3329 // other cases
3330 return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
3331 v.sgn, v.nbits, v.ndigits, v.digit);
3332}
3333
3334
3335sc_signed
3336operator ^ (const sc_signed &u, long v)
3337{
3338 if (v == 0) // case 1
3339 return sc_signed(u);
3340
3341 CONVERT_LONG(v);
3342
3343 if (u.sgn == SC_ZERO) // case 2
3344 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3345
3346 // other cases
3347 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3348 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3349}
3350
3351
3352sc_signed
3353operator ^ (long u, const sc_signed &v)
3354{
3355 if (u == 0)
3356 return sc_signed(v);
3357
3358 CONVERT_LONG(u);
3359
3360 if (v.sgn == SC_ZERO)
3361 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3362
3363 // other cases
3364 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3365 v.sgn, v.nbits, v.ndigits, v.digit);
3366}
3367
3368
3369sc_signed
3370operator ^ (const sc_unsigned &u, long v)
3371{
3372 if (v == 0) // case 1
3373 return sc_signed(u);
3374
3375 CONVERT_LONG(v);
3376
3377 if (u.sgn == SC_ZERO) // case 2
3378 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3379
3380 // other cases
3381 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3382 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3383}
3384
3385
3386sc_signed
3387operator ^ (long u, const sc_unsigned &v)
3388{
3389 if (u == 0)
3390 return sc_signed(v);
3391
3392 CONVERT_LONG(u);
3393
3394 if (v.sgn == SC_ZERO)
3395 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3396
3397 // other cases
3398 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3399 v.sgn, v.nbits, v.ndigits, v.digit);
3400}
3401
3402
3403sc_signed
3404operator ^ (const sc_signed &u, unsigned long v)
3405{
3406 if (v == 0) // case 1
3407 return sc_signed(u);
3408
3409 CONVERT_LONG(v);
3410
3411 if (u.sgn == SC_ZERO) // case 2
3412 return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
3413
3414 // other cases
3415 return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
3416 vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
3417}
3418
3419sc_signed
3420operator ^ (unsigned long u, const sc_signed &v)
3421{
3422 if (u == 0)
3423 return sc_signed(v);
3424
3425 CONVERT_LONG(u);
3426
3427 if (v.sgn == SC_ZERO)
3428 return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
3429
3430 // other cases
3431 return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
3432 v.sgn, v.nbits, v.ndigits, v.digit);
3433}
3434
3435// The rest of the operators in this section are included from
3436// sc_nbcommon.cpp.
3437
3438
3439// ----------------------------------------------------------------------------
3440// SECTION: Bitwise NOT operator: ~
3441// ----------------------------------------------------------------------------
3442
3443// Operators in this section are included from sc_nbcommon.cpp.
3444
3445
3446// ----------------------------------------------------------------------------
3447// SECTION: LEFT SHIFT operators: <<, <<=
3448// ----------------------------------------------------------------------------
3449
3450sc_signed
3451operator << (const sc_signed &u, const sc_unsigned &v)
3452{
3453 if (v.sgn == SC_ZERO)
3454 return sc_signed(u);
3455
3456 return operator << (u, v.to_ulong());
3457}
3458
3459// The rest of the operators in this section are included from
3460// sc_nbcommon.cpp.
3461
3462
3463// ----------------------------------------------------------------------------
3464// SECTION: RIGHT SHIFT operators: >>, >>=
3465// ----------------------------------------------------------------------------
3466
3467sc_signed
3468operator >> (const sc_signed &u, const sc_unsigned &v)
3469{
3470 if (v.sgn == SC_ZERO)
3471 return sc_signed(u);
3472
3473 return operator >> (u, v.to_ulong());
3474}
3475
3476// The rest of the operators in this section are included from
3477// sc_nbcommon.cpp.
3478
3479
3480// ----------------------------------------------------------------------------
3481// SECTION: Unary arithmetic operators.
3482// ----------------------------------------------------------------------------
3483
3484sc_signed
3485operator + (const sc_signed &u)
3486{
3487 return sc_signed(u);
3488}
3489
3490sc_signed
3491operator - (const sc_signed &u)
3492{
3493 return sc_signed(u, -u.sgn);
3494}
3495
3496sc_signed
3497operator - (const sc_unsigned &u)
3498{
3499 return sc_signed(u, -u.sgn);
3500}
3501
3502
3503// ----------------------------------------------------------------------------
3504// SECTION: EQUAL operator: ==
3505// ----------------------------------------------------------------------------
3506
3507bool
3508operator == (const sc_signed &u, const sc_signed &v)
3509{
3510 if (u.sgn != v.sgn)
3511 return false;
3512
3513 if (&u == &v)
3514 return true;
3515
3516 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) != 0)
3517 return false;
3518
3519 return true;
3520}
3521
3522
3523bool
3524operator == (const sc_signed &u, int64 v)
3525{
3526 CONVERT_INT64(v);
3527
3528 if (u.sgn != vs)
3529 return false;
3530
3531 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
3532 return false;
3533
3534 return true;
3535}
3536
3537
3538bool
3539operator == (int64 u, const sc_signed &v)
3540{
3541 CONVERT_INT64(u);
3542
3543 if (us != v.sgn)
3544 return false;
3545
3546 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
3547 return false;
3548
3549 return true;
3550}
3551
3552
3553bool
3554operator == (const sc_signed &u, uint64 v)
3555{
3556 CONVERT_INT64(v);
3557
3558 if (u.sgn != vs)
3559 return false;
3560
3561 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
3562 return false;
3563
3564 return true;
3565}
3566
3567
3568bool
3569operator == (uint64 u, const sc_signed &v)
3570{
3571 CONVERT_INT64(u);
3572
3573 if (us != v.sgn)
3574 return false;
3575
3576 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
3577 return false;
3578
3579 return true;
3580}
3581
3582
3583bool
3584operator == (const sc_signed &u, long v)
3585{
3586 CONVERT_LONG(v);
3587
3588 if (u.sgn != vs)
3589 return false;
3590
3591 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
3592 return false;
3593
3594 return true;
3595}
3596
3597
3598bool
3599operator == (long u, const sc_signed &v)
3600{
3601 CONVERT_LONG(u);
3602
3603 if (us != v.sgn)
3604 return false;
3605
3606 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
3607 return false;
3608
3609 return true;
3610}
3611
3612
3613bool
3614operator == (const sc_signed &u, unsigned long v)
3615{
3616 CONVERT_LONG(v);
3617
3618 if (u.sgn != vs)
3619 return false;
3620
3621 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
3622 return false;
3623
3624 return true;
3625}
3626
3627
3628bool
3629operator == (unsigned long u, const sc_signed &v)
3630{
3631 CONVERT_LONG(u);
3632
3633 if (us != v.sgn)
3634 return false;
3635
3636 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
3637 return false;
3638
3639 return true;
3640}
3641
3642
3643// ----------------------------------------------------------------------------
3644// SECTION: NOT_EQUAL operator: !=
3645// ----------------------------------------------------------------------------
3646
3647// Operators in this section are included from sc_nbcommon.cpp.
3648
3649
3650// ----------------------------------------------------------------------------
3651// SECTION: LESS THAN operator: <
3652// ----------------------------------------------------------------------------
3653
3654bool
3655operator < (const sc_signed &u, const sc_signed &v)
3656{
3657 if (u.sgn < v.sgn)
3658 return true;
3659
3660 if (u.sgn > v.sgn)
3661 return false;
3662
3663 // u.sgn == v.sgn
3664
3665 if (&u == &v)
3666 return false;
3667
3668 if (u.sgn == SC_POS) {
3669 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) < 0)
3670 return true;
3671 } else if (u.sgn == SC_NEG) {
3672 if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) > 0)
3673 return true;
3674 }
3675
3676 return false;
3677}
3678
3679
3680bool
3681operator < (const sc_signed &u, int64 v)
3682{
3683 CONVERT_INT64(v);
3684
3685 if (u.sgn < vs)
3686 return true;
3687
3688 if (u.sgn > vs)
3689 return false;
3690
3691 // u.sgn == vs
3692
3693 if (vs == SC_POS) {
3694 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
3695 return true;
3696 } else if (vs == SC_NEG) {
3697 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) > 0)
3698 return true;
3699 }
3700
3701 return false;
3702}
3703
3704
3705bool
3706operator < (int64 u, const sc_signed &v)
3707{
3708 CONVERT_INT64(u);
3709
3710 if (us < v.sgn)
3711 return true;
3712
3713 if (us > v.sgn)
3714 return false;
3715
3716 // us == v.sgn
3717
3718 if (us == SC_POS) {
3719 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
3720 return true;
3721 } else if (us == SC_NEG) {
3722 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) > 0)
3723 return true;
3724 }
3725
3726 return false;
3727}
3728
3729
3730bool
3731operator < (const sc_signed &u, uint64 v)
3732{
3733 CONVERT_INT64(v);
3734
3735 if (u.sgn < vs)
3736 return true;
3737
3738 if (u.sgn > vs)
3739 return false;
3740
3741 // u.sgn == vs
3742
3743 if (vs == SC_POS) {
3744 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
3745 return true;
3746 }
3747
3748 return false;
3749}
3750
3751
3752bool
3753operator < (uint64 u, const sc_signed &v)
3754{
3755 CONVERT_INT64(u);
3756
3757 if (us < v.sgn)
3758 return true;
3759
3760 if (us > v.sgn)
3761 return false;
3762
3763 // us == v.sgn
3764
3765 if (us == SC_POS) {
3766 if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
3767 return true;
3768 }
3769
3770 return false;
3771}
3772
3773
3774bool
3775operator < (const sc_signed &u, long v)
3776{
3777 CONVERT_LONG(v);
3778
3779 if (u.sgn < vs)
3780 return true;
3781
3782 if (u.sgn > vs)
3783 return false;
3784
3785 // u.sgn == vs
3786
3787 if (vs == SC_POS) {
3788 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
3789 return true;
3790
3791 } else if (vs == SC_NEG) {
3792 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) > 0)
3793 return true;
3794 }
3795
3796 return false;
3797}
3798
3799
3800bool
3801operator < (long u, const sc_signed &v)
3802{
3803 CONVERT_LONG(u);
3804
3805 if (us < v.sgn)
3806 return true;
3807
3808 if (us > v.sgn)
3809 return false;
3810
3811 // us == v.sgn
3812
3813 if (us == SC_POS) {
3814 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
3815 return true;
3816 } else if (us == SC_NEG) {
3817 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) > 0)
3818 return true;
3819 }
3820
3821 return false;
3822}
3823
3824
3825bool
3826operator < (const sc_signed &u, unsigned long v)
3827{
3828 CONVERT_LONG(v);
3829
3830 if (u.sgn < vs)
3831 return true;
3832
3833 if (u.sgn > vs)
3834 return false;
3835
3836 // u.sgn == vs
3837
3838 if (vs == SC_POS) {
3839 if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
3840 return true;
3841 }
3842
3843 return false;
3844}
3845
3846
3847bool
3848operator < (unsigned long u, const sc_signed &v)
3849{
3850 CONVERT_LONG(u);
3851
3852 if (us < v.sgn)
3853 return true;
3854
3855 if (us > v.sgn)
3856 return false;
3857
3858 // us == v.sgn
3859
3860 if (us == SC_POS) {
3861 if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
3862 return true;
3863 }
3864
3865 return false;
3866}
3867
3868
3869// ---------------------------------------------------------------------------
3870// SECTION: LESS THAN or EQUAL operator: <=
3871// ---------------------------------------------------------------------------
3872
3873// Operators in this section are included from sc_nbcommon.cpp.
3874
3875
3876// ---------------------------------------------------------------------------
3877// SECTION: GREATER THAN operator: >
3878// ---------------------------------------------------------------------------
3879
3880// Operators in this section are included from sc_nbcommon.cpp.
3881
3882
3883// ---------------------------------------------------------------------------
3884// SECTION: GREATER THAN or EQUAL operator: >=
3885// ---------------------------------------------------------------------------
3886
3887// Operators in this section are included from sc_nbcommon.cpp.
3888
3889
3890// ---------------------------------------------------------------------------
3891// SECTION: Public members - Other utils.
3892// ---------------------------------------------------------------------------
3893
3894bool
3895sc_signed::iszero() const
3896{
3897 if (sgn == SC_ZERO)
3898 return true;
3899 else if (sgn != SC_NOSIGN)
3900 return false;
3901 else
3902 return check_for_zero(ndigits, digit);
3903}
3904
3905
3906bool
3907sc_signed::sign() const
3908{
3909 if (sgn == SC_NEG)
3910 return 1;
3911 else if (sgn != SC_NOSIGN)
3912 return 0;
3913 else
3914 return ((digit[ndigits - 1] & one_and_zeros(bit_ord(nbits - 1))) != 0);
3915}
3916
3917// The rest of the utils in this section are included from sc_nbcommon.cpp.
3918
3919
3920// ----------------------------------------------------------------------------
3921// SECTION: Private members.
3922// ----------------------------------------------------------------------------
3923
3924// The private members in this section are included from sc_nbcommon.cpp.
3925
3926#define CLASS_TYPE sc_signed
3927#define CLASS_TYPE_STR "sc_signed"
3928
3929#define ADD_HELPER add_signed_friend
3930#define SUB_HELPER sub_signed_friend
3931#define MUL_HELPER mul_signed_friend
3932#define DIV_HELPER div_signed_friend
3933#define MOD_HELPER mod_signed_friend
3934#define AND_HELPER and_signed_friend
3935#define OR_HELPER or_signed_friend
3936#define XOR_HELPER xor_signed_friend
3937
3938#include "sc_nbfriends.inc"
3939
3940#undef SC_UNSIGNED
3941#define SC_SIGNED
3942#define IF_SC_SIGNED 1 // 1 = sc_signed
3943#define CLASS_TYPE_SUBREF sc_signed_subref_r
3944#define OTHER_CLASS_TYPE sc_unsigned
3945#define OTHER_CLASS_TYPE_SUBREF sc_unsigned_subref_r
3946
3947#define MUL_ON_HELPER mul_on_help_signed
3948#define DIV_ON_HELPER div_on_help_signed
3949#define MOD_ON_HELPER mod_on_help_signed
3950
3951#include "sc_nbcommon.inc"
3952
3953#undef MOD_ON_HELPER
3954#undef DIV_ON_HELPER
3955#undef MUL_ON_HELPER
3956
3957#undef OTHER_CLASS_TYPE_SUBREF
3958#undef OTHER_CLASS_TYPE
3959#undef CLASS_TYPE_SUBREF
3960#undef IF_SC_SIGNED
3961#undef SC_SIGNED
3962
3963#undef XOR_HELPER
3964#undef OR_HELPER
3965#undef AND_HELPER
3966#undef MOD_HELPER
3967#undef DIV_HELPER
3968#undef MUL_HELPER
3969#undef SUB_HELPER
3970#undef ADD_HELPER
3971
3972#undef CLASS_TYPE
3973#undef CLASS_TYPE_STR
3974
3975#include "sc_signed_bitref.inc"
3976#include "sc_signed_subref.inc"
3977
3978#undef CONVERT_LONG
3979#undef CONVERT_LONG_2
3980#undef CONVERT_INT64
3981#undef CONVERT_INT64_2
3982
3983} // namespace sc_dt
|