SystemC 3.0.0
Accellera SystemC proof-of-concept library
sc_bigint_inlines.h
Go to the documentation of this file.
1/*****************************************************************************
2
3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4 more contributor license agreements. See the NOTICE file distributed
5 with this work for additional information regarding copyright ownership.
6 Accellera licenses this file to you under the Apache License, Version 2.0
7 (the "License"); you may not use this file except in compliance with the
8 License. You may obtain a copy of the License at
9
10 http://www.apache.org/licenses/LICENSE-2.0
11
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15 implied. See the License for the specific language governing
16 permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22 sc_bigint<W>_inlines.h -- sc_bigint<W> inline implementations.
23
24 This file contains inline implementations that require the other "int"
25 headers to have been included before its contents can be resolved.
26
27 Original Author: Andy Goodrich, Cadence Design Systems
28
29 *****************************************************************************/
30
31#ifndef SC_BIGINT_INLINES_H
32#define SC_BIGINT_INLINES_H
33
34namespace sc_dt {
35
36// +----------------------------------------------------------------------------
37// |"sc_bigint<W>::operator ="
38// |
39// | These are the assignment operators for the sc_bigint<W> class.
40// |
41// | Arguments:
42// | from = value to be assigned this object instance.
43// | Result:
44// | Constant reference to this object instance.
45// +----------------------------------------------------------------------------
46template<int W>
47inline const sc_bigint<W>&
48sc_bigint<W>::operator = (const sc_bigint<W>& from)
49{
50 vector_copy( DIGITS_N, from.get_digits(), get_digits() );
51 return *this;
52}
53
54template<int W>
55template<int WO>
56inline const sc_bigint<W>&
57sc_bigint<W>::operator = (const sc_bigint<WO>& from)
58{
59 vector_copy( sc_bigint<WO>::DIGITS_N, from.get_digits(), DIGITS_N, get_digits() );
60 adjust_hod();
61 return *this;
62}
63
64template<int W>
65template<int WO>
66inline const sc_bigint<W>&
67sc_bigint<W>::operator = (const sc_biguint<WO>& from)
68{
69 sc_digit* to_p = get_digits();
70 vector_copy( sc_biguint<WO>::DIGITS_N, from.get_digits(), DIGITS_N, to_p );
71 adjust_hod();
72 return *this;
73}
74
75template<int W>
76inline const sc_bigint<W>&
77sc_bigint<W>::operator = (const sc_unsigned& from)
78{
79 sc_digit* to_p = get_digits();
80 vector_copy( from.get_digits_n(), from.get_digits(), DIGITS_N, to_p );
81 adjust_hod();
82 return *this;
83}
84
85template<int W>
86inline
87const sc_bigint<W>&
88sc_bigint<W>::operator=(const sc_unsigned_subref_r& v)
89{
90 operator=(sc_unsigned(v));
91 return * this;
92}
93
94template<int W>
95inline const sc_bigint<W>&
96sc_bigint<W>::operator = (const sc_signed& from)
97{
98 sc_digit* to_p = get_digits();
99 vector_copy( from.get_digits_n(), from.get_digits(), DIGITS_N, to_p );
100 adjust_hod();
101 return *this;
102}
103
104
105template<int W>
106inline const sc_bigint<W>&
107sc_bigint<W>::operator = ( int64 from )
108{
109 sc_digit* to_p = get_digits();
110 *to_p++ = (sc_digit)from;
111 if ( HOD > 0 ) {
112 *to_p++ = from >> 32;
113 }
114 if ( HOD > 1 ) {
115 vector_fill( from < 0 ? -1 : 0, HOD-2, to_p );
116 }
117 adjust_hod();
118 return *this;
119}
120
121template<int W>
122inline const sc_bigint<W>&
123sc_bigint<W>::operator = ( long from )
124{
125 sc_digit* to_p = get_digits();
126 *to_p++ = from;
127 if ( sizeof(from) > 4 ) {
128 if ( HOD > 0 ) {
129 *to_p++ = (int64)from >> 32;
130 }
131 if ( HOD > 1 ) {
132 vector_fill( from < 0 ? -1 : 0, HOD-2, to_p );
133 }
134 }
135 else if ( HOD > 0 ) {
136 vector_fill( from < 0 ? -1 : 0, HOD-1, to_p );
137 }
138 adjust_hod();
139 return *this;
140}
141
142template<int W>
143inline const sc_bigint<W>&
144sc_bigint<W>::operator = ( int from )
145{
146 sc_digit* to_p = get_digits();
147 *to_p++ = (sc_digit)from;
148 if ( HOD > 0 ) {
149 vector_fill( from < 0 ? -1 : 0, HOD-1, to_p );
150 }
151 adjust_hod();
152 return *this;
153}
154
155template<int W>
156inline const sc_bigint<W>&
157sc_bigint<W>::operator = ( uint64 from )
158{
159 sc_digit* to_p = get_digits();
160 *to_p++ = (sc_digit)from;
161 if ( HOD > 0 ) {
162 *to_p++ = from >> 32;
163 }
164 if ( HOD > 1 ) {
165 vector_fill( 0, HOD - 2, to_p );
166 }
167 adjust_hod();
168 return *this;
169}
170
171template<int W>
172inline const sc_bigint<W>&
173sc_bigint<W>::operator = ( unsigned long from )
174{
175 sc_digit* to_p = get_digits();
176 *to_p++ = from;
177 if ( sizeof(from) > 4 ) {
178 if ( HOD > 0 ) {
179 *to_p++ = (int64)from >> 32;
180 }
181 if ( HOD > 1 ) {
182 vector_fill( 0, HOD-2, to_p );
183 }
184 }
185 else if ( HOD > 1 ) {
186 vector_fill( 0, HOD-1, to_p );
187 }
188 adjust_hod();
189 return *this;
190}
191
192template<int W>
193inline const sc_bigint<W>&
194sc_bigint<W>::operator = ( unsigned int from )
195{
196 sc_digit* to_p = get_digits();
197 *to_p++ = from;
198 if ( HOD > 0 ) {
199 vector_fill( 0, HOD-1, to_p );
200 }
201 adjust_hod();
202 return *this;
203}
204
205template<int W>
206inline const sc_bigint<W>&
207sc_bigint<W>::operator = ( const sc_int_base& from )
208{
209 return *this = (int64)from;
210}
211
212template<int W>
213inline const sc_bigint<W>&
214sc_bigint<W>::operator = ( const sc_uint_base& from )
215{
216 return *this = (uint64)from;
217}
218
219// Unary operators:
220
221template<int W>
222inline const sc_bigint<W>
223sc_bigint<W>::operator - ()
224{
225 sc_carry carry=1;
226 sc_bigint<W> result;
227 sc_digit* result_digits = result.get_digits();
228 for ( int digit_i = 0; digit_i <= HOD; ++digit_i ) {
229 carry += ~digit[digit_i];
230 result_digits[digit_i] = (sc_digit)carry;
231 carry >>=BITS_PER_DIGIT;
232 }
233 return result;
234}
235
236template<int W>
237inline const sc_bigint<W>
238sc_bigint<W>::operator ~ ()
239{
240 sc_bigint<W> result;
241 sc_digit* result_digits = result.get_digits();
242 for ( int digit_i = 0; digit_i <= HOD; ++digit_i ) {
243 result_digits[digit_i] = ~digit[digit_i];
244 }
245 return result;
246}
247
248 // SELF-REFERENCING OPERATORS:
249
250 template<int W>
251 inline sc_bigint<W>& sc_bigint<W>::operator += (const sc_signed& v) { sc_signed_proxy()+= v; return *this; }
252 template<int W>
253 inline sc_bigint<W>& sc_bigint<W>::operator += (const sc_unsigned& v) { sc_signed_proxy()+= v; return *this; }
254 template<int W>
255 inline sc_bigint<W>& sc_bigint<W>::operator += (int64 v) { sc_signed_proxy()+= v; return *this; }
256 template<int W>
257 inline sc_bigint<W>& sc_bigint<W>::operator += (uint64 v) { sc_signed_proxy()+= v; return *this; }
258 template<int W>
259 inline sc_bigint<W>& sc_bigint<W>::operator += (long v) { sc_signed_proxy()+= v; return *this; }
260 template<int W>
261 inline sc_bigint<W>& sc_bigint<W>::operator += (unsigned long v) { sc_signed_proxy()+= v; return *this; }
262 template<int W>
263 inline sc_bigint<W>& sc_bigint<W>::operator += (int v) { sc_signed_proxy()+= v; return *this; }
264 template<int W>
265 inline sc_bigint<W>& sc_bigint<W>::operator += (unsigned int v) { sc_signed_proxy()+= v; return *this; }
266 template<int W>
267 inline sc_bigint<W>& sc_bigint<W>::operator += (const sc_int_base& v) { sc_signed_proxy()+= v; return *this; }
268 template<int W>
269 inline sc_bigint<W>& sc_bigint<W>::operator += (const sc_uint_base& v) { sc_signed_proxy()+= v; return *this; }
270
271 template<int W>
272 inline sc_bigint<W>& sc_bigint<W>::operator -= (const sc_signed& v) { sc_signed_proxy()-= v; return *this; }
273 template<int W>
274 inline sc_bigint<W>& sc_bigint<W>::operator -= (const sc_unsigned& v) { sc_signed_proxy()-= v; return *this; }
275 template<int W>
276 inline sc_bigint<W>& sc_bigint<W>::operator -= (int64 v) { sc_signed_proxy()-= v; return *this; }
277 template<int W>
278 inline sc_bigint<W>& sc_bigint<W>::operator -= (uint64 v) { sc_signed_proxy()-= v; return *this; }
279 template<int W>
280 inline sc_bigint<W>& sc_bigint<W>::operator -= (long v) { sc_signed_proxy()-= v; return *this; }
281 template<int W>
282 inline sc_bigint<W>& sc_bigint<W>::operator -= (unsigned long v) { sc_signed_proxy()-= v; return *this; }
283 template<int W>
284 inline sc_bigint<W>& sc_bigint<W>::operator -= (int v) { sc_signed_proxy()-= v; return *this; }
285 template<int W>
286 inline sc_bigint<W>& sc_bigint<W>::operator -= (unsigned int v) { sc_signed_proxy()-= v; return *this; }
287 template<int W>
288 inline sc_bigint<W>& sc_bigint<W>::operator -= (const sc_int_base& v) { sc_signed_proxy()-= v; return *this; }
289 template<int W>
290 inline sc_bigint<W>& sc_bigint<W>::operator -= (const sc_uint_base& v) { sc_signed_proxy()-= v; return *this; }
291
292 template<int W>
293 inline sc_bigint<W>& sc_bigint<W>::operator *= (const sc_signed& v) { sc_signed_proxy()*= v; return *this; }
294 template<int W>
295 inline sc_bigint<W>& sc_bigint<W>::operator *= (const sc_unsigned& v) { sc_signed_proxy()*= v; return *this; }
296 template<int W>
297 inline sc_bigint<W>& sc_bigint<W>::operator *= (int64 v) { sc_signed_proxy()*= v; return *this; }
298 template<int W>
299 inline sc_bigint<W>& sc_bigint<W>::operator *= (uint64 v) { sc_signed_proxy()*= v; return *this; }
300 template<int W>
301 inline sc_bigint<W>& sc_bigint<W>::operator *= (long v) { sc_signed_proxy()*= v; return *this; }
302 template<int W>
303 inline sc_bigint<W>& sc_bigint<W>::operator *= (unsigned long v) { sc_signed_proxy()*= v; return *this; }
304 template<int W>
305 inline sc_bigint<W>& sc_bigint<W>::operator *= (int v) { sc_signed_proxy()*= v; return *this; }
306 template<int W>
307 inline sc_bigint<W>& sc_bigint<W>::operator *= (unsigned int v) { sc_signed_proxy()*= v; return *this; }
308 template<int W>
309 inline sc_bigint<W>& sc_bigint<W>::operator *= (const sc_int_base& v) { sc_signed_proxy()*= v; return *this; }
310 template<int W>
311 inline sc_bigint<W>& sc_bigint<W>::operator *= (const sc_uint_base& v) { sc_signed_proxy()*= v; return *this; }
312
313 template<int W>
314 inline sc_bigint<W>& sc_bigint<W>::operator /= (const sc_signed& v) { sc_signed_proxy()/= v; return *this; }
315 template<int W>
316 inline sc_bigint<W>& sc_bigint<W>::operator /= (const sc_unsigned& v) { sc_signed_proxy()/= v; return *this; }
317 template<int W>
318 inline sc_bigint<W>& sc_bigint<W>::operator /= (int64 v) { sc_signed_proxy()/= v; return *this; }
319 template<int W>
320 inline sc_bigint<W>& sc_bigint<W>::operator /= (uint64 v) { sc_signed_proxy()/= v; return *this; }
321 template<int W>
322 inline sc_bigint<W>& sc_bigint<W>::operator /= (long v) { sc_signed_proxy()/= v; return *this; }
323 template<int W>
324 inline sc_bigint<W>& sc_bigint<W>::operator /= (unsigned long v) { sc_signed_proxy()/= v; return *this; }
325 template<int W>
326 inline sc_bigint<W>& sc_bigint<W>::operator /= (int v) { sc_signed_proxy()/= v; return *this; }
327 template<int W>
328 inline sc_bigint<W>& sc_bigint<W>::operator /= (unsigned int v) { sc_signed_proxy()/= v; return *this; }
329 template<int W>
330 inline sc_bigint<W>& sc_bigint<W>::operator /= (const sc_int_base& v) { sc_signed_proxy()/= v; return *this; }
331 template<int W>
332 inline sc_bigint<W>& sc_bigint<W>::operator /= (const sc_uint_base& v) { sc_signed_proxy()/= v; return *this; }
333
334 template<int W>
335 inline sc_bigint<W>& sc_bigint<W>::operator %= (const sc_signed& v) { sc_signed_proxy()%= v; return *this; }
336 template<int W>
337 inline sc_bigint<W>& sc_bigint<W>::operator %= (const sc_unsigned& v) { sc_signed_proxy()%= v; return *this; }
338 template<int W>
339 inline sc_bigint<W>& sc_bigint<W>::operator %= (int64 v) { sc_signed_proxy()%= v; return *this; }
340 template<int W>
341 inline sc_bigint<W>& sc_bigint<W>::operator %= (uint64 v) { sc_signed_proxy()%= v; return *this; }
342 template<int W>
343 inline sc_bigint<W>& sc_bigint<W>::operator %= (long v) { sc_signed_proxy()%= v; return *this; }
344 template<int W>
345 inline sc_bigint<W>& sc_bigint<W>::operator %= (unsigned long v) { sc_signed_proxy()%= v; return *this; }
346 template<int W>
347 inline sc_bigint<W>& sc_bigint<W>::operator %= (int v) { sc_signed_proxy()%= v; return *this; }
348 template<int W>
349 inline sc_bigint<W>& sc_bigint<W>::operator %= (unsigned int v) { sc_signed_proxy()%= v; return *this; }
350 template<int W>
351 inline sc_bigint<W>& sc_bigint<W>::operator %= (const sc_int_base& v) { sc_signed_proxy()%= v; return *this; }
352 template<int W>
353 inline sc_bigint<W>& sc_bigint<W>::operator %= (const sc_uint_base& v) { sc_signed_proxy()%= v; return *this; }
354
355 template<int W>
356 inline sc_bigint<W>& sc_bigint<W>::operator &= (const sc_signed& v) { sc_signed_proxy()&= v; return *this; }
357 template<int W>
358 inline sc_bigint<W>& sc_bigint<W>::operator &= (const sc_unsigned& v) { sc_signed_proxy()&= v; return *this; }
359 template<int W>
360 inline sc_bigint<W>& sc_bigint<W>::operator &= (int64 v) { sc_signed_proxy()&= v; return *this; }
361 template<int W>
362 inline sc_bigint<W>& sc_bigint<W>::operator &= (uint64 v) { sc_signed_proxy()&= v; return *this; }
363 template<int W>
364 inline sc_bigint<W>& sc_bigint<W>::operator &= (long v) { sc_signed_proxy()&= v; return *this; }
365 template<int W>
366 inline sc_bigint<W>& sc_bigint<W>::operator &= (unsigned long v) { sc_signed_proxy()&= v; return *this; }
367 template<int W>
368 inline sc_bigint<W>& sc_bigint<W>::operator &= (int v) { sc_signed_proxy()&= v; return *this; }
369 template<int W>
370 inline sc_bigint<W>& sc_bigint<W>::operator &= (unsigned int v) { sc_signed_proxy()&= v; return *this; }
371 template<int W>
372 inline sc_bigint<W>& sc_bigint<W>::operator &= (const sc_int_base& v) { sc_signed_proxy()&= v; return *this; }
373 template<int W>
374 inline sc_bigint<W>& sc_bigint<W>::operator &= (const sc_uint_base& v) { sc_signed_proxy()&= v; return *this; }
375
376 template<int W>
377 inline sc_bigint<W>& sc_bigint<W>::operator |= (const sc_signed& v) { sc_signed_proxy()|= v; return *this; }
378 template<int W>
379 inline sc_bigint<W>& sc_bigint<W>::operator |= (const sc_unsigned& v) { sc_signed_proxy()|= v; return *this; }
380 template<int W>
381 inline sc_bigint<W>& sc_bigint<W>::operator |= (int64 v) { sc_signed_proxy()|= v; return *this; }
382 template<int W>
383 inline sc_bigint<W>& sc_bigint<W>::operator |= (uint64 v) { sc_signed_proxy()|= v; return *this; }
384 template<int W>
385 inline sc_bigint<W>& sc_bigint<W>::operator |= (long v) { sc_signed_proxy()|= v; return *this; }
386 template<int W>
387 inline sc_bigint<W>& sc_bigint<W>::operator |= (unsigned long v) { sc_signed_proxy()|= v; return *this; }
388 template<int W>
389 inline sc_bigint<W>& sc_bigint<W>::operator |= (int v) { sc_signed_proxy()|= v; return *this; }
390 template<int W>
391 inline sc_bigint<W>& sc_bigint<W>::operator |= (unsigned int v) { sc_signed_proxy()|= v; return *this; }
392 template<int W>
393 inline sc_bigint<W>& sc_bigint<W>::operator |= (const sc_int_base& v) { sc_signed_proxy()|= v; return *this; }
394 template<int W>
395 inline sc_bigint<W>& sc_bigint<W>::operator |= (const sc_uint_base& v) { sc_signed_proxy()|= v; return *this; }
396
397 template<int W>
398 inline sc_bigint<W>& sc_bigint<W>::operator ^= (const sc_signed& v) { sc_signed_proxy()^= v; return *this; }
399 template<int W>
400 inline sc_bigint<W>& sc_bigint<W>::operator ^= (const sc_unsigned& v) { sc_signed_proxy()^= v; return *this; }
401 template<int W>
402 inline sc_bigint<W>& sc_bigint<W>::operator ^= (int64 v) { sc_signed_proxy()^= v; return *this; }
403 template<int W>
404 inline sc_bigint<W>& sc_bigint<W>::operator ^= (uint64 v) { sc_signed_proxy()^= v; return *this; }
405 template<int W>
406 inline sc_bigint<W>& sc_bigint<W>::operator ^= (long v) { sc_signed_proxy()^= v; return *this; }
407 template<int W>
408 inline sc_bigint<W>& sc_bigint<W>::operator ^= (unsigned long v) { sc_signed_proxy()^= v; return *this; }
409 template<int W>
410 inline sc_bigint<W>& sc_bigint<W>::operator ^= (int v) { sc_signed_proxy()^= v; return *this; }
411 template<int W>
412 inline sc_bigint<W>& sc_bigint<W>::operator ^= (unsigned int v) { sc_signed_proxy()^= v; return *this; }
413 template<int W>
414 inline sc_bigint<W>& sc_bigint<W>::operator ^= (const sc_int_base& v) { sc_signed_proxy()^= v; return *this; }
415 template<int W>
416 inline sc_bigint<W>& sc_bigint<W>::operator ^= (const sc_uint_base& v) { sc_signed_proxy()^= v; return *this; }
417
418// reduce methods
419
420template<int W>
421inline bool sc_bigint<W>::and_reduce() const { return vector_and_reduce(W,digit); }
422template<int W>
423inline bool sc_bigint<W>::nand_reduce() const { return !vector_and_reduce(W,digit); }
424template<int W>
425inline bool sc_bigint<W>::or_reduce() const { return vector_or_reduce(W,digit); }
426template<int W>
427inline bool sc_bigint<W>::nor_reduce() const { return !vector_or_reduce(W,digit); }
428template<int W>
429inline bool sc_bigint<W>::xor_reduce() const { return vector_xor_reduce(W,digit); }
430template<int W>
431inline bool sc_bigint<W>::xnor_reduce() const { return !vector_xor_reduce(W,digit); }
432
433// left shift methods:
434
435template<int W>
436const sc_signed
437sc_bigint<W>::operator<<(int v) const
438{
439 if (v <= 0)
440 return sc_signed(*this);
441
442 int nb = W + v;
443 int nd = DIV_CEIL(nb);
444 sc_signed result(nb, false);
445
446 vector_shift_left( DIV_CEIL(W), digit, nd, result.digit, v );
447 result.adjust_hod();
448
449 return result;
450}
451
452template<int W>
453const sc_bigint<W>&
454sc_bigint<W>::operator<<=(int v)
455{
456 if (v <= 0)
457 return *this;
458
459 vector_shift_left( DIV_CEIL(W+1), digit, v );
460 adjust_hod();
461
462 return *this;
463}
464
465
466template<int W>
467const sc_bigint<W>&
468sc_bigint<W>::operator>>=(int v)
469{
470
471 if (v <= 0)
472 return *this;
473
474 int nd = DIV_CEIL(W);
475
476 vector_shift_right(nd, digit, v, (int)digit[nd-1]<0 ? DIGIT_MASK:0);
477
478 return *this;
479}
480
481// right shift methods:
482
483template<int W>
484const sc_signed
485sc_bigint<W>::operator>>(int v) const
486{
487 if (v <= 0) {
488 return sc_signed(*this);
489 }
490 int nb = W - v;
491
492 // If we shift off the end return the sign bit.
493
494 if ( 0 >= nb ) {
495 sc_signed result(1, false);
496 result.digit[0] = 0 > (int)digit[HOD] ? -1 : 0;
497 return result;
498 }
499
500 // Return a value that is the width of the shifted value:
501
502 sc_signed result(nb, false);
503 if ( W < 33 ) {
504 result.digit[0] = (int)digit[0] >> v;
505 }
506 else if ( W < 65 ) {
507 int64 tmp = digit[DIV_CEIL(W)-1];
508 tmp = (tmp << 32) | digit[0];
509 tmp = tmp >> v;
510 result.digit[0] = tmp;
511 if ( nb > 32 ) {
512 result.digit[1] = (tmp >>32);
513 }
514 }
515 else {
516 vector_extract(digit, result.digit, W-1, v);
517 }
518 result.adjust_hod();
519 return result;
520}
521
522// sc_bv<W> and sc_lv<W> constructors using an sc_bigint<WO> value:
523
524template<int W>
525template<int WO>
526sc_bv<W>::sc_bv( const sc_bigint<WO>& v )
527 : sc_bv_base(W)
528{
529 *this = v.sc_signed_proxy();
530}
531
532template<int W>
533template<int WO>
534sc_lv<W>::sc_lv( const sc_bigint<WO>& v )
535 : sc_lv_base(W)
536{
537 *this = v.sc_signed_proxy();
538}
539
540} // namespace sc_dt
541
542#endif // SC_BIGINT_INLINES_H
DIGIT_MASK
#define DIGIT_MASK
Definition: sc_nbdefs.h:168
DIV_CEIL
#define DIV_CEIL(x)
Definition: sc_nbdefs.h:212
BITS_PER_DIGIT
#define BITS_PER_DIGIT
Definition: sc_nbdefs.h:164
sc_dt::vector_fill
void vector_fill(const sc_digit fill, const int to_hod, sc_digit *to_p)
Definition: sc_vector_utils.h:927
sc_dt::vector_and_reduce
bool vector_and_reduce(const int bits_n, const sc_digit *target_p)
Definition: sc_vector_utils.h:580
sc_dt::uint64
unsigned long long uint64
Definition: sc_nbdefs.h:216
sc_dt::vector_extract
void vector_extract(const sc_digit *source_p, sc_digit *destination_p, const int high_bit, const int low_bit)
Definition: sc_vector_utils.h:859
sc_dt::vector_copy
void vector_copy(const int from_n, const sc_digit *from_p, const int to_n, sc_digit *to_p)
Definition: sc_vector_utils.h:799
sc_dt::vector_xor_reduce
bool vector_xor_reduce(const int bits_n, const sc_digit *target_p)
Definition: sc_vector_utils.h:2587
sc_dt::vector_or_reduce
bool vector_or_reduce(const int bits_n, const sc_digit *target_p)
Definition: sc_vector_utils.h:1576
sc_dt::sc_digit
unsigned int sc_digit
Definition: sc_nbdefs.h:161
sc_dt::vector_shift_left
void vector_shift_left(const int from_digits_n, const sc_digit *from_p, const int to_digits_n, sc_digit *to_p, const int shift_n)
Definition: sc_vector_utils.h:1684
sc_dt::vector_shift_right
void vector_shift_right(const int target_n, sc_digit *target_p, int bits_n, const sc_digit fill)
Definition: sc_vector_utils.h:1868
sc_dt::sc_carry
uint64 sc_carry
Definition: sc_nbdefs.h:225
sc_dt::int64
long long int64
Definition: sc_nbdefs.h:215
sc_dt::sc_bigint::operator>>=
const sc_bigint< W > & operator>>=(int v)
Definition: sc_bigint_inlines.h:468
sc_dt::sc_bigint::operator>>
const sc_signed operator>>(int v) const
Definition: sc_bigint_inlines.h:485
sc_dt::sc_bigint::or_reduce
bool or_reduce() const
Definition: sc_bigint_inlines.h:425
sc_dt::sc_bigint::operator*=
sc_bigint< W > & operator*=(const sc_signed &v)
Definition: sc_bigint_inlines.h:293
sc_dt::sc_bigint::nor_reduce
bool nor_reduce() const
Definition: sc_bigint_inlines.h:427
sc_dt::sc_bigint::operator|=
sc_bigint< W > & operator|=(const sc_signed &v)
Definition: sc_bigint_inlines.h:377
sc_dt::sc_bigint::get_digits
const sc_digit * get_digits() const
Definition: sc_bigint.h:706
sc_dt::sc_bigint::xnor_reduce
bool xnor_reduce() const
Definition: sc_bigint_inlines.h:431
sc_dt::sc_bigint::nand_reduce
bool nand_reduce() const
Definition: sc_bigint_inlines.h:423
sc_dt::sc_bigint::operator+=
sc_bigint< W > & operator+=(const sc_signed &v)
Definition: sc_bigint_inlines.h:251
sc_dt::sc_bigint::operator-
const sc_bigint< W > operator-()
Definition: sc_bigint_inlines.h:223
sc_dt::sc_bigint::xor_reduce
bool xor_reduce() const
Definition: sc_bigint_inlines.h:429
sc_dt::sc_bigint::and_reduce
bool and_reduce() const
Definition: sc_bigint_inlines.h:421
sc_dt::sc_bigint::operator<<=
const sc_bigint< W > & operator<<=(int v)
Definition: sc_bigint_inlines.h:454
sc_dt::sc_bigint::operator%=
sc_bigint< W > & operator%=(const sc_signed &v)
Definition: sc_bigint_inlines.h:335
sc_dt::sc_bigint::operator~
const sc_bigint< W > operator~()
Definition: sc_bigint_inlines.h:238
sc_dt::sc_bigint::operator/=
sc_bigint< W > & operator/=(const sc_signed &v)
Definition: sc_bigint_inlines.h:314
sc_dt::sc_bigint::sc_signed_proxy
sc_signed & sc_signed_proxy()
Definition: sc_bigint.h:676
sc_dt::sc_bigint::operator=
const sc_bigint< W > & operator=(const sc_bigint< W > &other)
Definition: sc_bigint_inlines.h:48
sc_dt::sc_bigint::operator&=
sc_bigint< W > & operator&=(const sc_signed &v)
Definition: sc_bigint_inlines.h:356
sc_dt::sc_bigint::operator-=
sc_bigint< W > & operator-=(const sc_signed &v)
Definition: sc_bigint_inlines.h:272
sc_dt::sc_bigint::operator^=
sc_bigint< W > & operator^=(const sc_signed &v)
Definition: sc_bigint_inlines.h:398
sc_dt::sc_bigint::operator<<
const sc_signed operator<<(int v) const
Definition: sc_bigint_inlines.h:437
sc_dt::sc_biguint::get_digits
const sc_digit * get_digits() const
Definition: sc_biguint.h:712
sc_dt::sc_signed::digit
sc_digit * digit
Definition: sc_signed.h:1152
sc_dt::sc_signed::get_digits
sc_digit * get_digits() const
Definition: sc_signed.h:1198
sc_dt::sc_signed::get_digits_n
int get_digits_n() const
Definition: sc_signed.h:1200
sc_dt::sc_unsigned::get_digits
sc_digit * get_digits() const
Definition: sc_unsigned.h:1186
sc_dt::sc_unsigned::get_digits_n
int get_digits_n() const
Definition: sc_unsigned.h:1188
Generated on Fri Aug 16 2024 16:36:33 for SystemC by doxygen 1.9.4