Mercurial > octave
annotate liboctave/oct-inttypes.h @ 7922:935be827eaf8
error for NaN values in & and | expressions
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Fri, 11 Jul 2008 14:56:30 -0400 |
| parents | 82be108cc558 |
| children | 2b8952e133c9 |
| 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 | |
|
7598
a89b3fa632ee
partial specialization for octave_int_fit_to_range
John W. Eaton <jwe@octave.org>
parents:
7596
diff
changeset
|
131 template <typename T> |
|
a89b3fa632ee
partial specialization for octave_int_fit_to_range
John W. Eaton <jwe@octave.org>
parents:
7596
diff
changeset
|
132 inline T |
|
a89b3fa632ee
partial specialization for octave_int_fit_to_range
John W. Eaton <jwe@octave.org>
parents:
7596
diff
changeset
|
133 octave_int_fit_to_range (const double& x, const T& mn, const T& mx) |
|
a89b3fa632ee
partial specialization for octave_int_fit_to_range
John W. Eaton <jwe@octave.org>
parents:
7596
diff
changeset
|
134 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
135 return (__lo_ieee_isnan (x) ? 0 : (x > mx ? mx : (x < mn ? mn : static_cast<T> (x)))); |
|
7598
a89b3fa632ee
partial specialization for octave_int_fit_to_range
John W. Eaton <jwe@octave.org>
parents:
7596
diff
changeset
|
136 } |
|
7596
6929e40fc597
compatible handling of NaN -> int conversions
John W. Eaton <jwe@octave.org>
parents:
7534
diff
changeset
|
137 |
| 4943 | 138 // If X is unsigned and the new type is signed, then we only have to |
| 139 // check the upper limit, but we should cast the maximum value of the | |
| 140 // new type to an unsigned type before performing the comparison. | |
| 141 // This should always be OK because the maximum value should always be | |
| 142 // positive. | |
| 143 | |
| 5072 | 144 #define OCTAVE_US_S_FTR(T1, T2, TC) \ |
| 4943 | 145 template <> \ |
| 146 inline T2 \ | |
| 147 octave_int_fit_to_range<T1, T2> (const T1& x, const T2&, const T2& mx) \ | |
| 148 { \ | |
| 149 return x > static_cast<TC> (mx) ? mx : x; \ | |
| 150 } | |
| 151 | |
| 5072 | 152 #define OCTAVE_US_S_FTR_FCNS(T) \ |
| 153 OCTAVE_US_S_FTR (T, char, unsigned char) \ | |
| 154 OCTAVE_US_S_FTR (T, signed char, unsigned char) \ | |
| 155 OCTAVE_US_S_FTR (T, short, unsigned short) \ | |
| 156 OCTAVE_US_S_FTR (T, int, unsigned int) \ | |
| 157 OCTAVE_US_S_FTR (T, long, unsigned long) \ | |
| 158 OCTAVE_US_S_FTR (T, long long, unsigned long long) | |
| 4943 | 159 |
| 5072 | 160 OCTAVE_US_S_FTR_FCNS (unsigned char) |
| 161 OCTAVE_US_S_FTR_FCNS (unsigned short) | |
| 162 OCTAVE_US_S_FTR_FCNS (unsigned int) | |
| 163 OCTAVE_US_S_FTR_FCNS (unsigned long) | |
| 164 OCTAVE_US_S_FTR_FCNS (unsigned long long) | |
| 4943 | 165 |
| 166 // If X is signed and the new type is unsigned, then we only have to | |
| 167 // check the lower limit (which will always be 0 for an unsigned | |
| 168 // type). The upper limit will be enforced correctly by converting to | |
| 169 // the new type, even if the type of X is wider than the new type. | |
| 170 | |
| 5072 | 171 #define OCTAVE_S_US_FTR(T1, T2) \ |
| 4943 | 172 template <> \ |
| 173 inline T2 \ | |
| 174 octave_int_fit_to_range<T1, T2> (const T1& x, const T2&, const T2&) \ | |
| 175 { \ | |
| 5420 | 176 return x <= 0 ? 0 : x; \ |
| 4943 | 177 } |
| 178 | |
| 5072 | 179 #define OCTAVE_S_US_FTR_FCNS(T) \ |
| 180 OCTAVE_S_US_FTR (T, unsigned char) \ | |
| 181 OCTAVE_S_US_FTR (T, unsigned short) \ | |
| 182 OCTAVE_S_US_FTR (T, unsigned int) \ | |
| 183 OCTAVE_S_US_FTR (T, unsigned long) \ | |
| 184 OCTAVE_S_US_FTR (T, unsigned long long) | |
| 4943 | 185 |
| 5072 | 186 OCTAVE_S_US_FTR_FCNS (char) |
| 187 OCTAVE_S_US_FTR_FCNS (signed char) | |
| 188 OCTAVE_S_US_FTR_FCNS (short) | |
| 189 OCTAVE_S_US_FTR_FCNS (int) | |
| 190 OCTAVE_S_US_FTR_FCNS (long) | |
| 191 OCTAVE_S_US_FTR_FCNS (long long) | |
| 4943 | 192 |
| 4902 | 193 #define OCTAVE_INT_FIT_TO_RANGE(r, T) \ |
| 4943 | 194 octave_int_fit_to_range (r, \ |
| 195 std::numeric_limits<T>::min (), \ | |
| 196 std::numeric_limits<T>::max ()) | |
| 4902 | 197 |
| 198 #define OCTAVE_INT_MIN_VAL2(T1, T2) \ | |
| 199 std::numeric_limits<typename octave_int_binop_traits<T1, T2>::TR>::min () | |
| 200 | |
| 201 #define OCTAVE_INT_MAX_VAL2(T1, T2) \ | |
| 202 std::numeric_limits<typename octave_int_binop_traits<T1, T2>::TR>::max () | |
| 203 | |
| 204 #define OCTAVE_INT_FIT_TO_RANGE2(r, T1, T2) \ | |
| 205 octave_int_fit_to_range (r, \ | |
| 206 OCTAVE_INT_MIN_VAL2 (T1, T2), \ | |
| 207 OCTAVE_INT_MAX_VAL2 (T1, T2)) | |
| 208 | |
|
7534
ef755c763b62
avoid more "comparison is always false due to limited range of data type" warnings from GCC
John W. Eaton <jwe@octave.org>
parents:
7521
diff
changeset
|
209 // We have all the machinery below (octave_int_helper) to avoid a few |
|
ef755c763b62
avoid more "comparison is always false due to limited range of data type" warnings from GCC
John W. Eaton <jwe@octave.org>
parents:
7521
diff
changeset
|
210 // warnings from GCC about comparisons always false due to limited |
|
ef755c763b62
avoid more "comparison is always false due to limited range of data type" warnings from GCC
John W. Eaton <jwe@octave.org>
parents:
7521
diff
changeset
|
211 // range of data types. Ugh. The cure may be worse than the disease. |
|
7521
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 // 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
|
214 // 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
|
215 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
216 template <class T> class octave_int; |
|
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 T, bool is_signed> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
219 class octave_int_helper |
|
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 public: |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
222 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
|
223 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
224 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
|
225 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
226 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
|
227 }; |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
228 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
229 template <class T> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
230 class octave_int_helper<T, false> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
231 { |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
232 public: |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
233 static octave_int<T> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
234 abs (const T& x) { return x; } |
|
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 static octave_int<T> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
237 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
|
238 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
239 template <class T2> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
240 static void |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
241 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
|
242 }; |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
243 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
244 template <class T> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
245 class octave_int_helper<T, true> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
246 { |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
247 public: |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
248 static octave_int<T> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
249 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
|
250 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
251 static octave_int<T> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
252 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
|
253 |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
254 template <class T2> |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
255 static void |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
256 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
|
257 { |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
258 if (ival < 0) |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
259 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
|
260 else |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
261 ival = ival >> x; |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
262 } |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
263 }; |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
264 |
| 4902 | 265 template <class T> |
| 266 class | |
| 267 octave_int | |
| 268 { | |
| 269 public: | |
| 270 | |
| 4943 | 271 typedef T val_type; |
| 272 | |
| 4902 | 273 octave_int (void) : ival () { } |
| 274 | |
| 275 template <class U> | |
| 276 octave_int (U i) : ival (OCTAVE_INT_FIT_TO_RANGE (i, T)) { } | |
| 277 | |
| 6402 | 278 octave_int (double d) : ival (OCTAVE_INT_FIT_TO_RANGE (xround (d), T)) { } |
| 279 | |
| 4902 | 280 octave_int (bool b) : ival (b) { } |
| 281 | |
| 282 template <class U> | |
| 283 octave_int (const octave_int<U>& i) | |
| 284 : ival (OCTAVE_INT_FIT_TO_RANGE (i.value (), T)) { } | |
| 285 | |
| 286 octave_int (const octave_int<T>& i) : ival (i.ival) { } | |
| 287 | |
| 288 octave_int& operator = (const octave_int<T>& i) | |
| 289 { | |
| 290 ival = i.ival; | |
| 291 return *this; | |
| 292 } | |
| 293 | |
| 294 ~octave_int (void) { } | |
| 295 | |
| 296 T value (void) const { return ival; } | |
| 297 | |
| 4949 | 298 const unsigned char * iptr (void) const |
| 299 { return reinterpret_cast<const unsigned char *> (& ival); } | |
| 300 | |
| 4902 | 301 bool operator ! (void) const { return ! ival; } |
| 302 | |
| 4906 | 303 octave_int<T> operator + (void) const { return *this; } |
| 4902 | 304 |
| 4906 | 305 octave_int<T> operator - (void) const |
| 4902 | 306 { |
| 4953 | 307 // Can't just return -ival because signed types are not |
| 308 // symmetric, which causes things like -intmin("int32") to be the | |
| 309 // same as intmin("int32") instead of intmax("int32") (which is | |
| 310 // what we should get with saturation semantics). | |
| 311 | |
| 312 return std::numeric_limits<T>::is_signed ? | |
| 313 OCTAVE_INT_FIT_TO_RANGE (- static_cast<double> (ival), T) : 0; | |
| 4902 | 314 } |
| 315 | |
| 7198 | 316 bool bool_value (void) const { return static_cast<bool> (value ()); } |
| 317 | |
| 318 char char_value (void) const { return static_cast<char> (value ()); } | |
| 319 | |
| 320 double double_value (void) const { return static_cast<double> (value ()); } | |
| 321 | |
| 322 float float_value (void) const { return static_cast<float> (value ()); } | |
| 323 | |
| 7177 | 324 operator T (void) const { return value (); } |
| 325 | |
| 7198 | 326 // char and bool operators intentionally omitted. |
| 5533 | 327 |
| 7198 | 328 operator double (void) const { return double_value (); } |
| 4902 | 329 |
| 7198 | 330 operator float (void) const { return float_value (); } |
| 5030 | 331 |
| 4902 | 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 | |
| 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 | |
| 4952 | 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 ()); | |
| 352 ival = OCTAVE_INT_FIT_TO_RANGE (t * tx, T); | |
| 353 return *this; | |
| 354 } | |
| 355 | |
| 356 octave_int<T>& operator /= (const octave_int<T>& x) | |
| 357 { | |
| 358 double t = static_cast<double> (value ()); | |
| 359 double tx = static_cast<double> (x.value ()); | |
| 4968 | 360 double r = (t == 0 && tx == 0) ? 0 : xround (t / tx); |
| 4953 | 361 ival = OCTAVE_INT_FIT_TO_RANGE (r, T); |
| 4952 | 362 return *this; |
| 363 } | |
| 364 | |
| 365 template <class T2> | |
| 366 octave_int<T>& operator <<= (const T2& x) | |
| 367 { | |
| 6764 | 368 ival = ival << x; |
| 4952 | 369 return *this; |
| 370 } | |
| 371 | |
|
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
372 // 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
|
373 // 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
|
374 // 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
|
375 // for unsigned types. |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
376 |
| 4952 | 377 template <class T2> |
| 378 octave_int<T>& operator >>= (const T2& x) | |
| 379 { | |
|
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
380 octave_int_helper<T, std::numeric_limits<T>::is_signed>::rshift_eq (ival, x); |
| 4952 | 381 return *this; |
| 382 } | |
| 383 | |
|
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
384 octave_int<T> abs (void) const |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
385 { |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
386 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
|
387 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
388 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
389 octave_int<T> signum (void) const |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
390 { |
|
7521
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
391 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
|
392 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7198
diff
changeset
|
393 |
| 4906 | 394 octave_int<T> min (void) const { return std::numeric_limits<T>::min (); } |
| 395 octave_int<T> max (void) const { return std::numeric_limits<T>::max (); } | |
| 396 | |
| 4919 | 397 static int nbits (void) { return sizeof (T) * CHAR_BIT; } |
| 4909 | 398 |
| 4949 | 399 static int byte_size (void) { return sizeof(T); } |
| 400 | |
| 5900 | 401 // Unsafe. This function exists to support the MEX interface. |
| 402 // You should not use it anywhere else. | |
| 403 void *mex_get_data (void) const { return const_cast<T *> (&ival); } | |
| 404 | |
| 4902 | 405 private: |
| 406 | |
| 407 T ival; | |
| 408 }; | |
| 409 | |
| 410 template <class T> | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
411 bool |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
412 xisnan (const octave_int<T>&) |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
413 { |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
414 return false; |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
415 } |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
416 |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7789
diff
changeset
|
417 template <class T> |
| 4953 | 418 octave_int<T> |
| 419 pow (const octave_int<T>& a, const octave_int<T>& b) | |
| 4952 | 420 { |
| 4953 | 421 octave_int<T> retval; |
| 4952 | 422 |
| 4953 | 423 octave_int<T> zero = octave_int<T> (0); |
| 424 octave_int<T> one = octave_int<T> (1); | |
| 4952 | 425 |
| 426 if (b == zero) | |
| 427 retval = one; | |
| 428 else if (b < zero) | |
| 429 retval = zero; | |
| 430 else | |
| 431 { | |
| 4953 | 432 octave_int<T> a_val = a; |
| 433 octave_int<T> b_val = b; | |
| 4952 | 434 |
| 435 retval = a; | |
| 436 | |
| 437 b_val -= 1; | |
| 438 | |
| 5030 | 439 while (b_val != zero) |
| 4952 | 440 { |
| 5030 | 441 if ((b_val & one) != zero) |
| 4952 | 442 retval = retval * a_val; |
| 443 | |
| 444 b_val = b_val >> 1; | |
| 445 | |
| 446 if (b_val > zero) | |
| 447 a_val = a_val * a_val; | |
| 448 } | |
| 449 } | |
| 450 | |
| 451 return retval; | |
| 452 } | |
| 453 | |
| 454 template <class T> | |
| 4953 | 455 octave_int<T> |
| 456 pow (double a, const octave_int<T>& b) | |
| 457 { | |
| 458 double tb = static_cast<double> (b.value ()); | |
| 459 double r = pow (a, tb); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
460 r = __lo_ieee_isnan (r) ? 0 : xround (r); |
| 4953 | 461 return OCTAVE_INT_FIT_TO_RANGE (r, T); |
| 462 } | |
| 463 | |
| 464 template <class T> | |
| 465 octave_int<T> | |
| 466 pow (const octave_int<T>& a, double b) | |
| 467 { | |
| 468 double ta = static_cast<double> (a.value ()); | |
| 469 double r = pow (ta, b); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
470 r = __lo_ieee_isnan (r) ? 0 : xround (r); |
| 4953 | 471 return OCTAVE_INT_FIT_TO_RANGE (r, T); |
| 472 } | |
| 473 | |
| 474 template <class T> | |
| 4902 | 475 std::ostream& |
| 476 operator << (std::ostream& os, const octave_int<T>& ival) | |
| 477 { | |
| 478 os << ival.value (); | |
| 479 return os; | |
| 480 } | |
| 481 | |
| 482 template <class T> | |
| 483 std::istream& | |
| 484 operator >> (std::istream& is, octave_int<T>& ival) | |
| 485 { | |
| 486 T tmp = 0; | |
| 487 is >> tmp; | |
| 488 ival = tmp; | |
| 489 return is; | |
| 490 } | |
| 491 | |
| 5828 | 492 typedef octave_int<int8_t> octave_int8; |
| 493 typedef octave_int<int16_t> octave_int16; | |
| 494 typedef octave_int<int32_t> octave_int32; | |
| 495 typedef octave_int<int64_t> octave_int64; | |
| 4902 | 496 |
| 5828 | 497 typedef octave_int<uint8_t> octave_uint8; |
| 498 typedef octave_int<uint16_t> octave_uint16; | |
| 499 typedef octave_int<uint32_t> octave_uint32; | |
| 500 typedef octave_int<uint64_t> octave_uint64; | |
| 4902 | 501 |
| 502 #define OCTAVE_INT_BIN_OP(OP) \ | |
| 503 template <class T1, class T2> \ | |
| 504 octave_int<typename octave_int_binop_traits<T1, T2>::TR> \ | |
| 505 operator OP (const octave_int<T1>& x, const octave_int<T2>& y) \ | |
| 506 { \ | |
| 507 double tx = static_cast<double> (x.value ()); \ | |
| 508 double ty = static_cast<double> (y.value ()); \ | |
| 509 double r = tx OP ty; \ | |
| 510 return OCTAVE_INT_FIT_TO_RANGE2 (r, T1, T2); \ | |
| 4906 | 511 } |
| 4902 | 512 |
| 513 OCTAVE_INT_BIN_OP(+) | |
| 514 OCTAVE_INT_BIN_OP(-) | |
| 515 OCTAVE_INT_BIN_OP(*) | |
| 4953 | 516 |
| 517 template <class T1, class T2> | |
| 518 octave_int<typename octave_int_binop_traits<T1, T2>::TR> | |
| 519 operator / (const octave_int<T1>& x, const octave_int<T2>& y) | |
| 520 { | |
| 521 double tx = static_cast<double> (x.value ()); | |
| 522 double ty = static_cast<double> (y.value ()); | |
| 6402 | 523 double r = (tx == 0 && ty == 0) ? 0 : xround (tx / ty); |
| 4953 | 524 return OCTAVE_INT_FIT_TO_RANGE2 (r, T1, T2); |
| 525 } | |
| 526 | |
| 527 #define OCTAVE_INT_DOUBLE_BIN_OP(OP) \ | |
| 528 template <class T> \ | |
| 529 octave_int<T> \ | |
| 530 operator OP (const octave_int<T>& x, double y) \ | |
| 531 { \ | |
| 532 double tx = static_cast<double> (x.value ()); \ | |
| 4968 | 533 double r = xround (tx OP y); \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
534 r = __lo_ieee_isnan (r) ? 0 : xround (r); \ |
| 4953 | 535 return OCTAVE_INT_FIT_TO_RANGE (r, T); \ |
| 536 } | |
| 537 | |
| 538 OCTAVE_INT_DOUBLE_BIN_OP(+) | |
| 539 OCTAVE_INT_DOUBLE_BIN_OP(-) | |
| 540 OCTAVE_INT_DOUBLE_BIN_OP(*) | |
| 541 OCTAVE_INT_DOUBLE_BIN_OP(/) | |
| 542 | |
| 543 #define OCTAVE_DOUBLE_INT_BIN_OP(OP) \ | |
| 544 template <class T> \ | |
| 545 octave_int<T> \ | |
| 546 operator OP (double x, const octave_int<T>& y) \ | |
| 547 { \ | |
| 548 double ty = static_cast<double> (y.value ()); \ | |
| 549 double r = x OP ty; \ | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
550 r = __lo_ieee_isnan (r) ? 0 : xround (r); \ |
| 4953 | 551 return OCTAVE_INT_FIT_TO_RANGE (r, T); \ |
| 552 } | |
| 553 | |
| 554 OCTAVE_DOUBLE_INT_BIN_OP(+) | |
| 555 OCTAVE_DOUBLE_INT_BIN_OP(-) | |
| 556 OCTAVE_DOUBLE_INT_BIN_OP(*) | |
| 557 OCTAVE_DOUBLE_INT_BIN_OP(/) | |
| 4902 | 558 |
| 5029 | 559 #define OCTAVE_INT_DOUBLE_CMP_OP(OP) \ |
| 560 template <class T> \ | |
| 561 bool \ | |
| 562 operator OP (const octave_int<T>& x, const double& y) \ | |
| 563 { \ | |
| 564 double tx = static_cast<double> (x.value ()); \ | |
| 5030 | 565 return tx OP y; \ |
| 5029 | 566 } |
| 567 | |
| 568 OCTAVE_INT_DOUBLE_CMP_OP (<) | |
| 569 OCTAVE_INT_DOUBLE_CMP_OP (<=) | |
| 570 OCTAVE_INT_DOUBLE_CMP_OP (>=) | |
| 571 OCTAVE_INT_DOUBLE_CMP_OP (>) | |
| 572 OCTAVE_INT_DOUBLE_CMP_OP (==) | |
| 573 OCTAVE_INT_DOUBLE_CMP_OP (!=) | |
| 574 | |
| 575 #define OCTAVE_DOUBLE_INT_CMP_OP(OP) \ | |
| 576 template <class T> \ | |
| 577 bool \ | |
| 578 operator OP (const double& x, const octave_int<T>& y) \ | |
| 579 { \ | |
| 580 double ty = static_cast<double> (y.value ()); \ | |
| 5030 | 581 return x OP ty; \ |
| 5029 | 582 } |
| 583 | |
| 584 OCTAVE_DOUBLE_INT_CMP_OP (<) | |
| 585 OCTAVE_DOUBLE_INT_CMP_OP (<=) | |
| 586 OCTAVE_DOUBLE_INT_CMP_OP (>=) | |
| 587 OCTAVE_DOUBLE_INT_CMP_OP (>) | |
| 588 OCTAVE_DOUBLE_INT_CMP_OP (==) | |
| 589 OCTAVE_DOUBLE_INT_CMP_OP (!=) | |
| 590 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
591 #define OCTAVE_INT_FLOAT_BIN_OP(OP) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
592 template <class T> \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
593 octave_int<T> \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
594 operator OP (const octave_int<T>& x, float y) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
595 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
596 double tx = static_cast<double> (x.value ()); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
597 double r = xround (tx OP y); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
598 r = __lo_ieee_isnan (r) ? 0 : xround (r); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
599 return OCTAVE_INT_FIT_TO_RANGE (r, T); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
600 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
601 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
602 OCTAVE_INT_FLOAT_BIN_OP(+) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
603 OCTAVE_INT_FLOAT_BIN_OP(-) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
604 OCTAVE_INT_FLOAT_BIN_OP(*) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
605 OCTAVE_INT_FLOAT_BIN_OP(/) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
606 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
607 #define OCTAVE_FLOAT_INT_BIN_OP(OP) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
608 template <class T> \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
609 octave_int<T> \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
610 operator OP (float x, const octave_int<T>& y) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
611 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
612 double ty = static_cast<double> (y.value ()); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
613 double r = x OP ty; \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
614 r = __lo_ieee_isnan (r) ? 0 : xround (r); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
615 return OCTAVE_INT_FIT_TO_RANGE (r, T); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
616 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
617 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
618 OCTAVE_FLOAT_INT_BIN_OP(+) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
619 OCTAVE_FLOAT_INT_BIN_OP(-) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
620 OCTAVE_FLOAT_INT_BIN_OP(*) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
621 OCTAVE_FLOAT_INT_BIN_OP(/) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
622 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
623 #define OCTAVE_INT_FLOAT_CMP_OP(OP) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
624 template <class T> \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
625 bool \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
626 operator OP (const octave_int<T>& x, const float& y) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
627 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
628 double tx = static_cast<double> (x.value ()); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
629 return tx OP y; \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
630 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
631 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
632 OCTAVE_INT_FLOAT_CMP_OP (<) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
633 OCTAVE_INT_FLOAT_CMP_OP (<=) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
634 OCTAVE_INT_FLOAT_CMP_OP (>=) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
635 OCTAVE_INT_FLOAT_CMP_OP (>) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
636 OCTAVE_INT_FLOAT_CMP_OP (==) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
637 OCTAVE_INT_FLOAT_CMP_OP (!=) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
638 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
639 #define OCTAVE_FLOAT_INT_CMP_OP(OP) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
640 template <class T> \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
641 bool \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
642 operator OP (const float& x, const octave_int<T>& y) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
643 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
644 double ty = static_cast<double> (y.value ()); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
645 return x OP ty; \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
646 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
647 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
648 OCTAVE_FLOAT_INT_CMP_OP (<) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
649 OCTAVE_FLOAT_INT_CMP_OP (<=) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
650 OCTAVE_FLOAT_INT_CMP_OP (>=) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
651 OCTAVE_FLOAT_INT_CMP_OP (>) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
652 OCTAVE_FLOAT_INT_CMP_OP (==) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
653 OCTAVE_FLOAT_INT_CMP_OP (!=) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7598
diff
changeset
|
654 |
| 4906 | 655 #define OCTAVE_INT_BITCMP_OP(OP) \ |
| 656 template <class T> \ | |
| 657 octave_int<T> \ | |
| 658 operator OP (const octave_int<T>& x, const octave_int<T>& y) \ | |
| 659 { \ | |
| 660 return x.value () OP y.value (); \ | |
| 661 } | |
| 662 | |
| 663 OCTAVE_INT_BITCMP_OP (&) | |
| 664 OCTAVE_INT_BITCMP_OP (|) | |
| 665 OCTAVE_INT_BITCMP_OP (^) | |
| 666 | |
| 4952 | 667 template <class T1, class T2> |
| 668 octave_int<T1> | |
| 669 operator << (const octave_int<T1>& x, const T2& y) | |
| 670 { | |
| 5030 | 671 octave_int<T1> retval = x; |
| 4952 | 672 return retval <<= y; |
| 673 } | |
| 4906 | 674 |
| 4952 | 675 template <class T1, class T2> |
| 676 octave_int<T1> | |
| 677 operator >> (const octave_int<T1>& x, const T2& y) | |
| 678 { | |
| 5030 | 679 octave_int<T1> retval = x; |
| 4952 | 680 return retval >>= y; |
| 681 } | |
| 4906 | 682 |
| 4909 | 683 template <class T> |
| 684 octave_int<T> | |
| 4920 | 685 bitshift (const octave_int<T>& a, int n, |
| 686 const octave_int<T>& mask = std::numeric_limits<T>::max ()) | |
| 4909 | 687 { |
| 688 if (n > 0) | |
| 4952 | 689 return (a << n) & mask; |
| 4909 | 690 else if (n < 0) |
| 4952 | 691 return (a >> -n) & mask; |
| 4909 | 692 else |
| 693 return a; | |
| 694 } | |
| 695 | |
| 4902 | 696 #define OCTAVE_INT_CMP_OP(OP) \ |
| 697 template <class T1, class T2> \ | |
| 698 bool \ | |
| 699 operator OP (const octave_int<T1>& x, const octave_int<T2>& y) \ | |
| 700 { \ | |
| 5072 | 701 return x.value () OP y.value (); \ |
| 4906 | 702 } |
| 4902 | 703 |
| 704 OCTAVE_INT_CMP_OP (<) | |
| 705 OCTAVE_INT_CMP_OP (<=) | |
| 706 OCTAVE_INT_CMP_OP (>=) | |
| 707 OCTAVE_INT_CMP_OP (>) | |
| 708 OCTAVE_INT_CMP_OP (==) | |
| 709 OCTAVE_INT_CMP_OP (!=) | |
| 710 | |
| 5072 | 711 // The following apply if the unsigned type is at least as wide as the |
| 712 // signed type (then we can cast postive signed values to the unsigned | |
| 713 // type and compare). | |
| 714 | |
| 715 #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
|
716 template <> \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
717 bool \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
718 OCTAVE_API operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs); |
| 5072 | 719 |
| 720 #define OCTAVE_US_TYPE1_CMP_OP_DECLS(UT, ST) \ | |
| 721 OCTAVE_US_TYPE1_CMP_OP_DECL (<, false, UT, ST) \ | |
| 722 OCTAVE_US_TYPE1_CMP_OP_DECL (<=, false, UT, ST) \ | |
| 723 OCTAVE_US_TYPE1_CMP_OP_DECL (>=, true, UT, ST) \ | |
| 724 OCTAVE_US_TYPE1_CMP_OP_DECL (>, true, UT, ST) \ | |
| 725 OCTAVE_US_TYPE1_CMP_OP_DECL (==, false, UT, ST) \ | |
| 726 OCTAVE_US_TYPE1_CMP_OP_DECL (!=, true, UT, ST) | |
| 727 | |
| 728 #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
|
729 template <> \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
730 bool \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
731 OCTAVE_API operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs); |
| 5072 | 732 |
| 733 #define OCTAVE_SU_TYPE1_CMP_OP_DECLS(ST, UT) \ | |
| 734 OCTAVE_SU_TYPE1_CMP_OP_DECL (<, true, ST, UT) \ | |
| 735 OCTAVE_SU_TYPE1_CMP_OP_DECL (<=, true, ST, UT) \ | |
| 736 OCTAVE_SU_TYPE1_CMP_OP_DECL (>=, false, ST, UT) \ | |
| 737 OCTAVE_SU_TYPE1_CMP_OP_DECL (>, false, ST, UT) \ | |
| 738 OCTAVE_SU_TYPE1_CMP_OP_DECL (==, false, ST, UT) \ | |
| 739 OCTAVE_SU_TYPE1_CMP_OP_DECL (!=, true, ST, UT) | |
| 740 | |
| 741 #define OCTAVE_TYPE1_CMP_OP_DECLS(UT, ST) \ | |
| 742 OCTAVE_US_TYPE1_CMP_OP_DECLS (UT, ST) \ | |
| 743 OCTAVE_SU_TYPE1_CMP_OP_DECLS (ST, UT) | |
| 744 | |
| 5828 | 745 OCTAVE_TYPE1_CMP_OP_DECLS (uint32_t, int8_t) |
| 746 OCTAVE_TYPE1_CMP_OP_DECLS (uint32_t, int16_t) | |
| 747 OCTAVE_TYPE1_CMP_OP_DECLS (uint32_t, int32_t) | |
| 5072 | 748 |
| 5828 | 749 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int8_t) |
| 750 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int16_t) | |
| 751 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int32_t) | |
| 752 OCTAVE_TYPE1_CMP_OP_DECLS (uint64_t, int64_t) | |
| 5072 | 753 |
| 754 // The following apply if the signed type is wider than the unsigned | |
| 755 // type (then we can cast unsigned values to the signed type and | |
| 756 // compare if the signed value is positive). | |
| 757 | |
| 758 #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
|
759 template <> \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
760 bool \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
761 OCTAVE_API operator OP (const octave_int<UT>& lhs, const octave_int<ST>& rhs); |
| 5072 | 762 |
| 763 #define OCTAVE_US_TYPE2_CMP_OP_DECLS(ST, UT) \ | |
| 764 OCTAVE_US_TYPE2_CMP_OP_DECL (<, false, ST, UT) \ | |
| 765 OCTAVE_US_TYPE2_CMP_OP_DECL (<=, false, ST, UT) \ | |
| 766 OCTAVE_US_TYPE2_CMP_OP_DECL (>=, true, ST, UT) \ | |
| 767 OCTAVE_US_TYPE2_CMP_OP_DECL (>, true, ST, UT) \ | |
| 768 OCTAVE_US_TYPE2_CMP_OP_DECL (==, false, ST, UT) \ | |
| 769 OCTAVE_US_TYPE2_CMP_OP_DECL (!=, true, ST, UT) | |
| 770 | |
| 771 #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
|
772 template <> \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
773 bool \ |
|
6f10bbb2854a
avoid some GCC warnings for unsigned comparisons
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
774 OCTAVE_API operator OP (const octave_int<ST>& lhs, const octave_int<UT>& rhs); |
| 5072 | 775 |
| 776 #define OCTAVE_SU_TYPE2_CMP_OP_DECLS(ST, UT) \ | |
| 777 OCTAVE_SU_TYPE2_CMP_OP_DECL (<, true, ST, UT) \ | |
| 778 OCTAVE_SU_TYPE2_CMP_OP_DECL (<=, true, ST, UT) \ | |
| 779 OCTAVE_SU_TYPE2_CMP_OP_DECL (>=, false, ST, UT) \ | |
| 780 OCTAVE_SU_TYPE2_CMP_OP_DECL (>, false, ST, UT) \ | |
| 781 OCTAVE_SU_TYPE2_CMP_OP_DECL (==, false, ST, UT) \ | |
| 782 OCTAVE_SU_TYPE2_CMP_OP_DECL (!=, true, ST, UT) | |
| 783 | |
| 784 #define OCTAVE_TYPE2_CMP_OP_DECLS(UT, ST) \ | |
| 785 OCTAVE_US_TYPE2_CMP_OP_DECLS (UT, ST) \ | |
| 786 OCTAVE_SU_TYPE2_CMP_OP_DECLS (ST, UT) | |
| 787 | |
| 5828 | 788 OCTAVE_TYPE2_CMP_OP_DECLS (uint32_t, int64_t) |
| 5072 | 789 |
| 4902 | 790 #undef OCTAVE_INT_BINOP_TRAIT |
| 5072 | 791 #undef OCTAVE_US_S_FTR |
| 792 #undef OCTAVE_US_S_FTR_FCNS | |
| 793 #undef OCTAVE_S_US_FTR | |
| 794 #undef OCTAVE_S_US_FTR_FCNS | |
| 4902 | 795 #undef OCTAVE_INT_FIT_TO_RANGE |
| 796 #undef OCTAVE_INT_MIN_VAL2 | |
| 797 #undef OCTAVE_INT_MAX_VAL2 | |
| 798 #undef OCTAVE_INT_FIT_TO_RANGE2 | |
| 799 #undef OCTAVE_INT_BIN_OP | |
| 5072 | 800 #undef OCTAVE_INT_DOUBLE_BIN_OP |
| 801 #undef OCTAVE_DOUBLE_INT_BIN_OP | |
| 802 #undef OCTAVE_INT_DOUBLE_CMP_OP | |
| 803 #undef OCTAVE_DOUBLE_INT_CMP_OP | |
| 804 #undef OCTAVE_INT_BITCMP_OP | |
| 4902 | 805 #undef OCTAVE_INT_CMP_OP |
| 5072 | 806 #undef OCTAVE_US_TYPE1_CMP_OP_DECL |
| 807 #undef OCTAVE_US_TYPE1_CMP_OP_DECLS | |
| 808 #undef OCTAVE_SU_TYPE1_CMP_OP_DECL | |
| 809 #undef OCTAVE_SU_TYPE1_CMP_OP_DECLS | |
| 810 #undef OCTAVE_TYPE1_CMP_OP_DECLS | |
| 811 #undef OCTAVE_US_TYPE2_CMP_OP_DECL | |
| 812 #undef OCTAVE_US_TYPE2_CMP_OP_DECLS | |
| 813 #undef OCTAVE_SU_TYPE2_CMP_OP_DECL | |
| 814 #undef OCTAVE_SU_TYPE2_CMP_OP_DECLS | |
| 5074 | 815 #undef OCTAVE_TYPE2_CMP_OP_DECLS |
| 4902 | 816 |
| 817 #endif | |
| 818 | |
| 819 /* | |
| 820 ;;; Local Variables: *** | |
| 821 ;;; mode: C++ *** | |
| 822 ;;; End: *** | |
| 823 */ |