SystemC 3.0.0
Accellera SystemC proof-of-concept library
sc_biguint_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_biguint<W>_inlines.h -- sc_biguint<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_BIGUINT_INLINES_H
32#define SC_BIGUINT_INLINES_H
33
34namespace sc_dt {
35
36// +----------------------------------------------------------------------------
37// |"sc_biguint<W>::operator ="
38// |
39// | These are the assignment operators for the sc_biguint<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_biguint<W>&
48sc_biguint<W>::operator = (const sc_biguint<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_biguint<W>&
57sc_biguint<W>::operator = (const sc_biguint<WO>& from)
58{
59 if ( W == WO ) {
60 vector_copy( DIGITS_N, from.get_digits(), get_digits() );
61 }
62 else {
63 vector_copy(sc_biguint<WO>::DIGITS_N, from.get_digits(), DIGITS_N, get_digits() );
64 adjust_hod();
65 }
66 return *this;
67}
68
69template<int W>
70template<int WO>
71inline const sc_biguint<W>&
72sc_biguint<W>::operator = (const sc_bigint<WO>& from)
73{
74 sc_digit* to_p = get_digits();
75 vector_copy( sc_biguint<WO>::DIGITS_N, from.get_digits(), DIGITS_N, to_p );
76 adjust_hod();
77 return *this;
78}
79
80template<int W>
81inline const sc_biguint<W>&
82sc_biguint<W>::operator = (const sc_unsigned& from)
83{
84 sc_digit* to_p = get_digits();
85 vector_copy( from.get_digits_n(), from.get_digits(), DIGITS_N, to_p );
86 adjust_hod();
87 return *this;
88}
89
90template<int W>
91inline const sc_biguint<W>&
92sc_biguint<W>::operator = (const sc_signed& from)
93{
94 sc_digit* to_p = get_digits();
95 vector_copy( from.get_digits_n(), from.get_digits(), DIGITS_N, to_p );
96 adjust_hod();
97 return *this;
98}
99
100template<int W>
101inline const sc_biguint<W>&
102sc_biguint<W>::operator = ( int64 from )
103{
104 sc_digit* to_p = get_digits();
105 *to_p++ = (sc_digit)from;
106 if ( HOD > 0 ) {
107 *to_p++ = from >> 32;
108 }
109 if ( HOD > 1 ) {
110 vector_fill( from < 0 ? -1 : 0, HOD-2, to_p );
111 }
112 adjust_hod();
113 return *this;
114}
115
116template<int W>
117inline const sc_biguint<W>&
118sc_biguint<W>::operator = ( long from )
119{
120 sc_digit* to_p = get_digits();
121 *to_p++ = from;
122 if ( sizeof(from) > 4 ) {
123 if ( HOD > 0 ) {
124 *to_p++ = (int64)from >> 32;
125 }
126 if ( HOD > 1 ) {
127 vector_fill( from < 0 ? -1 : 0, HOD-2, to_p );
128 }
129 }
130 else if ( HOD > 0 ) {
131 vector_fill( from < 0 ? -1 : 0, HOD-1, to_p );
132 }
133 adjust_hod();
134 return *this;
135}
136
137template<int W>
138inline const sc_biguint<W>&
139sc_biguint<W>::operator = ( int from )
140{
141 sc_digit* to_p = get_digits();
142 *to_p++ = from;
143 if ( HOD > 0 ) {
144 vector_fill( from < 0 ? -1 : 0, HOD-1, to_p );
145 }
146 adjust_hod();
147 return *this;
148}
149
150template<int W>
151inline const sc_biguint<W>&
152sc_biguint<W>::operator = ( uint64 from )
153{
154 sc_digit* to_p = get_digits();
155 *to_p++ = (sc_digit)from;
156 if ( HOD > 0 ) {
157 *to_p++ = from >> 32;
158 }
159 if ( HOD > 1 ) {
160 vector_fill( 0, HOD - 2, to_p );
161 }
162 adjust_hod();
163 return *this;
164}
165
166template<int W>
167inline const sc_biguint<W>&
168sc_biguint<W>::operator = ( unsigned long from )
169{
170 sc_digit* to_p = get_digits();
171 *to_p++ = from;
172 if ( sizeof(from) > 4 ) {
173 if ( HOD > 0 ) {
174 *to_p++ = (uint64)from >> 32;
175 }
176 if ( HOD > 1 ) {
177 vector_fill( 0, HOD-2, to_p );
178 }
179 }
180 else if ( HOD > 1 ) {
181 vector_fill( 0, HOD-1, to_p );
182 }
183 adjust_hod();
184 return *this;
185}
186
187template<int W>
188inline const sc_biguint<W>&
189sc_biguint<W>::operator = ( unsigned int from )
190{
191 sc_digit* to_p = get_digits();
192 *to_p++ = from;
193 if ( HOD > 0 ) {
194 vector_fill( 0, HOD-1, to_p );
195 }
196 adjust_hod();
197 return *this;
198}
199
200template<int W>
201inline const sc_biguint<W>&
202sc_biguint<W>::operator = ( const sc_int_base& from )
203{
204 return *this = (int64)from;
205}
206
207template<int W>
208inline const sc_biguint<W>&
209sc_biguint<W>::operator = ( const sc_uint_base& from )
210{
211 return *this = (uint64)from;
212}
213
214template<int W>
215inline const sc_bigint<W+1>
216sc_biguint<W>::operator - ()
217{
218 sc_carry carry=1;
219 sc_bigint<W+1> result;
220 for ( int digit_i = 0; digit_i <= HOD; ++digit_i ) {
221 carry += ~digit[digit_i];
222 result.digit[digit_i] = carry;
223 carry >>=BITS_PER_DIGIT;
224 }
225 return result;
226}
227
228template<int W>
229inline const sc_bigint<W+1>
230sc_biguint<W>::operator ~ ()
231{
232 sc_bigint<W+1> result;
233 for ( int digit_i = 0; digit_i <= HOD; ++digit_i ) {
234 result.digit[digit_i] = ~digit[digit_i];
235 }
236 return result;
237}
238
239 // SELF-REFERENCING OPERATORS:
240
241 template<int W>
242 inline const sc_biguint<W>& sc_biguint<W>::operator += (const sc_signed& v) { sc_unsigned_proxy()+= v; return *this; }
243 template<int W>
244 inline const sc_biguint<W>& sc_biguint<W>::operator += (const sc_unsigned& v) { sc_unsigned_proxy()+= v; return *this; }
245 template<int W>
246 inline const sc_biguint<W>& sc_biguint<W>::operator += (int64 v) { sc_unsigned_proxy()+= v; return *this; }
247 template<int W>
248 inline const sc_biguint<W>& sc_biguint<W>::operator += (uint64 v) { sc_unsigned_proxy()+= v; return *this; }
249 template<int W>
250 inline const sc_biguint<W>& sc_biguint<W>::operator += (long v) { sc_unsigned_proxy()+= v; return *this; }
251 template<int W>
252 inline const sc_biguint<W>& sc_biguint<W>::operator += (unsigned long v) { sc_unsigned_proxy()+= v; return *this; }
253 template<int W>
254 inline const sc_biguint<W>& sc_biguint<W>::operator += (int v) { sc_unsigned_proxy()+= v; return *this; }
255 template<int W>
256 inline const sc_biguint<W>& sc_biguint<W>::operator += (unsigned int v) { sc_unsigned_proxy()+= v; return *this; }
257 template<int W>
258 inline const sc_biguint<W>& sc_biguint<W>::operator += (const sc_int_base& v) { sc_unsigned_proxy()+= v; return *this; }
259 template<int W>
260 inline const sc_biguint<W>& sc_biguint<W>::operator += (const sc_uint_base& v) { sc_unsigned_proxy()+= v; return *this; }
261
262 template<int W>
263 inline const sc_biguint<W>& sc_biguint<W>::operator -= (const sc_signed& v) { sc_unsigned_proxy()-= v; return *this; }
264 template<int W>
265 inline const sc_biguint<W>& sc_biguint<W>::operator -= (const sc_unsigned& v) { sc_unsigned_proxy()-= v; return *this; }
266 template<int W>
267 inline const sc_biguint<W>& sc_biguint<W>::operator -= (int64 v) { sc_unsigned_proxy()-= v; return *this; }
268 template<int W>
269 inline const sc_biguint<W>& sc_biguint<W>::operator -= (uint64 v) { sc_unsigned_proxy()-= v; return *this; }
270 template<int W>
271 inline const sc_biguint<W>& sc_biguint<W>::operator -= (long v) { sc_unsigned_proxy()-= v; return *this; }
272 template<int W>
273 inline const sc_biguint<W>& sc_biguint<W>::operator -= (unsigned long v) { sc_unsigned_proxy()-= v; return *this; }
274 template<int W>
275 inline const sc_biguint<W>& sc_biguint<W>::operator -= (int v) { sc_unsigned_proxy()-= v; return *this; }
276 template<int W>
277 inline const sc_biguint<W>& sc_biguint<W>::operator -= (unsigned int v) { sc_unsigned_proxy()-= v; return *this; }
278 template<int W>
279 inline const sc_biguint<W>& sc_biguint<W>::operator -= (const sc_int_base& v) { sc_unsigned_proxy()-= v; return *this; }
280 template<int W>
281 inline const sc_biguint<W>& sc_biguint<W>::operator -= (const sc_uint_base& v) { sc_unsigned_proxy()-= v; return *this; }
282
283 template<int W>
284 inline const sc_biguint<W>& sc_biguint<W>::operator *= (const sc_signed& v) { sc_unsigned_proxy()*= v; return *this; }
285 template<int W>
286 inline const sc_biguint<W>& sc_biguint<W>::operator *= (const sc_unsigned& v) { sc_unsigned_proxy()*= v; return *this; }
287 template<int W>
288 inline const sc_biguint<W>& sc_biguint<W>::operator *= (int64 v) { sc_unsigned_proxy()*= v; return *this; }
289 template<int W>
290 inline const sc_biguint<W>& sc_biguint<W>::operator *= (uint64 v) { sc_unsigned_proxy()*= v; return *this; }
291 template<int W>
292 inline const sc_biguint<W>& sc_biguint<W>::operator *= (long v) { sc_unsigned_proxy()*= v; return *this; }
293 template<int W>
294 inline const sc_biguint<W>& sc_biguint<W>::operator *= (unsigned long v) { sc_unsigned_proxy()*= v; return *this; }
295 template<int W>
296 inline const sc_biguint<W>& sc_biguint<W>::operator *= (int v) { sc_unsigned_proxy()*= v; return *this; }
297 template<int W>
298 inline const sc_biguint<W>& sc_biguint<W>::operator *= (unsigned int v) { sc_unsigned_proxy()*= v; return *this; }
299 template<int W>
300 inline const sc_biguint<W>& sc_biguint<W>::operator *= (const sc_int_base& v) { sc_unsigned_proxy()*= v; return *this; }
301 template<int W>
302 inline const sc_biguint<W>& sc_biguint<W>::operator *= (const sc_uint_base& v) { sc_unsigned_proxy()*= v; return *this; }
303
304 template<int W>
305 inline const sc_biguint<W>& sc_biguint<W>::operator /= (const sc_signed& v) { sc_unsigned_proxy()/= v; return *this; }
306 template<int W>
307 inline const sc_biguint<W>& sc_biguint<W>::operator /= (const sc_unsigned& v) { sc_unsigned_proxy()/= v; return *this; }
308 template<int W>
309 inline const sc_biguint<W>& sc_biguint<W>::operator /= (int64 v) { sc_unsigned_proxy()/= v; return *this; }
310 template<int W>
311 inline const sc_biguint<W>& sc_biguint<W>::operator /= (uint64 v) { sc_unsigned_proxy()/= v; return *this; }
312 template<int W>
313 inline const sc_biguint<W>& sc_biguint<W>::operator /= (long v) { sc_unsigned_proxy()/= v; return *this; }
314 template<int W>
315 inline const sc_biguint<W>& sc_biguint<W>::operator /= (unsigned long v) { sc_unsigned_proxy()/= v; return *this; }
316 template<int W>
317 inline const sc_biguint<W>& sc_biguint<W>::operator /= (int v) { sc_unsigned_proxy()/= v; return *this; }
318 template<int W>
319 inline const sc_biguint<W>& sc_biguint<W>::operator /= (unsigned int v) { sc_unsigned_proxy()/= v; return *this; }
320 template<int W>
321 inline const sc_biguint<W>& sc_biguint<W>::operator /= (const sc_int_base& v) { sc_unsigned_proxy()/= v; return *this; }
322 template<int W>
323 inline const sc_biguint<W>& sc_biguint<W>::operator /= (const sc_uint_base& v) { sc_unsigned_proxy()/= v; return *this; }
324
325 template<int W>
326 inline const sc_biguint<W>& sc_biguint<W>::operator %= (const sc_signed& v) { sc_unsigned_proxy()%= v; return *this; }
327 template<int W>
328 inline const sc_biguint<W>& sc_biguint<W>::operator %= (const sc_unsigned& v) { sc_unsigned_proxy()%= v; return *this; }
329 template<int W>
330 inline const sc_biguint<W>& sc_biguint<W>::operator %= (int64 v) { sc_unsigned_proxy()%= v; return *this; }
331 template<int W>
332 inline const sc_biguint<W>& sc_biguint<W>::operator %= (uint64 v) { sc_unsigned_proxy()%= v; return *this; }
333 template<int W>
334 inline const sc_biguint<W>& sc_biguint<W>::operator %= (long v) { sc_unsigned_proxy()%= v; return *this; }
335 template<int W>
336 inline const sc_biguint<W>& sc_biguint<W>::operator %= (unsigned long v) { sc_unsigned_proxy()%= v; return *this; }
337 template<int W>
338 inline const sc_biguint<W>& sc_biguint<W>::operator %= (int v) { sc_unsigned_proxy()%= v; return *this; }
339 template<int W>
340 inline const sc_biguint<W>& sc_biguint<W>::operator %= (unsigned int v) { sc_unsigned_proxy()%= v; return *this; }
341 template<int W>
342 inline const sc_biguint<W>& sc_biguint<W>::operator %= (const sc_int_base& v) { sc_unsigned_proxy()%= v; return *this; }
343 template<int W>
344 inline const sc_biguint<W>& sc_biguint<W>::operator %= (const sc_uint_base& v) { sc_unsigned_proxy()%= v; return *this; }
345
346 template<int W>
347 inline const sc_biguint<W>& sc_biguint<W>::operator &= (const sc_signed& v) { sc_unsigned_proxy()&= v; return *this; }
348 template<int W>
349 inline const sc_biguint<W>& sc_biguint<W>::operator &= (const sc_unsigned& v) { sc_unsigned_proxy()&= v; return *this; }
350 template<int W>
351 inline const sc_biguint<W>& sc_biguint<W>::operator &= (int64 v) { sc_unsigned_proxy()&= v; return *this; }
352 template<int W>
353 inline const sc_biguint<W>& sc_biguint<W>::operator &= (uint64 v) { sc_unsigned_proxy()&= v; return *this; }
354 template<int W>
355 inline const sc_biguint<W>& sc_biguint<W>::operator &= (long v) { sc_unsigned_proxy()&= v; return *this; }
356 template<int W>
357 inline const sc_biguint<W>& sc_biguint<W>::operator &= (unsigned long v) { sc_unsigned_proxy()&= v; return *this; }
358 template<int W>
359 inline const sc_biguint<W>& sc_biguint<W>::operator &= (int v) { sc_unsigned_proxy()&= v; return *this; }
360 template<int W>
361 inline const sc_biguint<W>& sc_biguint<W>::operator &= (unsigned int v) { sc_unsigned_proxy()&= v; return *this; }
362 template<int W>
363 inline const sc_biguint<W>& sc_biguint<W>::operator &= (const sc_int_base& v) { sc_unsigned_proxy()&= v; return *this; }
364 template<int W>
365 inline const sc_biguint<W>& sc_biguint<W>::operator &= (const sc_uint_base& v) { sc_unsigned_proxy()&= v; return *this; }
366
367 template<int W>
368 inline const sc_biguint<W>& sc_biguint<W>::operator |= (const sc_signed& v) { sc_unsigned_proxy()|= v; return *this; }
369 template<int W>
370 inline const sc_biguint<W>& sc_biguint<W>::operator |= (const sc_unsigned& v) { sc_unsigned_proxy()|= v; return *this; }
371 template<int W>
372 inline const sc_biguint<W>& sc_biguint<W>::operator |= (int64 v) { sc_unsigned_proxy()|= v; return *this; }
373 template<int W>
374 inline const sc_biguint<W>& sc_biguint<W>::operator |= (uint64 v) { sc_unsigned_proxy()|= v; return *this; }
375 template<int W>
376 inline const sc_biguint<W>& sc_biguint<W>::operator |= (long v) { sc_unsigned_proxy()|= v; return *this; }
377 template<int W>
378 inline const sc_biguint<W>& sc_biguint<W>::operator |= (unsigned long v) { sc_unsigned_proxy()|= v; return *this; }
379 template<int W>
380 inline const sc_biguint<W>& sc_biguint<W>::operator |= (int v) { sc_unsigned_proxy()|= v; return *this; }
381 template<int W>
382 inline const sc_biguint<W>& sc_biguint<W>::operator |= (unsigned int v) { sc_unsigned_proxy()|= v; return *this; }
383 template<int W>
384 inline const sc_biguint<W>& sc_biguint<W>::operator |= (const sc_int_base& v) { sc_unsigned_proxy()|= v; return *this; }
385 template<int W>
386 inline const sc_biguint<W>& sc_biguint<W>::operator |= (const sc_uint_base& v) { sc_unsigned_proxy()|= v; return *this; }
387
388 template<int W>
389 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (const sc_signed& v) { sc_unsigned_proxy()^= v; return *this; }
390 template<int W>
391 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (const sc_unsigned& v) { sc_unsigned_proxy()^= v; return *this; }
392 template<int W>
393 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (int64 v) { sc_unsigned_proxy()^= v; return *this; }
394 template<int W>
395 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (uint64 v) { sc_unsigned_proxy()^= v; return *this; }
396 template<int W>
397 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (long v) { sc_unsigned_proxy()^= v; return *this; }
398 template<int W>
399 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (unsigned long v) { sc_unsigned_proxy()^= v; return *this; }
400 template<int W>
401 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (int v) { sc_unsigned_proxy()^= v; return *this; }
402 template<int W>
403 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (unsigned int v) { sc_unsigned_proxy()^= v; return *this; }
404 template<int W>
405 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (const sc_int_base& v) { sc_unsigned_proxy()^= v; return *this; }
406 template<int W>
407 inline const sc_biguint<W>& sc_biguint<W>::operator ^= (const sc_uint_base& v) { sc_unsigned_proxy()^= v; return *this; }
408
409// reduce methods
410
411template<int W>
412inline bool sc_biguint<W>::and_reduce() const { return vector_and_reduce(W,digit); }
413template<int W>
414inline bool sc_biguint<W>::nand_reduce() const { return !vector_and_reduce(W,digit); }
415template<int W>
416inline bool sc_biguint<W>::or_reduce() const { return vector_or_reduce(W,digit); }
417template<int W>
418inline bool sc_biguint<W>::nor_reduce() const { return !vector_or_reduce(W,digit); }
419template<int W>
420inline bool sc_biguint<W>::xor_reduce() const { return vector_xor_reduce(W,digit); }
421template<int W>
422inline bool sc_biguint<W>::xnor_reduce() const { return !vector_xor_reduce(W,digit); }
423
424// left shift methods:
425
426template<int W>
427const sc_unsigned
428sc_biguint<W>::operator<<(int v) const
429{
430 if (v <= 0)
431 return sc_unsigned(*this);
432
433 int nb = W + v;
434 int nd = DIV_CEIL(nb+1);
435 sc_unsigned result(nb, false);
436
437 vector_shift_left( DIV_CEIL(W+1), digit, nd, result.digit, v );
438 result.adjust_hod();
439
440 return result;
441}
442
443template<int W>
444const sc_biguint<W>&
445sc_biguint<W>::operator<<=(int v)
446{
447 if (v <= 0)
448 return *this;
449
450 vector_shift_left( DIV_CEIL(W+1), digit, v );
451 adjust_hod();
452
453 return *this;
454}
455
456
457// right shift methods:
458
459template<int W>
460const sc_unsigned
461sc_biguint<W>::operator>>(int v) const
462{
463 if (v <= 0) {
464 return sc_unsigned(*this);
465 }
466 int nb = W - v;
467
468 // If we shift off the end return a single bit 0.
469
470 if ( nb <= 0 ) {
471 sc_unsigned result(1, true);
472 return result;
473 }
474
475
476 // Return a value that is the width of the shifted value:
477 //
478 // Note: sc_biguint<W> values have one extra bit on the top, so the comparison is down
479 // one bit, e.g., W < 32, not W < 33.
480
481 sc_unsigned result(nb, false);
482 if ( W < 32 ) {
483 result.digit[0] = digit[0] >> v;
484 }
485 else if ( W < 64 ) {
486 uint64 tmp = digit[DIV_CEIL(W)-1];
487 tmp = (tmp << 32) | digit[0];
488 tmp = tmp >> v;
489 result.digit[0] = tmp;
490 if ( result.nbits > 32 ) {
491 result.digit[1] = (tmp >> 32);
492 }
493 }
494 else {
495 vector_extract(digit, result.digit, W-1, v);
496 }
497 result.adjust_hod();
498 return result;
499}
500
501template<int W>
502const sc_biguint<W>&
503sc_biguint<W>::operator>>=(int v)
504{
505
506 if (v <= 0)
507 return *this;
508
509 int nd = DIV_CEIL(W+1);
510 vector_shift_right(nd, digit, v, 0);
511
512 return *this;
513}
514
515template<int W>
516template<int WO>
517sc_bv<W>::sc_bv( const sc_biguint<WO>& v )
518 : sc_bv_base(W)
519{
520 *this = v.sc_unsigned_proxy();
521}
522
523template<int W>
524template<int WO>
525sc_lv<W>::sc_lv( const sc_biguint<WO>& v )
526 : sc_lv_base(W)
527{
528 *this = v.sc_unsigned_proxy();
529}
530
531
532} // namespace sc_dt
533
534#endif // SC_BIGUINT_INLINES_H
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::get_digits
const sc_digit * get_digits() const
Definition: sc_bigint.h:706
sc_dt::sc_biguint::nand_reduce
bool nand_reduce() const
Definition: sc_biguint_inlines.h:414
sc_dt::sc_biguint::operator-=
const sc_biguint< W > & operator-=(const sc_signed &v)
Definition: sc_biguint_inlines.h:263
sc_dt::sc_biguint::operator>>
const sc_unsigned operator>>(int v) const
Definition: sc_biguint_inlines.h:461
sc_dt::sc_biguint::operator%=
const sc_biguint< W > & operator%=(const sc_signed &v)
Definition: sc_biguint_inlines.h:326
sc_dt::sc_biguint::operator|=
const sc_biguint< W > & operator|=(const sc_signed &v)
Definition: sc_biguint_inlines.h:368
sc_dt::sc_biguint::operator>>=
const sc_biguint< W > & operator>>=(int v)
Definition: sc_biguint_inlines.h:503
sc_dt::sc_biguint::xnor_reduce
bool xnor_reduce() const
Definition: sc_biguint_inlines.h:422
sc_dt::sc_biguint::operator&=
const sc_biguint< W > & operator&=(const sc_signed &v)
Definition: sc_biguint_inlines.h:347
sc_dt::sc_biguint::get_digits
const sc_digit * get_digits() const
Definition: sc_biguint.h:712
sc_dt::sc_biguint::operator=
const sc_biguint< W > & operator=(const sc_biguint< W > &v)
Definition: sc_biguint_inlines.h:48
sc_dt::sc_biguint::operator/=
const sc_biguint< W > & operator/=(const sc_signed &v)
Definition: sc_biguint_inlines.h:305
sc_dt::sc_biguint::operator<<=
const sc_biguint< W > & operator<<=(int v)
Definition: sc_biguint_inlines.h:445
sc_dt::sc_biguint::operator-
const sc_bigint< W+1 > operator-()
Definition: sc_biguint_inlines.h:216
sc_dt::sc_biguint::operator+=
const sc_biguint< W > & operator+=(const sc_signed &v)
Definition: sc_biguint_inlines.h:242
sc_dt::sc_biguint::operator<<
const sc_unsigned operator<<(int v) const
Definition: sc_biguint_inlines.h:428
sc_dt::sc_biguint::sc_unsigned_proxy
sc_unsigned & sc_unsigned_proxy()
Definition: sc_biguint.h:682
sc_dt::sc_biguint::operator*=
const sc_biguint< W > & operator*=(const sc_signed &v)
Definition: sc_biguint_inlines.h:284
sc_dt::sc_biguint::operator~
const sc_bigint< W+1 > operator~()
Definition: sc_biguint_inlines.h:230
sc_dt::sc_biguint::operator^=
const sc_biguint< W > & operator^=(const sc_signed &v)
Definition: sc_biguint_inlines.h:389
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