SystemC  2.3.1
Accellera SystemC proof-of-concept library
sc_fixed.h
Go to the documentation of this file.
1 /*****************************************************************************
2 
3  The following code is derived, directly or indirectly, from the SystemC
4  source code Copyright (c) 1996-2014 by all Contributors.
5  All Rights reserved.
6 
7  The contents of this file are subject to the restrictions and limitations
8  set forth in the SystemC Open Source License (the "License");
9  You may not use this file except in compliance with such restrictions and
10  limitations. You may obtain instructions on how to receive a copy of the
11  License at http://www.accellera.org/. Software distributed by Contributors
12  under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
13  ANY KIND, either express or implied. See the License for the specific
14  language governing rights and limitations under the License.
15 
16  *****************************************************************************/
17 
18 /*****************************************************************************
19 
20  sc_fixed.h -
21 
22  Original Author: Martin Janssen, Synopsys, Inc.
23 
24  *****************************************************************************/
25 
26 /*****************************************************************************
27 
28  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
29  changes you are making here.
30 
31  Name, Affiliation, Date:
32  Description of Modification:
33 
34  *****************************************************************************/
35 
36 // $Log: sc_fixed.h,v $
37 // Revision 1.2 2011/01/19 18:57:40 acg
38 // Andy Goodrich: changes for IEEE_1666_2011.
39 //
40 // Revision 1.1.1.1 2006/12/15 20:20:04 acg
41 // SystemC 2.3
42 //
43 // Revision 1.3 2006/01/13 18:53:57 acg
44 // Andy Goodrich: added $Log command so that CVS comments are reproduced in
45 // the source.
46 //
47 
48 #ifndef SC_FIXED_H
49 #define SC_FIXED_H
50 
51 
52 #include "sysc/datatypes/fx/sc_fix.h"
53 
54 
55 namespace sc_dt
56 {
57 
58 // classes defined in this module
59 template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed;
60 template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed_fast;
61 
62 
63 // ----------------------------------------------------------------------------
64 // TEMPLATE CLASS : sc_fixed
65 //
66 // "Constrained" signed fixed-point class; arbitrary precision.
67 // ----------------------------------------------------------------------------
68 
69 template <int W, int I,
70  sc_q_mode Q = SC_DEFAULT_Q_MODE_,
71  sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
72 class sc_fixed : public sc_fix
73 {
74 
75 public:
76 
77  // constructors
78 
79  explicit sc_fixed( sc_fxnum_observer* = 0 );
80  explicit sc_fixed( const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
81 
82 #define DECL_CTORS_T_A(tp) \
83  sc_fixed( tp, sc_fxnum_observer* = 0 ); \
84  sc_fixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
85 
86 #define DECL_CTORS_T_B(tp) \
87  explicit sc_fixed( tp, sc_fxnum_observer* = 0 ); \
88  sc_fixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
89 
90  DECL_CTORS_T_A(int)
91  DECL_CTORS_T_A(unsigned int)
92  DECL_CTORS_T_A(long)
93  DECL_CTORS_T_A(unsigned long)
94  DECL_CTORS_T_A(float)
95  DECL_CTORS_T_A(double)
96  DECL_CTORS_T_A(const char*)
97  DECL_CTORS_T_A(const sc_fxval&)
98  DECL_CTORS_T_A(const sc_fxval_fast&)
99  DECL_CTORS_T_A(const sc_fxnum&)
100  DECL_CTORS_T_A(const sc_fxnum_fast&)
101 #ifndef SC_FX_EXCLUDE_OTHER
102  DECL_CTORS_T_B(int64)
103  DECL_CTORS_T_B(uint64)
104  DECL_CTORS_T_B(const sc_int_base&)
105  DECL_CTORS_T_B(const sc_uint_base&)
106  DECL_CTORS_T_B(const sc_signed&)
107  DECL_CTORS_T_B(const sc_unsigned&)
108 #endif
109 
110 #undef DECL_CTORS_T_A
111 #undef DECL_CTORS_T_B
112 
113  // copy constructor
114 
115  sc_fixed( const sc_fixed<W,I,Q,O,N>& );
116 
117 
118  // assignment operators
119 
120  sc_fixed& operator = ( const sc_fixed<W,I,Q,O,N>& );
121 
122 #define DECL_ASN_OP_T(op,tp) \
123  sc_fixed& operator op ( tp );
124 
125 #ifndef SC_FX_EXCLUDE_OTHER
126 #define DECL_ASN_OP_OTHER(op) \
127  DECL_ASN_OP_T(op,int64) \
128  DECL_ASN_OP_T(op,uint64) \
129  DECL_ASN_OP_T(op,const sc_int_base&) \
130  DECL_ASN_OP_T(op,const sc_uint_base&) \
131  DECL_ASN_OP_T(op,const sc_signed&) \
132  DECL_ASN_OP_T(op,const sc_unsigned&)
133 #else
134 #define DECL_ASN_OP_OTHER(op)
135 #endif
136 
137 #define DECL_ASN_OP(op) \
138  DECL_ASN_OP_T(op,int) \
139  DECL_ASN_OP_T(op,unsigned int) \
140  DECL_ASN_OP_T(op,long) \
141  DECL_ASN_OP_T(op,unsigned long) \
142  DECL_ASN_OP_T(op,float) \
143  DECL_ASN_OP_T(op,double) \
144  DECL_ASN_OP_T(op,const char*) \
145  DECL_ASN_OP_T(op,const sc_fxval&) \
146  DECL_ASN_OP_T(op,const sc_fxval_fast&) \
147  DECL_ASN_OP_T(op,const sc_fxnum&) \
148  DECL_ASN_OP_T(op,const sc_fxnum_fast&) \
149  DECL_ASN_OP_OTHER(op)
150 
151  DECL_ASN_OP(=)
152 
153  DECL_ASN_OP(*=)
154  DECL_ASN_OP(/=)
155  DECL_ASN_OP(+=)
156  DECL_ASN_OP(-=)
157 
158  DECL_ASN_OP_T(<<=,int)
159  DECL_ASN_OP_T(>>=,int)
160 
161  DECL_ASN_OP_T(&=,const sc_fix&)
162  DECL_ASN_OP_T(&=,const sc_fix_fast&)
163  DECL_ASN_OP_T(|=,const sc_fix&)
164  DECL_ASN_OP_T(|=,const sc_fix_fast&)
165  DECL_ASN_OP_T(^=,const sc_fix&)
166  DECL_ASN_OP_T(^=,const sc_fix_fast&)
167 
168 #undef DECL_ASN_OP_T
169 #undef DECL_ASN_OP_OTHER
170 #undef DECL_ASN_OP
171 
172 
173  // auto-increment and auto-decrement
174 
175  const sc_fxval operator ++ ( int );
176  const sc_fxval operator -- ( int );
177 
178  sc_fixed& operator ++ ();
179  sc_fixed& operator -- ();
180 
181 };
182 
183 
184 // ----------------------------------------------------------------------------
185 // TEMPLATE CLASS : sc_fixed_fast
186 //
187 // "Constrained" signed fixed-point class; limited precision.
188 // ----------------------------------------------------------------------------
189 
190 template <int W, int I,
191  sc_q_mode Q = SC_DEFAULT_Q_MODE_,
192  sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
193 class sc_fixed_fast : public sc_fix_fast
194 {
195 
196 public:
197 
198  // constructors
199 
200  explicit sc_fixed_fast( sc_fxnum_fast_observer* = 0 );
201  explicit sc_fixed_fast( const sc_fxcast_switch&,
202  sc_fxnum_fast_observer* = 0 );
203 
204 #define DECL_CTORS_T_A(tp) \
205  sc_fixed_fast( tp, sc_fxnum_fast_observer* = 0 ); \
206  sc_fixed_fast( tp, const sc_fxcast_switch&, \
207  sc_fxnum_fast_observer* = 0 );
208 
209 #define DECL_CTORS_T_B(tp) \
210  explicit sc_fixed_fast( tp, sc_fxnum_fast_observer* = 0 ); \
211  sc_fixed_fast( tp, const sc_fxcast_switch&, \
212  sc_fxnum_fast_observer* = 0 );
213 
214  DECL_CTORS_T_A(int)
215  DECL_CTORS_T_A(unsigned int)
216  DECL_CTORS_T_A(long)
217  DECL_CTORS_T_A(unsigned long)
218  DECL_CTORS_T_A(float)
219  DECL_CTORS_T_A(double)
220  DECL_CTORS_T_A(const char*)
221  DECL_CTORS_T_A(const sc_fxval&)
222  DECL_CTORS_T_A(const sc_fxval_fast&)
223  DECL_CTORS_T_A(const sc_fxnum&)
224  DECL_CTORS_T_A(const sc_fxnum_fast&)
225 #ifndef SC_FX_EXCLUDE_OTHER
226  DECL_CTORS_T_B(int64)
227  DECL_CTORS_T_B(uint64)
228  DECL_CTORS_T_B(const sc_int_base&)
229  DECL_CTORS_T_B(const sc_uint_base&)
230  DECL_CTORS_T_B(const sc_signed&)
231  DECL_CTORS_T_B(const sc_unsigned&)
232 #endif
233 
234 #undef DECL_CTORS_T_A
235 #undef DECL_CTORS_T_B
236 
237  // copy constructor
238 
239  sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& );
240 
241 
242  // assignment operators
243 
244  sc_fixed_fast& operator = ( const sc_fixed_fast<W,I,Q,O,N>& );
245 
246 #define DECL_ASN_OP_T(op,tp) \
247  sc_fixed_fast& operator op ( tp );
248 
249 #ifndef SC_FX_EXCLUDE_OTHER
250 #define DECL_ASN_OP_OTHER(op) \
251  DECL_ASN_OP_T(op,int64) \
252  DECL_ASN_OP_T(op,uint64) \
253  DECL_ASN_OP_T(op,const sc_int_base&) \
254  DECL_ASN_OP_T(op,const sc_uint_base&) \
255  DECL_ASN_OP_T(op,const sc_signed&) \
256  DECL_ASN_OP_T(op,const sc_unsigned&)
257 #else
258 #define DECL_ASN_OP_OTHER(op)
259 #endif
260 
261 #define DECL_ASN_OP(op) \
262  DECL_ASN_OP_T(op,int) \
263  DECL_ASN_OP_T(op,unsigned int) \
264  DECL_ASN_OP_T(op,long) \
265  DECL_ASN_OP_T(op,unsigned long) \
266  DECL_ASN_OP_T(op,float) \
267  DECL_ASN_OP_T(op,double) \
268  DECL_ASN_OP_T(op,const char*) \
269  DECL_ASN_OP_T(op,const sc_fxval&) \
270  DECL_ASN_OP_T(op,const sc_fxval_fast&) \
271  DECL_ASN_OP_T(op,const sc_fxnum&) \
272  DECL_ASN_OP_T(op,const sc_fxnum_fast&) \
273  DECL_ASN_OP_OTHER(op)
274 
275  DECL_ASN_OP(=)
276 
277  DECL_ASN_OP(*=)
278  DECL_ASN_OP(/=)
279  DECL_ASN_OP(+=)
280  DECL_ASN_OP(-=)
281 
282  DECL_ASN_OP_T(<<=,int)
283  DECL_ASN_OP_T(>>=,int)
284 
285  DECL_ASN_OP_T(&=,const sc_fix&)
286  DECL_ASN_OP_T(&=,const sc_fix_fast&)
287  DECL_ASN_OP_T(|=,const sc_fix&)
288  DECL_ASN_OP_T(|=,const sc_fix_fast&)
289  DECL_ASN_OP_T(^=,const sc_fix&)
290  DECL_ASN_OP_T(^=,const sc_fix_fast&)
291 
292 #undef DECL_ASN_OP_T
293 #undef DECL_ASN_OP_OTHER
294 #undef DECL_ASN_OP
295 
296 
297  // auto-increment and auto-decrement
298 
299  const sc_fxval_fast operator ++ ( int );
300  const sc_fxval_fast operator -- ( int );
301 
302  sc_fixed_fast& operator ++ ();
303  sc_fixed_fast& operator -- ();
304 
305 };
306 
307 
308 // IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
309 
310 // ----------------------------------------------------------------------------
311 // TEMPLATE CLASS : sc_fixed
312 //
313 // "Constrained" signed fixed-point class; arbitrary precision.
314 // ----------------------------------------------------------------------------
315 
316 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
317 inline
318 sc_fixed<W,I,Q,O,N>::sc_fixed( sc_fxnum_observer* observer_ )
319 : sc_fix( W, I, Q, O, N, observer_ )
320 {}
321 
322 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
323 inline
324 sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxcast_switch& cast_sw,
325  sc_fxnum_observer* observer_ )
326 : sc_fix( W, I, Q, O, N, cast_sw, observer_ )
327 {}
328 
329 #define DEFN_CTORS_T(tp) \
330 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> \
331 inline \
332 sc_fixed<W,I,Q,O,N>::sc_fixed( tp a, \
333  sc_fxnum_observer* observer_ ) \
334 : sc_fix( a, W, I, Q, O, N, observer_ ) \
335 {} \
336  \
337 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> \
338 inline \
339 sc_fixed<W,I,Q,O,N>::sc_fixed( tp a, \
340  const sc_fxcast_switch& cast_sw, \
341  sc_fxnum_observer* observer_ ) \
342 : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) \
343 {}
344 
345 DEFN_CTORS_T(int)
346 DEFN_CTORS_T(unsigned int)
347 DEFN_CTORS_T(long)
348 DEFN_CTORS_T(unsigned long)
349 DEFN_CTORS_T(float)
350 DEFN_CTORS_T(double)
351 DEFN_CTORS_T(const char*)
352 DEFN_CTORS_T(const sc_fxval&)
353 DEFN_CTORS_T(const sc_fxval_fast&)
354 DEFN_CTORS_T(const sc_fxnum&)
355 DEFN_CTORS_T(const sc_fxnum_fast&)
356 #ifndef SC_FX_EXCLUDE_OTHER
357 DEFN_CTORS_T(int64)
358 DEFN_CTORS_T(uint64)
359 DEFN_CTORS_T(const sc_int_base&)
360 DEFN_CTORS_T(const sc_uint_base&)
361 DEFN_CTORS_T(const sc_signed&)
362 DEFN_CTORS_T(const sc_unsigned&)
363 #endif
364 
365 #undef DEFN_CTORS_T
366 
367 // copy constructor
368 
369 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
370 inline
371 sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fixed<W,I,Q,O,N>& a )
372 : sc_fix( a, W, I, Q, O, N )
373 {}
374 
375 
376 // assignment operators
377 
378 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
379 inline
380 sc_fixed<W,I,Q,O,N>&
381 sc_fixed<W,I,Q,O,N>::operator = ( const sc_fixed<W,I,Q,O,N>& a )
382 {
383  sc_fix::operator = ( a );
384  return *this;
385 }
386 
387 #define DEFN_ASN_OP_T(op,tp) \
388 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> \
389 inline \
390 sc_fixed<W,I,Q,O,N>& \
391 sc_fixed<W,I,Q,O,N>::operator op ( tp a ) \
392 { \
393  sc_fix::operator op ( a ); \
394  return *this; \
395 }
396 
397 #ifndef SC_FX_EXCLUDE_OTHER
398 #define DEFN_ASN_OP_OTHER(op) \
399 DEFN_ASN_OP_T(op,int64) \
400 DEFN_ASN_OP_T(op,uint64) \
401 DEFN_ASN_OP_T(op,const sc_int_base&) \
402 DEFN_ASN_OP_T(op,const sc_uint_base&) \
403 DEFN_ASN_OP_T(op,const sc_signed&) \
404 DEFN_ASN_OP_T(op,const sc_unsigned&)
405 #else
406 #define DEFN_ASN_OP_OTHER(op)
407 #endif
408 
409 #define DEFN_ASN_OP(op) \
410 DEFN_ASN_OP_T(op,int) \
411 DEFN_ASN_OP_T(op,unsigned int) \
412 DEFN_ASN_OP_T(op,long) \
413 DEFN_ASN_OP_T(op,unsigned long) \
414 DEFN_ASN_OP_T(op,float) \
415 DEFN_ASN_OP_T(op,double) \
416 DEFN_ASN_OP_T(op,const char*) \
417 DEFN_ASN_OP_T(op,const sc_fxval&) \
418 DEFN_ASN_OP_T(op,const sc_fxval_fast&) \
419 DEFN_ASN_OP_T(op,const sc_fxnum&) \
420 DEFN_ASN_OP_T(op,const sc_fxnum_fast&) \
421 DEFN_ASN_OP_OTHER(op)
422 
423 DEFN_ASN_OP(=)
424 
425 DEFN_ASN_OP(*=)
426 DEFN_ASN_OP(/=)
427 DEFN_ASN_OP(+=)
428 DEFN_ASN_OP(-=)
429 
430 DEFN_ASN_OP_T(<<=,int)
431 DEFN_ASN_OP_T(>>=,int)
432 
433 DEFN_ASN_OP_T(&=,const sc_fix&)
434 DEFN_ASN_OP_T(&=,const sc_fix_fast&)
435 DEFN_ASN_OP_T(|=,const sc_fix&)
436 DEFN_ASN_OP_T(|=,const sc_fix_fast&)
437 DEFN_ASN_OP_T(^=,const sc_fix&)
438 DEFN_ASN_OP_T(^=,const sc_fix_fast&)
439 
440 #undef DEFN_ASN_OP_T
441 #undef DEFN_ASN_OP_OTHER
442 #undef DEFN_ASN_OP
443 
444 
445 // auto-increment and auto-decrement
446 
447 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
448 inline
449 const sc_fxval
450 sc_fixed<W,I,Q,O,N>::operator ++ ( int )
451 {
452  return sc_fxval( sc_fix::operator ++ ( 0 ) );
453 }
454 
455 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
456 inline
457 const sc_fxval
458 sc_fixed<W,I,Q,O,N>::operator -- ( int )
459 {
460  return sc_fxval( sc_fix::operator -- ( 0 ) );
461 }
462 
463 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
464 inline
465 sc_fixed<W,I,Q,O,N>&
466 sc_fixed<W,I,Q,O,N>::operator ++ ()
467 {
468  sc_fix::operator ++ ();
469  return *this;
470 }
471 
472 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
473 inline
474 sc_fixed<W,I,Q,O,N>&
475 sc_fixed<W,I,Q,O,N>::operator -- ()
476 {
477  sc_fix::operator -- ();
478  return *this;
479 }
480 
481 
482 // ----------------------------------------------------------------------------
483 // TEMPLATE CLASS : sc_fixed_fast
484 //
485 // "Constrained" signed fixed-point class; limited precision.
486 // ----------------------------------------------------------------------------
487 
488 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
489 inline
490 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( sc_fxnum_fast_observer* observer_ )
491 : sc_fix_fast( W, I, Q, O, N, observer_ )
492 {}
493 
494 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
495 inline
496 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxcast_switch& cast_sw,
497  sc_fxnum_fast_observer* observer_ )
498 : sc_fix_fast( W, I, Q, O, N, cast_sw, observer_ )
499 {}
500 
501 #define DEFN_CTORS_T(tp) \
502 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> \
503 inline \
504 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a, \
505  sc_fxnum_fast_observer* observer_ ) \
506 : sc_fix_fast( a, W, I, Q, O, N, observer_ ) \
507 {} \
508  \
509 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> \
510 inline \
511 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a, \
512  const sc_fxcast_switch& cast_sw, \
513  sc_fxnum_fast_observer* observer_ ) \
514 : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) \
515 {}
516 
517 DEFN_CTORS_T(int)
518 DEFN_CTORS_T(unsigned int)
519 DEFN_CTORS_T(long)
520 DEFN_CTORS_T(unsigned long)
521 DEFN_CTORS_T(float)
522 DEFN_CTORS_T(double)
523 DEFN_CTORS_T(const char*)
524 DEFN_CTORS_T(const sc_fxval&)
525 DEFN_CTORS_T(const sc_fxval_fast&)
526 DEFN_CTORS_T(const sc_fxnum&)
527 DEFN_CTORS_T(const sc_fxnum_fast&)
528 #ifndef SC_FX_EXCLUDE_OTHER
529 DEFN_CTORS_T(int64)
530 DEFN_CTORS_T(uint64)
531 DEFN_CTORS_T(const sc_int_base&)
532 DEFN_CTORS_T(const sc_uint_base&)
533 DEFN_CTORS_T(const sc_signed&)
534 DEFN_CTORS_T(const sc_unsigned&)
535 #endif
536 
537 #undef DEFN_CTORS_T
538 
539 // copy constructor
540 
541 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
542 inline
543 sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& a )
544 : sc_fix_fast( a, W, I, Q, O, N )
545 {}
546 
547 
548 // assignment operators
549 
550 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
551 inline
552 sc_fixed_fast<W,I,Q,O,N>&
553 sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fixed_fast<W,I,Q,O,N>& a )
554 {
555  sc_fix_fast::operator = ( a );
556  return *this;
557 }
558 
559 #define DEFN_ASN_OP_T(op,tp) \
560 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> \
561 inline \
562 sc_fixed_fast<W,I,Q,O,N>& \
563 sc_fixed_fast<W,I,Q,O,N>::operator op ( tp a ) \
564 { \
565  sc_fix_fast::operator op ( a ); \
566  return *this; \
567 }
568 
569 #ifndef SC_FX_EXCLUDE_OTHER
570 #define DEFN_ASN_OP_OTHER(op) \
571 DEFN_ASN_OP_T(op,int64) \
572 DEFN_ASN_OP_T(op,uint64) \
573 DEFN_ASN_OP_T(op,const sc_int_base&) \
574 DEFN_ASN_OP_T(op,const sc_uint_base&) \
575 DEFN_ASN_OP_T(op,const sc_signed&) \
576 DEFN_ASN_OP_T(op,const sc_unsigned&)
577 #else
578 #define DEFN_ASN_OP_OTHER(op)
579 #endif
580 
581 #define DEFN_ASN_OP(op) \
582 DEFN_ASN_OP_T(op,int) \
583 DEFN_ASN_OP_T(op,unsigned int) \
584 DEFN_ASN_OP_T(op,long) \
585 DEFN_ASN_OP_T(op,unsigned long) \
586 DEFN_ASN_OP_T(op,float) \
587 DEFN_ASN_OP_T(op,double) \
588 DEFN_ASN_OP_T(op,const char*) \
589 DEFN_ASN_OP_T(op,const sc_fxval&) \
590 DEFN_ASN_OP_T(op,const sc_fxval_fast&) \
591 DEFN_ASN_OP_T(op,const sc_fxnum&) \
592 DEFN_ASN_OP_T(op,const sc_fxnum_fast&) \
593 DEFN_ASN_OP_OTHER(op)
594 
595 DEFN_ASN_OP(=)
596 
597 DEFN_ASN_OP(*=)
598 DEFN_ASN_OP(/=)
599 DEFN_ASN_OP(+=)
600 DEFN_ASN_OP(-=)
601 
602 DEFN_ASN_OP_T(<<=,int)
603 DEFN_ASN_OP_T(>>=,int)
604 
605 DEFN_ASN_OP_T(&=,const sc_fix&)
606 DEFN_ASN_OP_T(&=,const sc_fix_fast&)
607 DEFN_ASN_OP_T(|=,const sc_fix&)
608 DEFN_ASN_OP_T(|=,const sc_fix_fast&)
609 DEFN_ASN_OP_T(^=,const sc_fix&)
610 DEFN_ASN_OP_T(^=,const sc_fix_fast&)
611 
612 #undef DEFN_ASN_OP_T
613 #undef DEFN_ASN_OP_OTHER
614 #undef DEFN_ASN_OP
615 
616 
617 // auto-increment and auto-decrement
618 
619 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
620 inline
621 const sc_fxval_fast
622 sc_fixed_fast<W,I,Q,O,N>::operator ++ ( int )
623 {
624  return sc_fxval_fast( sc_fix_fast::operator ++ ( 0 ) );
625 }
626 
627 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
628 inline
629 const sc_fxval_fast
630 sc_fixed_fast<W,I,Q,O,N>::operator -- ( int )
631 {
632  return sc_fxval_fast( sc_fix_fast::operator -- ( 0 ) );
633 }
634 
635 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
636 inline
637 sc_fixed_fast<W,I,Q,O,N>&
638 sc_fixed_fast<W,I,Q,O,N>::operator ++ ()
639 {
640  sc_fix_fast::operator ++ ();
641  return *this;
642 }
643 
644 template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
645 inline
646 sc_fixed_fast<W,I,Q,O,N>&
647 sc_fixed_fast<W,I,Q,O,N>::operator -- ()
648 {
649  sc_fix_fast::operator -- ();
650  return *this;
651 }
652 
653 } // namespace sc_dt
654 
655 
656 #endif
657 
658 // Taf!
sc_dt::sc_fix::operator--
sc_fix & operator--()
Definition: sc_fix.h:1227
sc_dt::sc_fixed::operator=
sc_fixed & operator=(const sc_fixed< W, I, Q, O, N > &)
Definition: sc_fixed.h:381
sc_dt::SC_DEFAULT_Q_MODE_
const sc_q_mode SC_DEFAULT_Q_MODE_
Definition: sc_fxdefs.h:200
sc_dt::SC_DEFAULT_N_BITS_
const int SC_DEFAULT_N_BITS_
Definition: sc_fxdefs.h:202
sc_dt::sc_fixed_fast::operator=
sc_fixed_fast & operator=(const sc_fixed_fast< W, I, Q, O, N > &)
Definition: sc_fixed.h:553
DECL_CTORS_T_A
#define DECL_CTORS_T_A(tp)
Definition: sc_fixed.h:204
sc_dt::sc_fix_fast::operator++
sc_fix_fast & operator++()
Definition: sc_fix.h:1917
sc_dt::uint64
uint64_t uint64
Definition: sc_nbdefs.h:183
sc_dt::sc_fix_fast::sc_fix_fast
sc_fix_fast(sc_fxnum_fast_observer *=0)
Definition: sc_fix.h:1243
DECL_CTORS_T_B
#define DECL_CTORS_T_B(tp)
Definition: sc_fixed.h:209
sc_dt::int64
int64_t int64
Definition: sc_nbdefs.h:182
sc_dt::sc_o_mode
sc_o_mode
Definition: sc_fxdefs.h:116
DEFN_CTORS_T
#define DEFN_CTORS_T(tp)
Definition: sc_fixed.h:501
sc_dt::sc_fixed_fast::sc_fixed_fast
sc_fixed_fast(sc_fxnum_fast_observer *=0)
Definition: sc_fixed.h:490
sc_dt::sc_fix_fast::operator=
sc_fix_fast & operator=(const sc_fix_fast &)
Definition: sc_fix.h:1818
sc_dt::sc_fixed_fast::operator++
sc_fixed_fast & operator++()
Definition: sc_fixed.h:638
sc_dt::sc_fix_fast::operator--
sc_fix_fast & operator--()
Definition: sc_fix.h:1925
sc_dt::SC_DEFAULT_O_MODE_
const sc_o_mode SC_DEFAULT_O_MODE_
Definition: sc_fxdefs.h:201
DECL_ASN_OP_T
#define DECL_ASN_OP_T(op, tp)
Definition: sc_fixed.h:246
sc_dt::sc_fixed::sc_fixed
sc_fixed(sc_fxnum_observer *=0)
Definition: sc_fixed.h:318
sc_dt::sc_fixed::operator++
sc_fixed & operator++()
Definition: sc_fixed.h:466
DEFN_ASN_OP
#define DEFN_ASN_OP(op)
Definition: sc_fixed.h:581
sc_dt::sc_fixed_fast::operator--
sc_fixed_fast & operator--()
Definition: sc_fixed.h:647
sc_dt::sc_q_mode
sc_q_mode
Definition: sc_fxdefs.h:87
sc_dt::sc_fixed::operator--
sc_fixed & operator--()
Definition: sc_fixed.h:475
sc_dt::sc_fxnum_fast::sc_fxval_fast
friend class sc_fxval_fast
Definition: sc_fxnum.h:990
DEFN_ASN_OP_T
#define DEFN_ASN_OP_T(op, tp)
Definition: sc_fixed.h:559
DECL_ASN_OP
#define DECL_ASN_OP(op)
Definition: sc_fixed.h:261
sc_dt::sc_fix::operator=
sc_fix & operator=(const sc_fix &)
Definition: sc_fix.h:1120
sc_dt::sc_fix::operator++
sc_fix & operator++()
Definition: sc_fix.h:1219
Generated on Thu Jun 19 2014 07:41:22 for SystemC by   doxygen 1.8.6