sc_signed.cc revision 12854
12623SN/A/***************************************************************************** 22623SN/A 32623SN/A Licensed to Accellera Systems Initiative Inc. (Accellera) under one or 42623SN/A more contributor license agreements. See the NOTICE file distributed 52623SN/A with this work for additional information regarding copyright ownership. 62623SN/A Accellera licenses this file to you under the Apache License, Version 2.0 72623SN/A (the "License"); you may not use this file except in compliance with the 82623SN/A License. You may obtain a copy of the License at 92623SN/A 102623SN/A http://www.apache.org/licenses/LICENSE-2.0 112623SN/A 122623SN/A Unless required by applicable law or agreed to in writing, software 132623SN/A distributed under the License is distributed on an "AS IS" BASIS, 142623SN/A WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 152623SN/A implied. See the License for the specific language governing 162623SN/A permissions and limitations under the License. 172623SN/A 182623SN/A *****************************************************************************/ 192623SN/A 202623SN/A/***************************************************************************** 212623SN/A 222623SN/A sc_signed.cpp -- Arbitrary precision signed arithmetic. 232623SN/A 242623SN/A This file includes the definitions of sc_signed_bitref, 252623SN/A sc_signed_subref, and sc_signed classes. The first two 262623SN/A classes are proxy classes to reference one bit and a range 272665Ssaidi@eecs.umich.edu of bits of a sc_signed number, respectively. This file also 282665Ssaidi@eecs.umich.edu includes sc_nbcommon.cpp and sc_nbfriends.cpp, which 292623SN/A contain the definitions shared by sc_unsigned. 302623SN/A 313170Sstever@eecs.umich.edu Original Author: Ali Dasdan, Synopsys, Inc. 323806Ssaidi@eecs.umich.edu 332623SN/A *****************************************************************************/ 344040Ssaidi@eecs.umich.edu 352623SN/A/***************************************************************************** 362623SN/A 373348Sbinkertn@umich.edu MODIFICATION LOG - modifiers, enter your name, affiliation, date and 383348Sbinkertn@umich.edu changes you are making here. 392623SN/A 402901Ssaidi@eecs.umich.edu Name, Affiliation, Date: 412623SN/A Description of Modification: 422623SN/A 432623SN/A *****************************************************************************/ 442623SN/A 452623SN/A 462623SN/A// $Log: sc_signed.cpp,v $ 472623SN/A// Revision 1.6 2011/02/18 20:19:15 acg 482623SN/A// Andy Goodrich: updating Copyright notice. 492623SN/A// 502623SN/A// Revision 1.5 2008/12/10 20:38:45 acg 512623SN/A// Andy Goodrich: fixed conversion of double values to the digits vector. 522623SN/A// The bits above the radix were not being masked off. 532623SN/A// 542623SN/A// Revision 1.4 2008/06/19 17:47:56 acg 552623SN/A// Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES. 562623SN/A// 572623SN/A// Revision 1.3 2008/04/29 21:20:41 acg 582623SN/A// Andy Goodrich: added mask to first word transferred when processing 592623SN/A// a negative sc_signed value in sc_signed::concat_get_data(). 604873Sstever@eecs.umich.edu// 612623SN/A// Revision 1.2 2007/11/04 21:27:00 acg 622623SN/A// Andy Goodrich: changes to make sure the proper value is returned from 632856Srdreslin@umich.edu// concat_get_data(). 642856Srdreslin@umich.edu// 652856Srdreslin@umich.edu// Revision 1.1.1.1 2006/12/15 20:20:05 acg 662856Srdreslin@umich.edu// SystemC 2.3 672856Srdreslin@umich.edu// 682856Srdreslin@umich.edu// Revision 1.5 2006/10/23 19:32:47 acg 692856Srdreslin@umich.edu// Andy Goodrich: further fix for incorrect value being returned from 702856Srdreslin@umich.edu// concat_get_data. This one is in the non-aligned value code. 712856Srdreslin@umich.edu// 722856Srdreslin@umich.edu// Revision 1.3 2006/01/13 18:49:32 acg 732623SN/A// Added $Log command so that CVS check in comments are reproduced in the 742623SN/A// source. 752623SN/A// 762623SN/A 772623SN/A#include <cctype> 782623SN/A#include <cmath> 792680Sktlim@umich.edu#include <sstream> 802680Sktlim@umich.edu 812623SN/A#include "systemc/ext/dt/bit/sc_bv_base.hh" 822623SN/A#include "systemc/ext/dt/bit/sc_lv_base.hh" 832680Sktlim@umich.edu#include "systemc/ext/dt/fx/sc_fix.hh" 842623SN/A#include "systemc/ext/dt/fx/scfx_other_defs.hh" 852623SN/A#include "systemc/ext/dt/int/sc_int_base.hh" 862623SN/A#include "systemc/ext/dt/int/sc_signed.hh" 872623SN/A#include "systemc/ext/dt/int/sc_uint_base.hh" 882623SN/A#include "systemc/ext/dt/int/sc_unsigned.hh" 893349Sbinkertn@umich.edu#include "systemc/ext/dt/misc/sc_concatref.hh" 902623SN/A 913184Srdreslin@umich.edu// explicit template instantiations 922623SN/Anamespace sc_core 932623SN/A{ 942623SN/A 952623SN/Atemplate class sc_vpool<sc_dt::sc_signed_bitref>; 963349Sbinkertn@umich.edutemplate class sc_vpool<sc_dt::sc_signed_subref>; 972623SN/A 983310Srdreslin@umich.edu} // namespace sc_core 993649Srdreslin@umich.edu 1002623SN/Anamespace sc_dt 1012623SN/A{ 1022623SN/A 1033349Sbinkertn@umich.edu// Pool of temporary instances: 1042623SN/A 1053184Srdreslin@umich.edusc_core::sc_vpool<sc_signed_bitref> sc_signed_bitref::m_pool(9); 1063184Srdreslin@umich.edusc_core::sc_vpool<sc_signed_subref> sc_signed_subref::m_pool(9); 1072623SN/A 1082623SN/Avoid 1092623SN/Asc_signed::invalid_init(const char *type_name, int nb) const 1102623SN/A{ 1112623SN/A std::stringstream msg; 1123647Srdreslin@umich.edu msg << "sc_signed("<< type_name << ") : nb = " << nb << " is not valid"; 1133647Srdreslin@umich.edu SC_REPORT_ERROR("initialization failed", msg.str().c_str()); 1143647Srdreslin@umich.edu} 1153647Srdreslin@umich.edu 1163647Srdreslin@umich.edu// ---------------------------------------------------------------------------- 1172626SN/A// SECTION: Public members - Invalid selections. 1183647Srdreslin@umich.edu// ---------------------------------------------------------------------------- 1192626SN/A 1202623SN/Avoid 1212623SN/Asc_signed::invalid_index(int i) const 1222623SN/A{ 1232657Ssaidi@eecs.umich.edu std::stringstream msg; 1242623SN/A msg << "sc_bigint bit selection: index = " << i << " violates " 1252623SN/A "0 <= index <= " << (nbits - 1); 1262623SN/A SC_REPORT_ERROR("out of bounds", msg.str().c_str()); 1272623SN/A sc_core::sc_abort(); // can't recover from here 1282623SN/A} 1294192Sktlim@umich.edu 1304192Sktlim@umich.eduvoid 1314192Sktlim@umich.edusc_signed::invalid_range(int l, int r) const 1324192Sktlim@umich.edu{ 1334192Sktlim@umich.edu std::stringstream msg; 1344192Sktlim@umich.edu msg << "sc_bigint part selection: left = " << 1354192Sktlim@umich.edu l << ", right = " << r << "\n" 1364192Sktlim@umich.edu " violates either (" << (nbits-1) << " >= left >= 0) or " 1374192Sktlim@umich.edu "(" << (nbits-1) << " >= right >= 0)"; 1384192Sktlim@umich.edu SC_REPORT_ERROR("out of bounds", msg.str().c_str()); 1394192Sktlim@umich.edu sc_core::sc_abort(); // can't recover from here 1402623SN/A} 1412623SN/A 1422623SN/A 1432623SN/A// ---------------------------------------------------------------------------- 1442640Sstever@eecs.umich.edu 1452623SN/A// ---------------------------------------------------------------------------- 1462623SN/A// SECTION: Public members. 1472623SN/A// ---------------------------------------------------------------------------- 1483647Srdreslin@umich.edu 1493647Srdreslin@umich.edu// Most public members are included from sc_nbcommon.inc. However, some 1503647Srdreslin@umich.edu// concatenation support appears here to optimize between the signed and 1514870Sstever@eecs.umich.edu// unsigned cases. 1524870Sstever@eecs.umich.edu 1534870Sstever@eecs.umich.edu// Insert this object's value at the specified place in a vector of biguint 1542623SN/A// style values. 1552623SN/A 1562623SN/Abool 1572623SN/Asc_signed::concat_get_ctrl(sc_digit *dst_p, int low_i) const 1582623SN/A{ 1592623SN/A int dst_i; // Index to next word to set in dst_p. 1602623SN/A int end_i; // Index of high order word to set. 1612623SN/A int left_shift; // Amount to shift value left. 1622623SN/A sc_digit mask; // Mask for partial word sets. 1632623SN/A 1642915Sktlim@umich.edu // CALCULATE METRICS FOR DATA MOVEMENT: 1652915Sktlim@umich.edu dst_i = low_i / BITS_PER_DIGIT; 1663177Shsul@eecs.umich.edu end_i = (low_i + nbits - 1) / BITS_PER_DIGIT; 1673177Shsul@eecs.umich.edu left_shift = low_i % BITS_PER_DIGIT; 1683145Shsul@eecs.umich.edu 1692623SN/A // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 1702623SN/A mask = ~(~0U << left_shift); 1712623SN/A dst_p[dst_i] = (dst_p[dst_i] & ~mask); 1722623SN/A dst_i++; 1732623SN/A 1742623SN/A for (; dst_i <= end_i; dst_i++) 1752623SN/A dst_p[dst_i] = 0; 1762915Sktlim@umich.edu 1772915Sktlim@umich.edu return false; 1783177Shsul@eecs.umich.edu} 1793145Shsul@eecs.umich.edu 1802915Sktlim@umich.edubool 1812915Sktlim@umich.edusc_signed::concat_get_data(sc_digit *dst_p, int low_i) const 1822915Sktlim@umich.edu{ 1832915Sktlim@umich.edu sc_digit carry; // Carry bit for complements. 1842915Sktlim@umich.edu int dst_i; // Index to next word to set in dst_p. 1852915Sktlim@umich.edu int end_i; // Index of high order word to set. 1863324Shsul@eecs.umich.edu int high_i; // Index w/in word of high order bit. 1873201Shsul@eecs.umich.edu int left_shift; // Amount to shift value left. 1883324Shsul@eecs.umich.edu sc_digit left_word; // High word component for set. 1893324Shsul@eecs.umich.edu sc_digit mask; // Mask for partial word sets. 1903324Shsul@eecs.umich.edu bool result; // True if inserted non-zero data. 1913431Sgblack@eecs.umich.edu int right_shift; // Amount to shift value right. 1923495Sktlim@umich.edu sc_digit right_word; // Low word component for set. 1933431Sgblack@eecs.umich.edu int src_i; // Index to next word to get from digit. 1943324Shsul@eecs.umich.edu 1952915Sktlim@umich.edu // CALCULATE METRICS FOR DATA MOVEMENT: 1962623SN/A dst_i = low_i / BITS_PER_DIGIT; 1972623SN/A high_i = low_i + nbits - 1; 1982623SN/A end_i = high_i / BITS_PER_DIGIT; 1992798Sktlim@umich.edu left_shift = low_i % BITS_PER_DIGIT; 2002623SN/A 2012798Sktlim@umich.edu switch (sgn) { 2022798Sktlim@umich.edu // POSITIVE SOURCE VALUE: 2032623SN/A case SC_POS: 2042798Sktlim@umich.edu result = true; 2052623SN/A 2062623SN/A // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 2072623SN/A if (dst_i == end_i) { 2082623SN/A mask = ~(~0U << left_shift); 2092623SN/A dst_p[dst_i] = ((dst_p[dst_i] & mask) | 2102623SN/A (digit[0] << left_shift)) & DIGIT_MASK; 2114192Sktlim@umich.edu 2122623SN/A // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 2132623SN/A } else if (left_shift == 0) { 2142623SN/A for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 2152680Sktlim@umich.edu dst_p[dst_i] = digit[src_i]; 2162623SN/A } 2172680Sktlim@umich.edu high_i = high_i % BITS_PER_DIGIT; 2182680Sktlim@umich.edu mask = ~(~1U << high_i) & DIGIT_MASK; 2192680Sktlim@umich.edu dst_p[dst_i] = digit[src_i] & mask; 2202623SN/A 2213495Sktlim@umich.edu // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 2222623SN/A } else { 2232623SN/A high_i = high_i % BITS_PER_DIGIT; 2242623SN/A right_shift = BITS_PER_DIGIT - left_shift; 2253512Sktlim@umich.edu mask = ~(~0U << left_shift); 2263512Sktlim@umich.edu right_word = digit[0]; 2273512Sktlim@umich.edu dst_p[dst_i] = (dst_p[dst_i] & mask) | 2282623SN/A ((right_word << left_shift) & DIGIT_MASK); 2292623SN/A for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) { 2302623SN/A left_word = digit[src_i]; 2312623SN/A dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) | 2322623SN/A (right_word >> right_shift); 2332623SN/A right_word = left_word; 2342623SN/A } 2352683Sktlim@umich.edu left_word = (src_i < ndigits) ? digit[src_i] : 0; 2362623SN/A mask = ~(~1U << high_i) & DIGIT_MASK; 2372623SN/A dst_p[dst_i] = ((left_word << left_shift) | 2382623SN/A (right_word >> right_shift)) & mask; 2392623SN/A } 2402623SN/A break; 2413686Sktlim@umich.edu 2423430Sgblack@eecs.umich.edu // SOURCE VALUE IS NEGATIVE: 2433495Sktlim@umich.edu case SC_NEG: 2442623SN/A // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 2452623SN/A result = true; 2462623SN/A if (dst_i == end_i) { 2472623SN/A mask = ~(~0U << nbits); 2482623SN/A right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask; 2492623SN/A mask = ~(~0U << left_shift); 2502623SN/A dst_p[dst_i] = ((dst_p[dst_i] & mask) | 2512623SN/A (right_word << left_shift)) & DIGIT_MASK; 2522683Sktlim@umich.edu 2532623SN/A // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 2542623SN/A } else if (left_shift == 0) { 2552626SN/A carry = 1; 2562626SN/A for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 2572626SN/A right_word = (digit[src_i] ^ DIGIT_MASK) + carry; 2582626SN/A dst_p[dst_i] = right_word & DIGIT_MASK; 2592626SN/A carry = right_word >> BITS_PER_DIGIT; 2602623SN/A } 2612623SN/A high_i = high_i % BITS_PER_DIGIT; 2622623SN/A mask = (~(~1U << high_i)) & DIGIT_MASK; 2632623SN/A right_word = (src_i < ndigits) ? 2642623SN/A (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry; 2652623SN/A dst_p[dst_i] = right_word & mask; 2662623SN/A 2672623SN/A // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 2682623SN/A } else { 2692623SN/A high_i = high_i % BITS_PER_DIGIT; 2703169Sstever@eecs.umich.edu right_shift = BITS_PER_DIGIT - left_shift; 2714870Sstever@eecs.umich.edu mask = ~(~0U << left_shift); 2723169Sstever@eecs.umich.edu carry = 1; 2732623SN/A right_word = (digit[0] ^ DIGIT_MASK) + carry; 2742623SN/A dst_p[dst_i] = (dst_p[dst_i] & mask) | 2752623SN/A ((right_word << left_shift) & DIGIT_MASK); 2762623SN/A carry = right_word >> BITS_PER_DIGIT; 2772623SN/A right_word &= DIGIT_MASK; 2782623SN/A for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) { 2793169Sstever@eecs.umich.edu left_word = (digit[src_i] ^ DIGIT_MASK) + carry; 2802623SN/A dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) | 2812623SN/A (right_word >> right_shift); 2822623SN/A carry = left_word >> BITS_PER_DIGIT; 2834878Sstever@eecs.umich.edu right_word = left_word & DIGIT_MASK; 2844878Sstever@eecs.umich.edu } 2854878Sstever@eecs.umich.edu left_word = (src_i < ndigits) ? 2864878Sstever@eecs.umich.edu (digit[src_i] ^ DIGIT_MASK) + carry : carry; 2874870Sstever@eecs.umich.edu mask = ~(~1U << high_i) & DIGIT_MASK; 2882623SN/A dst_p[dst_i] = ((left_word << left_shift) | 2893806Ssaidi@eecs.umich.edu (right_word >> right_shift)) & mask; 2904870Sstever@eecs.umich.edu } 2913806Ssaidi@eecs.umich.edu break; 2924870Sstever@eecs.umich.edu 2932623SN/A // VALUE IS ZERO: 2944870Sstever@eecs.umich.edu default: 2953170Sstever@eecs.umich.edu result = false; 2963170Sstever@eecs.umich.edu // ALL DATA TO BE MOVED IS IN A SINGLE WORD: 2973170Sstever@eecs.umich.edu if (dst_i == end_i) { 2983170Sstever@eecs.umich.edu mask = ~(~0U << nbits) << left_shift; 2992623SN/A dst_p[dst_i] = dst_p[dst_i] & ~mask; 3002623SN/A 3012623SN/A // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED: 3023172Sstever@eecs.umich.edu } else if (left_shift == 0) { 3032623SN/A for (src_i = 0; dst_i < end_i; dst_i++, src_i++) { 3042623SN/A dst_p[dst_i] = 0; 3052623SN/A } 3062623SN/A dst_p[dst_i] = 0; 3072623SN/A 3082623SN/A // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED: 3092623SN/A } else { 3102623SN/A mask = ~(~0U << left_shift); 3112623SN/A dst_p[dst_i] = (dst_p[dst_i] & mask); 3124115Ssaidi@eecs.umich.edu for (dst_i++; dst_i <= end_i; dst_i++) { 3134115Ssaidi@eecs.umich.edu dst_p[dst_i] = 0; 3144115Ssaidi@eecs.umich.edu } 3154115Ssaidi@eecs.umich.edu } 3164040Ssaidi@eecs.umich.edu break; 3174040Ssaidi@eecs.umich.edu } 3184040Ssaidi@eecs.umich.edu return result; 3194040Ssaidi@eecs.umich.edu} 3202623SN/A 3212623SN/A// Return this object instance's bits as a uint64 without sign extension. 3222623SN/A 3232623SN/Auint64 3242623SN/Asc_signed::concat_get_uint64() const 3252623SN/A{ 3262623SN/A uint64 result; 3272623SN/A switch (sgn) { 3282623SN/A case SC_POS: 3292623SN/A result = 0; 3302623SN/A if (ndigits > 2) 3312623SN/A result = digit[2]; 3322623SN/A if (ndigits > 1) 3332623SN/A result = (result << BITS_PER_DIGIT) | digit[1]; 3342623SN/A result = (result << BITS_PER_DIGIT) | digit[0]; 3352623SN/A break; 3362623SN/A case SC_NEG: 3372623SN/A result = 0; 3382623SN/A if (ndigits > 2) 3392623SN/A result = digit[2]; 3402623SN/A if (ndigits > 1) 3412623SN/A result = (result << BITS_PER_DIGIT) | digit[1]; 3422623SN/A result = (result << BITS_PER_DIGIT) | digit[0]; 3432623SN/A result = -result; 3442623SN/A if (nbits < 64) { 3452623SN/A uint64 mask = ~0; 3462623SN/A result = result & ~(mask << nbits); 3472623SN/A } 3482623SN/A break; 3492623SN/A default: 3502623SN/A result = 0; 3512623SN/A break; 3522623SN/A } 3532623SN/A return result; 3542623SN/A} 3552623SN/A 3562623SN/A// #### OPTIMIZE 3572623SN/Avoid 3582623SN/Asc_signed::concat_set(int64 src, int low_i) 3592623SN/A{ 3602623SN/A *this = (low_i < 64) ? src >> low_i : src >> 63; 3612623SN/A} 3622623SN/A 3633169Sstever@eecs.umich.eduvoid 3644870Sstever@eecs.umich.edusc_signed::concat_set(const sc_signed &src, int low_i) 3653169Sstever@eecs.umich.edu{ 3662623SN/A if (low_i < src.length()) 3672623SN/A *this = src >> low_i; 3682623SN/A else 3692623SN/A *this = (src<0) ? (int_type)-1 : 0; 3702623SN/A} 3712623SN/A 3723169Sstever@eecs.umich.eduvoid 3732623SN/Asc_signed::concat_set(const sc_unsigned &src, int low_i) 3742623SN/A{ 3752623SN/A if (low_i < src.length()) 3764878Sstever@eecs.umich.edu *this = src >> low_i; 3773170Sstever@eecs.umich.edu else 3782623SN/A *this = 0; 3793170Sstever@eecs.umich.edu} 3804878Sstever@eecs.umich.edu 3813170Sstever@eecs.umich.eduvoid 3824878Sstever@eecs.umich.edusc_signed::concat_set(uint64 src, int low_i) 3834878Sstever@eecs.umich.edu{ 3844878Sstever@eecs.umich.edu *this = (low_i < 64) ? src >> low_i : 0; 3854878Sstever@eecs.umich.edu} 3864878Sstever@eecs.umich.edu 3874878Sstever@eecs.umich.edu// ---------------------------------------------------------------------------- 3884040Ssaidi@eecs.umich.edu// SECTION: Public members - Reduction methods. 3894040Ssaidi@eecs.umich.edu// ---------------------------------------------------------------------------- 3904878Sstever@eecs.umich.edu 3914878Sstever@eecs.umich.edubool 3924878Sstever@eecs.umich.edusc_signed::and_reduce() const 3932623SN/A{ 3943806Ssaidi@eecs.umich.edu sc_digit current; // Current digit examining. 3954870Sstever@eecs.umich.edu int i; // Index of digit examining. 3963806Ssaidi@eecs.umich.edu 3973806Ssaidi@eecs.umich.edu if (sgn == SC_NEG) { 3984870Sstever@eecs.umich.edu current = (1 << BITS_PER_DIGIT); 3993806Ssaidi@eecs.umich.edu for (i = 0; i < ndigits-1; i++) { 4003170Sstever@eecs.umich.edu current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK); 4014870Sstever@eecs.umich.edu if ((current & DIGIT_MASK) != DIGIT_MASK) return false; 4024878Sstever@eecs.umich.edu } 4034878Sstever@eecs.umich.edu current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK); 4044878Sstever@eecs.umich.edu if ((current & ~(~0U << (nbits % BITS_PER_DIGIT))) == 4054878Sstever@eecs.umich.edu static_cast<sc_digit>(~(~0U << (nbits % BITS_PER_DIGIT)))) { 4064878Sstever@eecs.umich.edu return true; 4073170Sstever@eecs.umich.edu } 4083170Sstever@eecs.umich.edu } 4094878Sstever@eecs.umich.edu return false; 4104052Ssaidi@eecs.umich.edu} 4112631SN/A 4122623SN/Abool 4132623SN/Asc_signed::or_reduce() const 4142623SN/A{ 4153172Sstever@eecs.umich.edu return sgn == SC_ZERO ? false : true; 4162623SN/A} 4172623SN/A 4182623SN/Abool 4192623SN/Asc_signed::xor_reduce() const 4202623SN/A{ 4212623SN/A int i; // Digit examining. 4222623SN/A int odd; // Flag for odd number of digits. 4232623SN/A 4242623SN/A odd = 0; 4254224Sgblack@eecs.umich.edu for (i = 0; i < nbits; i++) 4264224Sgblack@eecs.umich.edu if (test(i)) 4274224Sgblack@eecs.umich.edu odd = ~odd; 4284224Sgblack@eecs.umich.edu return odd ? true : false; 4294224Sgblack@eecs.umich.edu} 4304224Sgblack@eecs.umich.edu 4314224Sgblack@eecs.umich.edu 4324224Sgblack@eecs.umich.edu 4334224Sgblack@eecs.umich.edu// ---------------------------------------------------------------------------- 4344224Sgblack@eecs.umich.edu// SECTION: Public members - Assignment operators. 4354224Sgblack@eecs.umich.edu// ---------------------------------------------------------------------------- 4362623SN/A 4372623SN/A// assignment operators 4382623SN/A 4392623SN/Aconst sc_signed & 4402623SN/Asc_signed::operator = (const char *a) 4412623SN/A{ 4422623SN/A if (a == 0) { 4432623SN/A SC_REPORT_ERROR("conversion failed", 4442623SN/A "character string is zero"); 4452623SN/A } else if (*a == 0) { 4462623SN/A SC_REPORT_ERROR("conversion failed", 4472623SN/A "character string is empty"); 4482623SN/A } else try { 4492623SN/A int len = length(); 4502623SN/A sc_fix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 4512623SN/A return this->operator = (aa); 4522623SN/A } catch(const sc_core::sc_report &) { 4532623SN/A std::stringstream msg; 4542623SN/A msg << "character string '" << a << "' is not valid"; 4552623SN/A SC_REPORT_ERROR("conversion failed", msg.str().c_str()); 4562623SN/A } 4572623SN/A return *this; 4582623SN/A} 4592623SN/A 4602623SN/Aconst sc_signed & 4612623SN/Asc_signed::operator=(int64 v) 4622623SN/A{ 4632623SN/A sgn = get_sign(v); 4642623SN/A // v >= 0 now. 4652623SN/A if (sgn == SC_ZERO) { 4662623SN/A vec_zero(ndigits, digit); 4672623SN/A } else { 4682623SN/A from_uint(ndigits, digit, (uint64)v); 4692623SN/A if (nbits <= (int)BITS_PER_INT64) 4702623SN/A convert_SM_to_2C_to_SM(); 4712623SN/A } 4722623SN/A return *this; 4732623SN/A} 4742623SN/A 4752623SN/Aconst sc_signed & 4762623SN/Asc_signed::operator=(uint64 v) 4772623SN/A{ 4782623SN/A sgn = get_sign(v); 4792623SN/A if (sgn == SC_ZERO) { 4802623SN/A vec_zero(ndigits, digit); 4812623SN/A } else { 4822623SN/A from_uint(ndigits, digit, v); 4832623SN/A if (nbits <= (int)BITS_PER_INT64) 4842623SN/A convert_SM_to_2C_to_SM(); 4852623SN/A } 4862623SN/A return *this; 4872623SN/A} 4882623SN/A 4893387Sgblack@eecs.umich.educonst sc_signed & 4903387Sgblack@eecs.umich.edusc_signed::operator=(long v) 4912626SN/A{ 4924870Sstever@eecs.umich.edu sgn = get_sign(v); 4932623SN/A // v >= 0 now. 4942623SN/A if (sgn == SC_ZERO) { 4954182Sgblack@eecs.umich.edu vec_zero(ndigits, digit); 4964182Sgblack@eecs.umich.edu } else { 4974182Sgblack@eecs.umich.edu from_uint(ndigits, digit, (unsigned long)v); 4982662Sstever@eecs.umich.edu if (nbits <= (int)BITS_PER_LONG) 4994182Sgblack@eecs.umich.edu convert_SM_to_2C_to_SM(); 5004593Sgblack@eecs.umich.edu } 5014593Sgblack@eecs.umich.edu return *this; 5024182Sgblack@eecs.umich.edu} 5034870Sstever@eecs.umich.edu 5044870Sstever@eecs.umich.educonst sc_signed & 5054870Sstever@eecs.umich.edusc_signed::operator=(unsigned long v) 5062623SN/A{ 5074870Sstever@eecs.umich.edu sgn = get_sign(v); 5084182Sgblack@eecs.umich.edu if (sgn == SC_ZERO) { 5094182Sgblack@eecs.umich.edu vec_zero(ndigits, digit); 5104593Sgblack@eecs.umich.edu } else { 5114182Sgblack@eecs.umich.edu from_uint(ndigits, digit, v); 5122623SN/A if (nbits <= (int)BITS_PER_LONG) 5133814Ssaidi@eecs.umich.edu convert_SM_to_2C_to_SM(); 5144182Sgblack@eecs.umich.edu } 5154182Sgblack@eecs.umich.edu return *this; 5164182Sgblack@eecs.umich.edu} 5174182Sgblack@eecs.umich.edu 5184182Sgblack@eecs.umich.educonst sc_signed & 5192623SN/Asc_signed::operator=(double v) 5203814Ssaidi@eecs.umich.edu{ 5214539Sgblack@eecs.umich.edu is_bad_double(v); 5224539Sgblack@eecs.umich.edu if (v < 0) { 5233814Ssaidi@eecs.umich.edu v = -v; 5243814Ssaidi@eecs.umich.edu sgn = SC_NEG; 5252623SN/A } else { 5264182Sgblack@eecs.umich.edu sgn = SC_POS; 5274182Sgblack@eecs.umich.edu } 5282623SN/A 5292662Sstever@eecs.umich.edu int i = 0; 5302803Ssaidi@eecs.umich.edu while (std::floor(v) && (i < ndigits)) { 5312803Ssaidi@eecs.umich.edu digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) & 5322803Ssaidi@eecs.umich.edu DIGIT_MASK; 5332803Ssaidi@eecs.umich.edu v /= DIGIT_RADIX; 5342803Ssaidi@eecs.umich.edu } 5352623SN/A vec_zero(i, ndigits, digit); 5362623SN/A convert_SM_to_2C_to_SM(); 5372623SN/A return *this; 5384377Sgblack@eecs.umich.edu} 5394182Sgblack@eecs.umich.edu 5402623SN/A 5412623SN/A// ---------------------------------------------------------------------------- 5422626SN/A 5432626SN/Aconst sc_signed & 5442623SN/Asc_signed::operator = (const sc_bv_base &v) 5452623SN/A{ 5462623SN/A int minlen = sc_min(nbits, v.length()); 5472623SN/A int i = 0; 5482623SN/A for (; i < minlen; ++i) { 5492623SN/A safe_set(i, v.get_bit(i), digit); 5502623SN/A } 5512623SN/A for (; i < nbits; ++i) { 5522623SN/A safe_set(i, 0, digit); // zero-extend 5532623SN/A } 5542623SN/A convert_2C_to_SM(); 5552623SN/A return *this; 5562623SN/A} 5573119Sktlim@umich.edu 5582901Ssaidi@eecs.umich.educonst sc_signed & 5593170Sstever@eecs.umich.edusc_signed::operator = (const sc_lv_base &v) 5602623SN/A{ 5612623SN/A int minlen = sc_min(nbits, v.length()); 5623453Sgblack@eecs.umich.edu int i = 0; 5633453Sgblack@eecs.umich.edu for (; i < minlen; ++i) { 5642623SN/A safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit); 5653617Sbinkertn@umich.edu } 5663617Sbinkertn@umich.edu for (; i < nbits; ++i) { 5673617Sbinkertn@umich.edu safe_set(i, 0, digit); // zero-extend 5683617Sbinkertn@umich.edu } 5692623SN/A convert_2C_to_SM(); 5702623SN/A return *this; 5712623SN/A} 5722623SN/A 5732623SN/A 5743661Srdreslin@umich.edu// explicit conversion to character string 5752623SN/Aconst std::string 5762623SN/Asc_signed::to_string(sc_numrep numrep) const 5772623SN/A{ 5782623SN/A int len = length(); 5792623SN/A sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 5802623SN/A return aa.to_string(numrep); 5812623SN/A} 5822623SN/A 5832623SN/Aconst std::string 5842623SN/Asc_signed::to_string(sc_numrep numrep, bool w_prefix) const 5852623SN/A{ 5862623SN/A int len = length(); 5872623SN/A sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON); 5882623SN/A return aa.to_string(numrep, w_prefix); 5892623SN/A} 5902623SN/A 5912623SN/A 5922623SN/A// ---------------------------------------------------------------------------- 5932623SN/A// SECTION: Interfacing with sc_int_base 5943119Sktlim@umich.edu// ---------------------------------------------------------------------------- 5952901Ssaidi@eecs.umich.edu 5963170Sstever@eecs.umich.educonst sc_signed & 5972623SN/Asc_signed::operator = (const sc_int_base &v) 5982623SN/A{ 5992623SN/A return operator = ((int64)v); 6002623SN/A} 6012623SN/A 6023617Sbinkertn@umich.edu 6033617Sbinkertn@umich.edusc_signed 6043617Sbinkertn@umich.eduoperator + (const sc_unsigned &u, const sc_int_base &v) 6052623SN/A{ 6062623SN/A return operator + (u, static_cast<int64>(v)); 6072623SN/A} 6082623SN/A 6092623SN/Asc_signed 6103661Srdreslin@umich.eduoperator + (const sc_int_base &u, const sc_unsigned &v) 6112623SN/A{ 6122623SN/A return operator + (static_cast<int64>(u), v); 6132623SN/A} 6142623SN/A 6152623SN/Asc_signed 6162623SN/Aoperator + (const sc_signed &u, const sc_int_base &v) 6172623SN/A{ 6182623SN/A return operator + (u, (int64)v); 6192623SN/A} 6202623SN/A 6212623SN/Asc_signed 6222623SN/Aoperator + (const sc_int_base &u, const sc_signed &v) 6232623SN/A{ 6242623SN/A return operator + ((int64)u, v); 6252623SN/A} 6262623SN/A 6272623SN/Aconst sc_signed & 6282623SN/Asc_signed::operator += (const sc_int_base &v) 6293119Sktlim@umich.edu{ 6302623SN/A return operator += ((int64)v); 6313661Srdreslin@umich.edu} 6322623SN/A 6332623SN/A 6342623SN/Asc_signed 6352623SN/Aoperator - (const sc_unsigned &u, const sc_int_base &v) 6362623SN/A{ 6372901Ssaidi@eecs.umich.edu return operator - (u, (int64)v); 6383170Sstever@eecs.umich.edu} 6392623SN/A 6402623SN/Asc_signed 6412623SN/Aoperator - (const sc_int_base &u, const sc_unsigned &v) 6422623SN/A{ 6432623SN/A return operator - ((int64)u, v); 6443617Sbinkertn@umich.edu} 6453617Sbinkertn@umich.edu 6463617Sbinkertn@umich.edusc_signed 6472623SN/Aoperator - (const sc_signed &u, const sc_int_base &v) 6482623SN/A{ 6492623SN/A return operator - (u, (int64)v); 6502623SN/A} 6512623SN/A 6522623SN/Asc_signed 6532623SN/Aoperator - (const sc_int_base &u, const sc_signed &v) 6542623SN/A{ 6552623SN/A return operator - ((int64)u, v); 6562623SN/A} 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 3983