Mercurial > octave
annotate liboctave/oct-inttypes.h @ 7521:6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Sun, 24 Feb 2008 02:58:01 -0500 |
parents | 8c32f95c2639 |
children | ef755c763b62 |
rev | line source |
---|---|
4902 | 1 /* |
2 | |
7017 | 3 Copyright (C) 2004, 2005, 2006, 2007 John W. Eaton |
4902 | 4 |
5 This file is part of Octave. | |
6 | |
7 Octave is free software; you can redistribute it and/or modify it | |
8 under the terms of the GNU General Public License as published by the | |
7016 | 9 Free Software Foundation; either version 3 of the License, or (at your |
10 option) any later version. | |
4902 | 11 |
12 Octave is distributed in the hope that it will be useful, but WITHOUT | |
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
7016 | 18 along with Octave; see the file COPYING. If not, see |
19 <http://www.gnu.org/licenses/>. | |
4902 | 20 |
21 */ | |
22 | |
23 #if !defined (octave_inttypes_h) | |
24 #define octave_inttypes_h 1 | |
25 | |
6482 | 26 #include <climits> |
27 | |
4902 | 28 #include <limits> |
29 #include <iostream> | |
30 | |
5828 | 31 #include "oct-types.h" |
4953 | 32 #include "lo-ieee.h" |
4969 | 33 #include "lo-mappers.h" |
4902 | 34 |
35 template <class T1, class T2> | |
36 class | |
37 octave_int_binop_traits | |
38 { | |
39 public: | |
40 // The return type for a T1 by T2 binary operation. | |
41 typedef T1 TR; | |
42 }; | |
43 | |
44 #define OCTAVE_INT_BINOP_TRAIT(T1, T2, T3) \ | |
45 template<> \ | |
46 class octave_int_binop_traits <T1, T2> \ | |
47 { \ | |
48 public: \ | |
49 typedef T3 TR; \ | |
50 } | |
51 | |
5828 | 52 OCTAVE_INT_BINOP_TRAIT (int8_t, int8_t, int8_t); |
53 OCTAVE_INT_BINOP_TRAIT (int8_t, int16_t, int8_t); | |
54 OCTAVE_INT_BINOP_TRAIT (int8_t, int32_t, int8_t); | |
55 OCTAVE_INT_BINOP_TRAIT (int8_t, int64_t, int8_t); | |
56 OCTAVE_INT_BINOP_TRAIT (int8_t, uint8_t, int8_t); | |
57 OCTAVE_INT_BINOP_TRAIT (int8_t, uint16_t, int8_t); | |
58 OCTAVE_INT_BINOP_TRAIT (int8_t, uint32_t, int8_t); | |
59 OCTAVE_INT_BINOP_TRAIT (int8_t, uint64_t, int8_t); | |
4902 | 60 |
5828 | 61 OCTAVE_INT_BINOP_TRAIT (int16_t, int8_t, int16_t); |
62 OCTAVE_INT_BINOP_TRAIT (int16_t, int16_t, int16_t); | |
63 OCTAVE_INT_BINOP_TRAIT (int16_t, int32_t, int16_t); | |
64 OCTAVE_INT_BINOP_TRAIT (int16_t, int64_t, int16_t); | |
65 OCTAVE_INT_BINOP_TRAIT (int16_t, uint8_t, int16_t); | |
66 OCTAVE_INT_BINOP_TRAIT (int16_t, uint16_t, int16_t); | |
67 OCTAVE_INT_BINOP_TRAIT (int16_t, uint32_t, int16_t); | |
68 OCTAVE_INT_BINOP_TRAIT (int16_t, uint64_t, int16_t); | |
4902 | 69 |
5828 | 70 OCTAVE_INT_BINOP_TRAIT (int32_t, int8_t, int32_t); |
71 OCTAVE_INT_BINOP_TRAIT (int32_t, int16_t, int32_t); | |
72 OCTAVE_INT_BINOP_TRAIT (int32_t, int32_t, int32_t); | |
73 OCTAVE_INT_BINOP_TRAIT (int32_t, int64_t, int32_t); | |
74 OCTAVE_INT_BINOP_TRAIT (int32_t, uint8_t, int32_t); | |
75 OCTAVE_INT_BINOP_TRAIT (int32_t, uint16_t, int32_t); | |
76 OCTAVE_INT_BINOP_TRAIT (int32_t, uint32_t, int32_t); | |
77 OCTAVE_INT_BINOP_TRAIT (int32_t, uint64_t, int32_t); | |
4902 | 78 |
5828 | 79 OCTAVE_INT_BINOP_TRAIT (int64_t, int8_t, int64_t); |
80 OCTAVE_INT_BINOP_TRAIT (int64_t, int16_t, int64_t); | |
81 OCTAVE_INT_BINOP_TRAIT (int64_t, int32_t, int64_t); | |
82 OCTAVE_INT_BINOP_TRAIT (int64_t, int64_t, int64_t); | |
83 OCTAVE_INT_BINOP_TRAIT (int64_t, uint8_t, int64_t); | |
84 OCTAVE_INT_BINOP_TRAIT (int64_t, uint16_t, int64_t); | |
85 OCTAVE_INT_BINOP_TRAIT (int64_t, uint32_t, int64_t); | |
86 OCTAVE_INT_BINOP_TRAIT (int64_t, uint64_t, int64_t); | |
4902 | 87 |
5828 | 88 OCTAVE_INT_BINOP_TRAIT (uint8_t, int8_t, int8_t); |
89 OCTAVE_INT_BINOP_TRAIT (uint8_t, int16_t, int8_t); | |
90 OCTAVE_INT_BINOP_TRAIT (uint8_t, int32_t, int8_t); | |
91 OCTAVE_INT_BINOP_TRAIT (uint8_t, int64_t, int8_t); | |
92 OCTAVE_INT_BINOP_TRAIT (uint8_t, uint8_t, uint8_t); | |
93 OCTAVE_INT_BINOP_TRAIT (uint8_t, uint16_t, uint8_t); | |
94 OCTAVE_INT_BINOP_TRAIT (uint8_t, uint32_t, uint8_t); | |
95 OCTAVE_INT_BINOP_TRAIT (uint8_t, uint64_t, uint8_t); | |
4902 | 96 |
5828 | 97 OCTAVE_INT_BINOP_TRAIT (uint16_t, int8_t, int16_t); |
98 OCTAVE_INT_BINOP_TRAIT (uint16_t, int16_t, int16_t); | |
99 OCTAVE_INT_BINOP_TRAIT (uint16_t, int32_t, int16_t); | |
100 OCTAVE_INT_BINOP_TRAIT (uint16_t, int64_t, int16_t); | |
101 OCTAVE_INT_BINOP_TRAIT (uint16_t, uint8_t, uint16_t); | |
102 OCTAVE_INT_BINOP_TRAIT (uint16_t, uint16_t, uint16_t); | |
103 OCTAVE_INT_BINOP_TRAIT (uint16_t, uint32_t, uint16_t); | |
104 OCTAVE_INT_BINOP_TRAIT (uint16_t, uint64_t, uint16_t); | |
4902 | 105 |
5828 | 106 OCTAVE_INT_BINOP_TRAIT (uint32_t, int8_t, int32_t); |
107 OCTAVE_INT_BINOP_TRAIT (uint32_t, int16_t, int32_t); | |
108 OCTAVE_INT_BINOP_TRAIT (uint32_t, int32_t, int32_t); | |
109 OCTAVE_INT_BINOP_TRAIT (uint32_t, int64_t, int32_t); | |
110 OCTAVE_INT_BINOP_TRAIT (uint32_t, uint8_t, uint32_t); | |
111 OCTAVE_INT_BINOP_TRAIT (uint32_t, uint16_t, uint32_t); | |
112 OCTAVE_INT_BINOP_TRAIT (uint32_t, uint32_t, uint32_t); | |
113 OCTAVE_INT_BINOP_TRAIT (uint32_t, uint64_t, uint32_t); | |
4902 | 114 |
5828 | 115 OCTAVE_INT_BINOP_TRAIT (uint64_t, int8_t, int64_t); |
116 OCTAVE_INT_BINOP_TRAIT (uint64_t, int16_t, int64_t); | |
117 OCTAVE_INT_BINOP_TRAIT (uint64_t, int32_t, int64_t); | |
118 OCTAVE_INT_BINOP_TRAIT (uint64_t, int64_t, int64_t); | |
119 OCTAVE_INT_BINOP_TRAIT (uint64_t, uint8_t, uint64_t); | |
120 OCTAVE_INT_BINOP_TRAIT (uint64_t, uint16_t, uint64_t); | |
121 OCTAVE_INT_BINOP_TRAIT (uint64_t, uint32_t, uint64_t); | |
122 OCTAVE_INT_BINOP_TRAIT (uint64_t, uint64_t, uint64_t); | |
4902 | 123 |
124 template <class T1, class T2> | |
125 inline T2 | |
126 octave_int_fit_to_range (const T1& x, const T2& mn, const T2& mx) | |
127 { | |
4963 | 128 return (x > mx ? mx : (x < mn ? mn : T2 (x))); |
4902 | 129 } |
130 | |
4943 | 131 // If X is unsigned and the new type is signed, then we only have to |
132 // check the upper limit, but we should cast the maximum value of the | |
133 // new type to an unsigned type before performing the comparison. | |
134 // This should always be OK because the maximum value should always be | |
135 // positive. | |
136 | |
5072 | 137 #define OCTAVE_US_S_FTR(T1, T2, TC) \ |
4943 | 138 template <> \ |
139 inline T2 \ | |
140 octave_int_fit_to_range<T1, T2> (const T1& x, const T2&, const T2& mx) \ | |
141 { \ | |
142 return x > static_cast<TC> (mx) ? mx : x; \ | |
143 } | |
144 | |
5072 | 145 #define OCTAVE_US_S_FTR_FCNS(T) \ |
146 OCTAVE_US_S_FTR (T, char, unsigned char) \ | |
147 OCTAVE_US_S_FTR (T, signed char, unsigned char) \ | |
148 OCTAVE_US_S_FTR (T, short, unsigned short) \ | |
149 OCTAVE_US_S_FTR (T, int, unsigned int) \ | |
150 OCTAVE_US_S_FTR (T, long, unsigned long) \ | |
151 OCTAVE_US_S_FTR (T, long long, unsigned long long) | |
4943 | 152 |
5072 | 153 OCTAVE_US_S_FTR_FCNS (unsigned char) |
154 OCTAVE_US_S_FTR_FCNS (unsigned short) | |
155 OCTAVE_US_S_FTR_FCNS (unsigned int) | |
156 OCTAVE_US_S_FTR_FCNS (unsigned long) | |
157 OCTAVE_US_S_FTR_FCNS (unsigned long long) | |
4943 | 158 |
159 // If X is signed and the new type is unsigned, then we only have to | |
160 // check the lower limit (which will always be 0 for an unsigned | |
161 // type). The upper limit will be enforced correctly by converting to | |
162 // the new type, even if the type of X is wider than the new type. | |
163 | |
5072 | 164 #define OCTAVE_S_US_FTR(T1, T2) \ |
4943 | 165 template <> \ |
166 inline T2 \ | |
167 octave_int_fit_to_range<T1, T2> (const T1& x, const T2&, const T2&) \ | |
168 { \ | |
5420 | 169 return x <= 0 ? 0 : x; \ |
4943 | 170 } |
171 | |
5072 | 172 #define OCTAVE_S_US_FTR_FCNS(T) \ |
173 OCTAVE_S_US_FTR (T, unsigned char) \ | |
174 OCTAVE_S_US_FTR (T, unsigned short) \ | |
175 OCTAVE_S_US_FTR (T, unsigned int) \ | |
176 OCTAVE_S_US_FTR (T, unsigned long) \ | |
177 OCTAVE_S_US_FTR (T, unsigned long long) | |
4943 | 178 |
5072 | 179 OCTAVE_S_US_FTR_FCNS (char) |
180 OCTAVE_S_US_FTR_FCNS (signed char) | |
181 OCTAVE_S_US_FTR_FCNS (short) | |
182 OCTAVE_S_US_FTR_FCNS (int) | |
183 OCTAVE_S_US_FTR_FCNS (long) | |
184 OCTAVE_S_US_FTR_FCNS (long long) | |
4943 | 185 |
4902 | 186 #define OCTAVE_INT_FIT_TO_RANGE(r, T) \ |
4943 | 187 octave_int_fit_to_range (r, \ |
188 std::numeric_limits<T>::min (), \ | |
189 std::numeric_limits<T>::max ()) | |
4902 | 190 |
191 #define OCTAVE_INT_MIN_VAL2(T1, T2) \ | |
192 std::numeric_limits<typename octave_int_binop_traits<T1, T2>::TR>::min () | |
193 | |
194 #define OCTAVE_INT_MAX_VAL2(T1, T2) \ | |
195 std::numeric_limits<typename octave_int_binop_traits<T1, T2>::TR>::max () | |
196 | |
197 #define OCTAVE_INT_FIT_TO_RANGE2(r, T1, T2) \ | |
198 octave_int_fit_to_range (r, \ | |
199 OCTAVE_INT_MIN_VAL2 (T1, T2), \ | |
200 OCTAVE_INT_MAX_VAL2 (T1, T2)) | |
201 | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
202 // By using these classes/functions we avoid warnings from GCC about |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
203 // comparisons always being false due to limited range of data type. |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
204 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
205 // FIXME -- it would be nice to nest the helper class inside the |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
206 // octave_int class, but I don't see the magic for that at the moment. |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
207 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
208 template <class T> class octave_int; |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
209 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
210 template <class T, bool is_signed> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
211 class octave_int_helper |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
212 { |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
213 public: |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
214 static octave_int<T> abs (const T& x); |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
215 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
216 static octave_int<T> signum (const T& x); |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
217 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
218 template <class T2> static void rshift_eq (T& ival, const T2& x); |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
219 }; |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
220 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
221 template <class T> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
222 class octave_int_helper<T, false> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
223 { |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
224 public: |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
225 static octave_int<T> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
226 abs (const T& x) { return x; } |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
227 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
228 static octave_int<T> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
229 signum (const T& x) { return x > 0 ? 1 : 0; } |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
230 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
231 template <class T2> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
232 static void |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
233 rshift_eq (T& ival, const T2& x) { ival = ival >> x; } |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
234 }; |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
235 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
236 template <class T> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
237 class octave_int_helper<T, true> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
238 { |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
239 public: |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
240 static octave_int<T> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
241 abs (const T& x) { return x < 0 ? -x : x; } |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
242 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
243 static octave_int<T> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
244 signum (const T& x) { return x < 0 ? -1 : (x > 0 ? 1 : 0); } |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
245 |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
246 template <class T2> |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
247 static void |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
248 rshift_eq (T& ival, const T2& x) |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
249 { |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
250 if (ival < 0) |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
251 ival = - (((-ival) >> x) & std::numeric_limits<T>::max()); |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
252 else |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
253 ival = ival >> x; |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
254 } |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
255 }; |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
256 |
4902 | 257 template <class T> |
258 class | |
259 octave_int | |
260 { | |
261 public: | |
262 | |
4943 | 263 typedef T val_type; |
264 | |
4902 | 265 octave_int (void) : ival () { } |
266 | |
267 template <class U> | |
268 octave_int (U i) : ival (OCTAVE_INT_FIT_TO_RANGE (i, T)) { } | |
269 | |
6402 | 270 octave_int (double d) : ival (OCTAVE_INT_FIT_TO_RANGE (xround (d), T)) { } |
271 | |
4902 | 272 octave_int (bool b) : ival (b) { } |
273 | |
274 template <class U> | |
275 octave_int (const octave_int<U>& i) | |
276 : ival (OCTAVE_INT_FIT_TO_RANGE (i.value (), T)) { } | |
277 | |
278 octave_int (const octave_int<T>& i) : ival (i.ival) { } | |
279 | |
280 octave_int& operator = (const octave_int<T>& i) | |
281 { | |
282 ival = i.ival; | |
283 return *this; | |
284 } | |
285 | |
286 ~octave_int (void) { } | |
287 | |
288 T value (void) const { return ival; } | |
289 | |
4949 | 290 const unsigned char * iptr (void) const |
291 { return reinterpret_cast<const unsigned char *> (& ival); } | |
292 | |
4902 | 293 bool operator ! (void) const { return ! ival; } |
294 | |
4906 | 295 octave_int<T> operator + (void) const { return *this; } |
4902 | 296 |
4906 | 297 octave_int<T> operator - (void) const |
4902 | 298 { |
4953 | 299 // Can't just return -ival because signed types are not |
300 // symmetric, which causes things like -intmin("int32") to be the | |
301 // same as intmin("int32") instead of intmax("int32") (which is | |
302 // what we should get with saturation semantics). | |
303 | |
304 return std::numeric_limits<T>::is_signed ? | |
305 OCTAVE_INT_FIT_TO_RANGE (- static_cast<double> (ival), T) : 0; | |
4902 | 306 } |
307 | |
7198 | 308 bool bool_value (void) const { return static_cast<bool> (value ()); } |
309 | |
310 char char_value (void) const { return static_cast<char> (value ()); } | |
311 | |
312 double double_value (void) const { return static_cast<double> (value ()); } | |
313 | |
314 float float_value (void) const { return static_cast<float> (value ()); } | |
315 | |
7177 | 316 operator T (void) const { return value (); } |
317 | |
7198 | 318 // char and bool operators intentionally omitted. |
5533 | 319 |
7198 | 320 operator double (void) const { return double_value (); } |
4902 | 321 |
7198 | 322 operator float (void) const { return float_value (); } |
5030 | 323 |
4902 | 324 octave_int<T>& operator += (const octave_int<T>& x) |
325 { | |
326 double t = static_cast<double> (value ()); | |
327 double tx = static_cast<double> (x.value ()); | |
328 ival = OCTAVE_INT_FIT_TO_RANGE (t + tx, T); | |
329 return *this; | |
330 } | |
331 | |
332 octave_int<T>& operator -= (const octave_int<T>& x) | |
333 { | |
334 double t = static_cast<double> (value ()); | |
335 double tx = static_cast<double> (x.value ()); | |
336 ival = OCTAVE_INT_FIT_TO_RANGE (t - tx, T); | |
337 return *this; | |
338 } | |
339 | |
4952 | 340 octave_int<T>& operator *= (const octave_int<T>& x) |
341 { | |
342 double t = static_cast<double> (value ()); | |
343 double tx = static_cast<double> (x.value ()); | |
344 ival = OCTAVE_INT_FIT_TO_RANGE (t * tx, T); | |
345 return *this; | |
346 } | |
347 | |
348 octave_int<T>& operator /= (const octave_int<T>& x) | |
349 { | |
350 double t = static_cast<double> (value ()); | |
351 double tx = static_cast<double> (x.value ()); | |
4968 | 352 double r = (t == 0 && tx == 0) ? 0 : xround (t / tx); |
4953 | 353 ival = OCTAVE_INT_FIT_TO_RANGE (r, T); |
4952 | 354 return *this; |
355 } | |
356 | |
357 template <class T2> | |
358 octave_int<T>& operator <<= (const T2& x) | |
359 { | |
6764 | 360 ival = ival << x; |
4952 | 361 return *this; |
362 } | |
363 | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
364 // Use helper functions in the operator >>=, abs, and signum |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
365 // functions to avoid "comparison of unsigned expression < 0 is |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
366 // always false" warnings from GCC when instantiating these funtions |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
367 // for unsigned types. |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
368 |
4952 | 369 template <class T2> |
370 octave_int<T>& operator >>= (const T2& x) | |
371 { | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
372 octave_int_helper<T, std::numeric_limits<T>::is_signed>::rshift_eq (ival, x); |
4952 | 373 return *this; |
374 } | |
375 | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
376 octave_int<T> abs (void) const |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
377 { |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
378 return octave_int_helper<T, std::numeric_limits<T>::is_signed>::abs (value ()); |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
379 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
380 |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
381 octave_int<T> signum (void) const |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
382 { |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
383 return octave_int_helper<T, std::numeric_limits<T>::is_signed>::signum (value ()); |
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
384 } |
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
385 |
4906 | 386 octave_int<T> min (void) const { return std::numeric_limits<T>::min (); } |
387 octave_int<T> max (void) const { return std::numeric_limits<T>::max (); } | |
388 | |
4919 | 389 static int nbits (void) { return sizeof (T) * CHAR_BIT; } |
4909 | 390 |
4949 | 391 static int byte_size (void) { return sizeof(T); } |
392 | |
5900 | 393 // Unsafe. This function exists to support the MEX interface. |
394 // You should not use it anywhere else. | |
395 void *mex_get_data (void) const { return const_cast<T *> (&ival); } | |
396 | |
4902 | 397 private: |
398 | |
399 T ival; | |
400 }; | |
401 | |
402 template <class T> | |
4953 | 403 octave_int<T> |
404 pow (const octave_int<T>& a, const octave_int<T>& b) | |
4952 | 405 { |
4953 | 406 octave_int<T> retval; |
4952 | 407 |
4953 | 408 octave_int<T> zero = octave_int<T> (0); |
409 octave_int<T> one = octave_int<T> (1); | |
4952 | 410 |
411 if (b == zero) | |
412 retval = one; | |
413 else if (b < zero) | |
414 retval = zero; | |
415 else | |
416 { | |
4953 | 417 octave_int<T> a_val = a; |
418 octave_int<T> b_val = b; | |
4952 | 419 |
420 retval = a; | |
421 | |
422 b_val -= 1; | |
423 | |
5030 | 424 while (b_val != zero) |
4952 | 425 { |
5030 | 426 if ((b_val & one) != zero) |
4952 | 427 retval = retval * a_val; |
428 | |
429 b_val = b_val >> 1; | |
430 | |
431 if (b_val > zero) | |
432 a_val = a_val * a_val; | |
433 } | |
434 } | |
435 | |
436 return retval; | |
437 } | |
438 | |
439 template <class T> | |
4953 | 440 octave_int<T> |
441 pow (double a, const octave_int<T>& b) | |
442 { | |
443 double tb = static_cast<double> (b.value ()); | |
444 double r = pow (a, tb); | |
4968 | 445 r = lo_ieee_isnan (r) ? 0 : xround (r); |
4953 | 446 return OCTAVE_INT_FIT_TO_RANGE (r, T); |
447 } | |
448 | |
449 template <class T> | |
450 octave_int<T> | |
451 pow (const octave_int<T>& a, double b) | |
452 { | |
453 double ta = static_cast<double> (a.value ()); | |
454 double r = pow (ta, b); | |
4968 | 455 r = lo_ieee_isnan (r) ? 0 : xround (r); |
4953 | 456 return OCTAVE_INT_FIT_TO_RANGE (r, T); |
457 } | |
458 | |
459 template <class T> | |
4902 | 460 std::ostream& |
461 operator << (std::ostream& os, const octave_int<T>& ival) | |
462 { | |
463 os << ival.value (); | |
464 return os; | |
465 } | |
466 | |
467 template <class T> | |
468 std::istream& | |
469 operator >> (std::istream& is, octave_int<T>& ival) | |
470 { | |
471 T tmp = 0; | |
472 is >> tmp; | |
473 ival = tmp; | |
474 return is; | |
475 } | |
476 | |
5828 | 477 typedef octave_int<int8_t> octave_int8; |
478 typedef octave_int<int16_t> octave_int16; | |
479 typedef octave_int<int32_t> octave_int32; | |
480 typedef octave_int<int64_t> octave_int64; | |
4902 | 481 |
5828 | 482 typedef octave_int<uint8_t> octave_uint8; |
483 typedef octave_int<uint16_t> octave_uint16; | |
484 typedef octave_int<uint32_t> octave_uint32; | |
485 typedef octave_int<uint64_t> octave_uint64; | |
4902 | 486 |
487 #define OCTAVE_INT_BIN_OP(OP) \ | |
488 template <class T1, class T2> \ | |
489 octave_int<typename octave_int_binop_traits<T1, T2>::TR> \ | |
490 operator OP (const octave_int<T1>& x, const octave_int<T2>& y) \ | |
491 { \ | |
492 double tx = static_cast<double> (x.value ()); \ | |
493 double ty = static_cast<double> (y.value ()); \ | |
494 double r = tx OP ty; \ | |
495 return OCTAVE_INT_FIT_TO_RANGE2 (r, T1, T2); \ | |
4906 | 496 } |
4902 | 497 |
498 OCTAVE_INT_BIN_OP(+) | |
499 OCTAVE_INT_BIN_OP(-) | |
500 OCTAVE_INT_BIN_OP(*) | |
4953 | 501 |
502 template <class T1, class T2> | |
503 octave_int<typename octave_int_binop_traits<T1, T2>::TR> | |
504 operator / (const octave_int<T1>& x, const octave_int<T2>& y) | |
505 { | |
506 double tx = static_cast<double> (x.value ()); | |
507 double ty = static_cast<double> (y.value ()); | |
6402 | 508 double r = (tx == 0 && ty == 0) ? 0 : xround (tx / ty); |
4953 | 509 return OCTAVE_INT_FIT_TO_RANGE2 (r, T1, T2); |
510 } | |
511 | |
512 #define OCTAVE_INT_DOUBLE_BIN_OP(OP) \ | |
513 template <class T> \ | |
514 octave_int<T> \ | |
515 operator OP (const octave_int<T>& x, double y) \ | |
516 { \ | |
517 double tx = static_cast<double> (x.value ()); \ | |
4968 | 518 double r = xround (tx OP y); \ |
519 r = lo_ieee_isnan (r) ? 0 : xround (r); \ | |
4953 | 520 return OCTAVE_INT_FIT_TO_RANGE (r, T); \ |
521 } | |
522 | |
523 OCTAVE_INT_DOUBLE_BIN_OP(+) | |
524 OCTAVE_INT_DOUBLE_BIN_OP(-) | |
525 OCTAVE_INT_DOUBLE_BIN_OP(*) | |
526 OCTAVE_INT_DOUBLE_BIN_OP(/) | |
527 | |
528 #define OCTAVE_DOUBLE_INT_BIN_OP(OP) \ | |
529 template <class T> \ | |
530 octave_int<T> \ | |
531 operator OP (double x, const octave_int<T>& y) \ | |
532 { \ | |
533 double ty = static_cast<double> (y.value ()); \ | |
534 double r = x OP ty; \ | |
4968 | 535 r = lo_ieee_isnan (r) ? 0 : xround (r); \ |
4953 | 536 return OCTAVE_INT_FIT_TO_RANGE (r, T); \ |
537 } | |
538 | |
539 OCTAVE_DOUBLE_INT_BIN_OP(+) | |
540 OCTAVE_DOUBLE_INT_BIN_OP(-) | |
541 OCTAVE_DOUBLE_INT_BIN_OP(*) | |
542 OCTAVE_DOUBLE_INT_BIN_OP(/) | |
4902 | 543 |
5029 | 544 #define OCTAVE_INT_DOUBLE_CMP_OP(OP) \ |
545 template <class T> \ | |
546 bool \ | |
547 operator OP (const octave_int<T>& x, const double& y) \ | |
548 { \ | |
549 double tx = static_cast<double> (x.value ()); \ | |
5030 | 550 return tx OP y; \ |
5029 | 551 } |
552 | |
553 OCTAVE_INT_DOUBLE_CMP_OP (<) | |
554 OCTAVE_INT_DOUBLE_CMP_OP (<=) | |
555 OCTAVE_INT_DOUBLE_CMP_OP (>=) | |
556 OCTAVE_INT_DOUBLE_CMP_OP (>) | |
557 OCTAVE_INT_DOUBLE_CMP_OP (==) | |
558 OCTAVE_INT_DOUBLE_CMP_OP (!=) | |
559 | |
560 #define OCTAVE_DOUBLE_INT_CMP_OP(OP) \ | |
561 template <class T> \ | |
562 bool \ | |
563 operator OP (const double& x, const octave_int<T>& y) \ | |
564 { \ | |
565 double ty = static_cast<double> (y.value ()); \ | |
5030 | 566 return x OP ty; \ |
5029 | 567 } |
568 | |
569 OCTAVE_DOUBLE_INT_CMP_OP (<) | |
570 OCTAVE_DOUBLE_INT_CMP_OP (<=) | |
571 OCTAVE_DOUBLE_INT_CMP_OP (>=) | |
572 OCTAVE_DOUBLE_INT_CMP_OP (>) | |
573 OCTAVE_DOUBLE_INT_CMP_OP (==) | |
574 OCTAVE_DOUBLE_INT_CMP_OP (!=) | |
575 | |
4906 | 576 #define OCTAVE_INT_BITCMP_OP(OP) \ |
577 template <class T> \ | |
578 octave_int<T> \ | |
579 operator OP (const octave_int<T>& x, const octave_int<T>& y) \ | |
580 { \ | |
581 return x.value () OP y.value (); \ | |
582 } | |
583 | |
584 OCTAVE_INT_BITCMP_OP (&) | |
585 OCTAVE_INT_BITCMP_OP (|) | |
586 OCTAVE_INT_BITCMP_OP (^) | |
587 | |
4952 | 588 template <class T1, class T2> |
589 octave_int<T1> | |
590 operator << (const octave_int<T1>& x, const T2& y) | |
591 { | |
5030 | 592 octave_int<T1> retval = x; |
4952 | 593 return retval <<= y; |
594 } | |
4906 | 595 |
4952 | 596 template <class T1, class T2> |
597 octave_int<T1> | |
598 operator >> (const octave_int<T1>& x, const T2& y) | |
599 { | |
5030 | 600 octave_int<T1> retval = x; |
4952 | 601 return retval >>= y; |
602 } | |
4906 | 603 |
4909 | 604 template <class T> |
605 octave_int<T> | |
4920 | 606 bitshift (const octave_int<T>& a, int n, |
607 const octave_int<T>& mask = std::numeric_limits<T>::max ()) | |
4909 | 608 { |
609 if (n > 0) | |
4952 | 610 return (a << n) & mask; |
4909 | 611 else if (n < 0) |
4952 | 612 return (a >> -n) & mask; |
4909 | 613 else |
614 return a; | |
615 } | |
616 | |
4902 | 617 #define OCTAVE_INT_CMP_OP(OP) \ |
618 template <class T1, class T2> \ | |
619 bool \ | |
620 operator OP (const octave_int<T1>& x, const octave_int<T2>& y) \ | |
621 { \ | |
5072 | 622 return x.value () OP y.value (); \ |
4906 | 623 } |
4902 | 624 |
625 OCTAVE_INT_CMP_OP (<) | |
626 OCTAVE_INT_CMP_OP (<=) | |
627 OCTAVE_INT_CMP_OP (>=) | |
628 OCTAVE_INT_CMP_OP (>) | |
629 OCTAVE_INT_CMP_OP (==) | |
630 OCTAVE_INT_CMP_OP (!=) | |
631 | |
5072 | 632 // The following apply if the unsigned type is at least as wide as the |
633 // signed type (then we can cast postive signed values to the unsigned | |
634 // type and compare). | |
635 | |
636 #define OCTAVE_US_TYPE1_CMP_OP_DECL(OP, LTZ_VAL, UT, ST) \ | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
637 template <> \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
638 bool \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
639 OCTAVE_API operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs); |
5072 | 640 |
641 #define OCTAVE_US_TYPE1_CMP_OP_DECLS(UT, ST) \ | |
642 OCTAVE_US_TYPE1_CMP_OP_DECL (<, false, UT, ST) \ | |
643 OCTAVE_US_TYPE1_CMP_OP_DECL (<=, false, UT, ST) \ | |
644 OCTAVE_US_TYPE1_CMP_OP_DECL (>=, true, UT, ST) \ | |
645 OCTAVE_US_TYPE1_CMP_OP_DECL (>, true, UT, ST) \ | |
646 OCTAVE_US_TYPE1_CMP_OP_DECL (==, false, UT, ST) \ | |
647 OCTAVE_US_TYPE1_CMP_OP_DECL (!=, true, UT, ST) | |
648 | |
649 #define OCTAVE_SU_TYPE1_CMP_OP_DECL(OP, LTZ_VAL, ST, UT) \ | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
650 template <> \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
651 bool \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
652 OCTAVE_API operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs); |
5072 | 653 |
654 #define OCTAVE_SU_TYPE1_CMP_OP_DECLS(ST, UT) \ | |
655 OCTAVE_SU_TYPE1_CMP_OP_DECL (<, true, ST, UT) \ | |
656 OCTAVE_SU_TYPE1_CMP_OP_DECL (<=, true, ST, UT) \ | |
657 OCTAVE_SU_TYPE1_CMP_OP_DECL (>=, false, ST, UT) \ | |
658 OCTAVE_SU_TYPE1_CMP_OP_DECL (>, false, ST, UT) \ | |
659 OCTAVE_SU_TYPE1_CMP_OP_DECL (==, false, ST, UT) \ | |
660 OCTAVE_SU_TYPE1_CMP_OP_DECL (!=, true, ST, UT) | |
661 | |
662 #define OCTAVE_TYPE1_CMP_OP_DECLS(UT, ST) \ | |
663 OCTAVE_US_TYPE1_CMP_OP_DECLS (UT, ST) \ | |
664 OCTAVE_SU_TYPE1_CMP_OP_DECLS (ST, UT) | |
665 | |
5828 | 666 OCTAVE_TYPE1_CMP_OP_DECLS (uint32_t, int8_t) |
667 OCTAVE_TYPE1_CMP_OP_DECLS (uint32_t, int16_t) | |
668 OCTAVE_TYPE1_CMP_OP_DECLS (uint32_t, int32_t) | |
5072 | 669 |
5828 | 670 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int8_t) |
671 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int16_t) | |
672 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int32_t) | |
673 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int64_t) | |
5072 | 674 |
675 // The following apply if the signed type is wider than the unsigned | |
676 // type (then we can cast unsigned values to the signed type and | |
677 // compare if the signed value is positive). | |
678 | |
679 #define OCTAVE_US_TYPE2_CMP_OP_DECL(OP, LTZ_VAL, UT, ST) \ | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
680 template <> \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
681 bool \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
682 OCTAVE_API operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs); |
5072 | 683 |
684 #define OCTAVE_US_TYPE2_CMP_OP_DECLS(ST, UT) \ | |
685 OCTAVE_US_TYPE2_CMP_OP_DECL (<, false, ST, UT) \ | |
686 OCTAVE_US_TYPE2_CMP_OP_DECL (<=, false, ST, UT) \ | |
687 OCTAVE_US_TYPE2_CMP_OP_DECL (>=, true, ST, UT) \ | |
688 OCTAVE_US_TYPE2_CMP_OP_DECL (>, true, ST, UT) \ | |
689 OCTAVE_US_TYPE2_CMP_OP_DECL (==, false, ST, UT) \ | |
690 OCTAVE_US_TYPE2_CMP_OP_DECL (!=, true, ST, UT) | |
691 | |
692 #define OCTAVE_SU_TYPE2_CMP_OP_DECL(OP, LTZ_VAL, ST, UT) \ | |
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
693 template <> \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
694 bool \ |
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
695 OCTAVE_API operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs); |
5072 | 696 |
697 #define OCTAVE_SU_TYPE2_CMP_OP_DECLS(ST, UT) \ | |
698 OCTAVE_SU_TYPE2_CMP_OP_DECL (<, true, ST, UT) \ | |
699 OCTAVE_SU_TYPE2_CMP_OP_DECL (<=, true, ST, UT) \ | |
700 OCTAVE_SU_TYPE2_CMP_OP_DECL (>=, false, ST, UT) \ | |
701 OCTAVE_SU_TYPE2_CMP_OP_DECL (>, false, ST, UT) \ | |
702 OCTAVE_SU_TYPE2_CMP_OP_DECL (==, false, ST, UT) \ | |
703 OCTAVE_SU_TYPE2_CMP_OP_DECL (!=, true, ST, UT) | |
704 | |
705 #define OCTAVE_TYPE2_CMP_OP_DECLS(UT, ST) \ | |
706 OCTAVE_US_TYPE2_CMP_OP_DECLS (UT, ST) \ | |
707 OCTAVE_SU_TYPE2_CMP_OP_DECLS (ST, UT) | |
708 | |
5828 | 709 OCTAVE_TYPE2_CMP_OP_DECLS (uint32_t, int64_t) |
5072 | 710 |
4902 | 711 #undef OCTAVE_INT_BINOP_TRAIT |
5072 | 712 #undef OCTAVE_US_S_FTR |
713 #undef OCTAVE_US_S_FTR_FCNS | |
714 #undef OCTAVE_S_US_FTR | |
715 #undef OCTAVE_S_US_FTR_FCNS | |
4902 | 716 #undef OCTAVE_INT_FIT_TO_RANGE |
717 #undef OCTAVE_INT_MIN_VAL2 | |
718 #undef OCTAVE_INT_MAX_VAL2 | |
719 #undef OCTAVE_INT_FIT_TO_RANGE2 | |
720 #undef OCTAVE_INT_BIN_OP | |
5072 | 721 #undef OCTAVE_INT_DOUBLE_BIN_OP |
722 #undef OCTAVE_DOUBLE_INT_BIN_OP | |
723 #undef OCTAVE_INT_DOUBLE_CMP_OP | |
724 #undef OCTAVE_DOUBLE_INT_CMP_OP | |
725 #undef OCTAVE_INT_BITCMP_OP | |
4902 | 726 #undef OCTAVE_INT_CMP_OP |
5072 | 727 #undef OCTAVE_US_TYPE1_CMP_OP_DECL |
728 #undef OCTAVE_US_TYPE1_CMP_OP_DECLS | |
729 #undef OCTAVE_SU_TYPE1_CMP_OP_DECL | |
730 #undef OCTAVE_SU_TYPE1_CMP_OP_DECLS | |
731 #undef OCTAVE_TYPE1_CMP_OP_DECLS | |
732 #undef OCTAVE_US_TYPE2_CMP_OP_DECL | |
733 #undef OCTAVE_US_TYPE2_CMP_OP_DECLS | |
734 #undef OCTAVE_SU_TYPE2_CMP_OP_DECL | |
735 #undef OCTAVE_SU_TYPE2_CMP_OP_DECLS | |
5074 | 736 #undef OCTAVE_TYPE2_CMP_OP_DECLS |
4902 | 737 |
738 #endif | |
739 | |
740 /* | |
741 ;;; Local Variables: *** | |
742 ;;; mode: C++ *** | |
743 ;;; End: *** | |
744 */ |