Mercurial > octave-nkf

comparison src/bitfcns.cc @ 4919:a1073eef650c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2004-07-27 15:22:50 by jwe]
author jwe
date Tue, 27 Jul 2004 15:22:51 +0000
parents c638c144d4da
children b22a7a1db0d5
comparison
equal deleted inserted replaced
4918:d2a7208f35d4 4919:a1073eef650c
84 \ 84 \
85 int nargin = args.length (); \ 85 int nargin = args.length (); \
86 \ 86 \
87 if (nargin == 2) \ 87 if (nargin == 2) \
88 { \ 88 { \
89 if (args(0).type_id () == octave_matrix::static_type_id () || \ 89 if (args(0).type_id () == octave_matrix::static_type_id () \
90 args(0).type_id () == octave_scalar::static_type_id () || \ 90 || args(0).type_id () == octave_scalar::static_type_id () \
91 args(1).type_id () == octave_matrix::static_type_id () || \ 91 || args(1).type_id () == octave_matrix::static_type_id () \
92 args(1).type_id () == octave_scalar::static_type_id ()) \ 92 || args(1).type_id () == octave_scalar::static_type_id ()) \
93 { \ 93 { \
94 bool arg0_is_int = true; \ 94 bool arg0_is_int = true; \
95 bool arg1_is_int = true; \ 95 bool arg1_is_int = true; \
96 \ 96 \
97 if (args(0).type_id () == octave_matrix::static_type_id () || \ 97 if (args(0).type_id () == octave_matrix::static_type_id () \
98 args(0).type_id () == octave_scalar::static_type_id ()) \ 98 || args(0).type_id () == octave_scalar::static_type_id ()) \
99 arg0_is_int = false; \ 99 arg0_is_int = false; \
100 \ 100 \
101 if (args(1).type_id () == octave_matrix::static_type_id () || \ 101 if (args(1).type_id () == octave_matrix::static_type_id () \
102 args(1).type_id () == octave_scalar::static_type_id ()) \ 102 || args(1).type_id () == octave_scalar::static_type_id ()) \
103 arg1_is_int = false; \ 103 arg1_is_int = false; \
104 \ 104 \
105 if (!arg0_is_int && !arg1_is_int) \ 105 if (!arg0_is_int && !arg1_is_int) \
106 { \ 106 { \
107 uint64NDArray x (args(0).array_value ()); \ 107 uint64NDArray x (args(0).array_value ()); \
108 uint64NDArray y (args(1).array_value ()); \ 108 uint64NDArray y (args(1).array_value ()); \
109 if (! error_state) \ 109 if (! error_state) \
110 BITOPX (OP, FNAME, uint64NDArray); \ 110 BITOPX (OP, FNAME, uint64NDArray); \
111 retval = retval.array_value (); \ 111 retval = retval.array_value (); \
112 } \ 112 } \
113 else \ 113 else \
114 { \ 114 { \
115 int p = (arg0_is_int ? 1 : 0); \ 115 int p = (arg0_is_int ? 1 : 0); \
116 int q = (arg0_is_int ? 0 : 1); \ 116 int q = (arg0_is_int ? 0 : 1); \
117 \
117 NDArray dx = args(p).array_value (); \ 118 NDArray dx = args(p).array_value (); \
118 \ 119 \
119 if (args(q).type_id () == octave_uint64_matrix::static_type_id () || \ 120 if (args(q).type_id () == octave_uint64_matrix::static_type_id () \
120 args(q).type_id () == octave_uint64_scalar::static_type_id ()) \ 121 || args(q).type_id () == octave_uint64_scalar::static_type_id ()) \
121 { \ 122 { \
122 uint64NDArray x (dx); \ 123 uint64NDArray x (dx); \
123 uint64NDArray y = args(q).uint64_array_value (); \ 124 uint64NDArray y = args(q).uint64_array_value (); \
124 if (! error_state) \ 125 if (! error_state) \
125 BITOPX (OP, FNAME, uint64NDArray); \ 126 BITOPX (OP, FNAME, uint64NDArray); \
126 } \ 127 } \
127 else if (args(q).type_id () == octave_uint32_matrix::static_type_id () || \ 128 else if (args(q).type_id () == octave_uint32_matrix::static_type_id () \
128 args(q).type_id () == octave_uint32_scalar::static_type_id ()) \ 129 || args(q).type_id () == octave_uint32_scalar::static_type_id ()) \
129 { \ 130 { \
130 uint32NDArray x (dx); \ 131 uint32NDArray x (dx); \
131 uint32NDArray y = args(q).uint32_array_value (); \ 132 uint32NDArray y = args(q).uint32_array_value (); \
132 if (! error_state) \ 133 if (! error_state) \
133 BITOPX (OP, FNAME, uint32NDArray); \ 134 BITOPX (OP, FNAME, uint32NDArray); \
134 } \ 135 } \
135 else if (args(q).type_id () == octave_uint16_matrix::static_type_id () || \ 136 else if (args(q).type_id () == octave_uint16_matrix::static_type_id () \
136 args(q).type_id () == octave_uint16_scalar::static_type_id ()) \ 137 || args(q).type_id () == octave_uint16_scalar::static_type_id ()) \
137 { \ 138 { \
138 uint16NDArray x (dx); \ 139 uint16NDArray x (dx); \
139 uint16NDArray y = args(q).uint16_array_value (); \ 140 uint16NDArray y = args(q).uint16_array_value (); \
140 if (! error_state) \ 141 if (! error_state) \
141 BITOPX (OP, FNAME, uint16NDArray); \ 142 BITOPX (OP, FNAME, uint16NDArray); \
142 } \ 143 } \
143 else if (args(q).type_id () == octave_uint8_matrix::static_type_id () || \ 144 else if (args(q).type_id () == octave_uint8_matrix::static_type_id () \
144 args(q).type_id () == octave_uint8_scalar::static_type_id ()) \ 145 || args(q).type_id () == octave_uint8_scalar::static_type_id ()) \
145 { \ 146 { \
146 uint8NDArray x (dx); \ 147 uint8NDArray x (dx); \
147 uint8NDArray y = args(q).uint8_array_value (); \ 148 uint8NDArray y = args(q).uint8_array_value (); \
148 if (! error_state) \ 149 if (! error_state) \
149 BITOPX (OP, FNAME, uint8NDArray); \ 150 BITOPX (OP, FNAME, uint8NDArray); \
150 } \ 151 } \
151 else if (args(q).type_id () == octave_int64_matrix::static_type_id () || \ 152 else if (args(q).type_id () == octave_int64_matrix::static_type_id () \
152 args(q).type_id () == octave_int64_scalar::static_type_id ()) \ 153 || args(q).type_id () == octave_int64_scalar::static_type_id ()) \
153 { \ 154 { \
154 int64NDArray x (dx); \ 155 int64NDArray x (dx); \
155 int64NDArray y = args(q).int64_array_value (); \ 156 int64NDArray y = args(q).int64_array_value (); \
156 if (! error_state) \ 157 if (! error_state) \
157 BITOPX (OP, FNAME, int64NDArray); \ 158 BITOPX (OP, FNAME, int64NDArray); \
158 } \ 159 } \
159 else if (args(q).type_id () == octave_int32_matrix::static_type_id () || \ 160 else if (args(q).type_id () == octave_int32_matrix::static_type_id () \
160 args(q).type_id () == octave_int32_scalar::static_type_id ()) \ 161 || args(q).type_id () == octave_int32_scalar::static_type_id ()) \
161 { \ 162 { \
162 int32NDArray x (dx); \ 163 int32NDArray x (dx); \
163 int32NDArray y = args(q).int32_array_value (); \ 164 int32NDArray y = args(q).int32_array_value (); \
164 if (! error_state) \ 165 if (! error_state) \
165 BITOPX (OP, FNAME, int32NDArray); \ 166 BITOPX (OP, FNAME, int32NDArray); \
166 } \ 167 } \
167 else if (args(q).type_id () == octave_int16_matrix::static_type_id () || \ 168 else if (args(q).type_id () == octave_int16_matrix::static_type_id () \
168 args(q).type_id () == octave_int16_scalar::static_type_id ()) \ 169 || args(q).type_id () == octave_int16_scalar::static_type_id ()) \
169 { \ 170 { \
170 int16NDArray x (dx); \ 171 int16NDArray x (dx); \
171 int16NDArray y = args(q).int16_array_value (); \ 172 int16NDArray y = args(q).int16_array_value (); \
172 if (! error_state) \ 173 if (! error_state) \
173 BITOPX (OP, FNAME, int16NDArray); \ 174 BITOPX (OP, FNAME, int16NDArray); \
174 } \ 175 } \
175 else if (args(q).type_id () == octave_int8_matrix::static_type_id () || \ 176 else if (args(q).type_id () == octave_int8_matrix::static_type_id () \
176 args(q).type_id () == octave_int8_scalar::static_type_id ()) \ 177 || args(q).type_id () == octave_int8_scalar::static_type_id ()) \
177 { \ 178 { \
178 int8NDArray x (dx); \ 179 int8NDArray x (dx); \
179 int8NDArray y = args(q).int8_array_value (); \ 180 int8NDArray y = args(q).int8_array_value (); \
180 if (! error_state) \ 181 if (! error_state) \
181 BITOPX (OP, FNAME, int8NDArray); \ 182 BITOPX (OP, FNAME, int8NDArray); \
182 } \ 183 } \
183 else \ 184 else \
184 error ("%s: illegal operand type", FNAME); \ 185 error ("%s: invalid operand type", FNAME); \
185 } \ 186 } \
186 } \ 187 } \
187 else if (args(0).type_id () == args(1).type_id ()) \ 188 else if (args(0).type_id () == args(1).type_id ()) \
188 { \ 189 { \
189 if (args(0).type_id () == octave_uint64_matrix::static_type_id () || \ 190 if (args(0).type_id () == octave_uint64_matrix::static_type_id () \
190 args(0).type_id () == octave_uint64_scalar::static_type_id ()) \ 191 || args(0).type_id () == octave_uint64_scalar::static_type_id ()) \
191 { \ 192 { \
192 uint64NDArray x = args(0).uint64_array_value (); \ 193 uint64NDArray x = args(0).uint64_array_value (); \
193 uint64NDArray y = args(1).uint64_array_value (); \ 194 uint64NDArray y = args(1).uint64_array_value (); \
194 if (! error_state) \ 195 if (! error_state) \
195 BITOPX (OP, FNAME, uint64NDArray); \ 196 BITOPX (OP, FNAME, uint64NDArray); \
196 } \ 197 } \
197 else if (args(0).type_id () == octave_uint32_matrix::static_type_id () || \ 198 else if (args(0).type_id () == octave_uint32_matrix::static_type_id () \
198 args(0).type_id () == octave_uint32_scalar::static_type_id ()) \ 199 || args(0).type_id () == octave_uint32_scalar::static_type_id ()) \
199 { \ 200 { \
200 uint32NDArray x = args(0).uint32_array_value (); \ 201 uint32NDArray x = args(0).uint32_array_value (); \
201 uint32NDArray y = args(1).uint32_array_value (); \ 202 uint32NDArray y = args(1).uint32_array_value (); \
202 if (! error_state) \ 203 if (! error_state) \
203 BITOPX (OP, FNAME, uint32NDArray); \ 204 BITOPX (OP, FNAME, uint32NDArray); \
204 } \ 205 } \
205 else if (args(0).type_id () == octave_uint16_matrix::static_type_id () || \ 206 else if (args(0).type_id () == octave_uint16_matrix::static_type_id () \
206 args(0).type_id () == octave_uint16_scalar::static_type_id ()) \ 207 || args(0).type_id () == octave_uint16_scalar::static_type_id ()) \
207 { \ 208 { \
208 uint16NDArray x = args(0).uint16_array_value (); \ 209 uint16NDArray x = args(0).uint16_array_value (); \
209 uint16NDArray y = args(1).uint16_array_value (); \ 210 uint16NDArray y = args(1).uint16_array_value (); \
210 if (! error_state) \ 211 if (! error_state) \
211 BITOPX (OP, FNAME, uint16NDArray); \ 212 BITOPX (OP, FNAME, uint16NDArray); \
212 } \ 213 } \
213 else if (args(0).type_id () == octave_uint8_matrix::static_type_id () || \ 214 else if (args(0).type_id () == octave_uint8_matrix::static_type_id () \
214 args(0).type_id () == octave_uint8_scalar::static_type_id ()) \ 215 || args(0).type_id () == octave_uint8_scalar::static_type_id ()) \
215 { \ 216 { \
216 uint8NDArray x = args(0).uint8_array_value (); \ 217 uint8NDArray x = args(0).uint8_array_value (); \
217 uint8NDArray y = args(1).uint8_array_value (); \ 218 uint8NDArray y = args(1).uint8_array_value (); \
218 if (! error_state) \ 219 if (! error_state) \
219 BITOPX (OP, FNAME, uint8NDArray); \ 220 BITOPX (OP, FNAME, uint8NDArray); \
220 } \ 221 } \
221 else if (args(0).type_id () == octave_int64_matrix::static_type_id () || \ 222 else if (args(0).type_id () == octave_int64_matrix::static_type_id () \
222 args(0).type_id () == octave_int64_scalar::static_type_id ()) \ 223 || args(0).type_id () == octave_int64_scalar::static_type_id ()) \
223 { \ 224 { \
224 int64NDArray x = args(0).int64_array_value (); \ 225 int64NDArray x = args(0).int64_array_value (); \
225 int64NDArray y = args(1).int64_array_value (); \ 226 int64NDArray y = args(1).int64_array_value (); \
226 if (! error_state) \ 227 if (! error_state) \
227 BITOPX (OP, FNAME, int64NDArray); \ 228 BITOPX (OP, FNAME, int64NDArray); \
228 } \ 229 } \
229 else if (args(0).type_id () == octave_int32_matrix::static_type_id () || \ 230 else if (args(0).type_id () == octave_int32_matrix::static_type_id () \
230 args(0).type_id () == octave_int32_scalar::static_type_id ()) \ 231 || args(0).type_id () == octave_int32_scalar::static_type_id ()) \
231 { \ 232 { \
232 int32NDArray x = args(0).int32_array_value (); \ 233 int32NDArray x = args(0).int32_array_value (); \
233 int32NDArray y = args(1).int32_array_value (); \ 234 int32NDArray y = args(1).int32_array_value (); \
234 if (! error_state) \ 235 if (! error_state) \
235 BITOPX (OP, FNAME, int32NDArray); \ 236 BITOPX (OP, FNAME, int32NDArray); \
236 } \ 237 } \
237 else if (args(0).type_id () == octave_int16_matrix::static_type_id () || \ 238 else if (args(0).type_id () == octave_int16_matrix::static_type_id () \
238 args(0).type_id () == octave_int16_scalar::static_type_id ()) \ 239 || args(0).type_id () == octave_int16_scalar::static_type_id ()) \
239 { \ 240 { \
240 int16NDArray x = args(0).int16_array_value (); \ 241 int16NDArray x = args(0).int16_array_value (); \
241 int16NDArray y = args(1).int16_array_value (); \ 242 int16NDArray y = args(1).int16_array_value (); \
242 if (! error_state) \ 243 if (! error_state) \
243 BITOPX (OP, FNAME, int16NDArray); \ 244 BITOPX (OP, FNAME, int16NDArray); \
244 } \ 245 } \
245 else if (args(0).type_id () == octave_int8_matrix::static_type_id () || \ 246 else if (args(0).type_id () == octave_int8_matrix::static_type_id () \
246 args(0).type_id () == octave_int8_scalar::static_type_id ()) \ 247 || args(0).type_id () == octave_int8_scalar::static_type_id ()) \
247 { \ 248 { \
248 int8NDArray x = args(0).int8_array_value (); \ 249 int8NDArray x = args(0).int8_array_value (); \
249 int8NDArray y = args(1).int8_array_value (); \ 250 int8NDArray y = args(1).int8_array_value (); \
250 if (! error_state) \ 251 if (! error_state) \
251 BITOPX (OP, FNAME, int8NDArray); \ 252 BITOPX (OP, FNAME, int8NDArray); \
252 } \ 253 } \
253 else \ 254 else \
254 error ("%s: illegal operand type", FNAME); \ 255 error ("%s: invalid operand type", FNAME); \
255 } \ 256 } \
256 else \ 257 else \
257 error ("%s: must have matching operand types", FNAME); \ 258 error ("%s: must have matching operand types", FNAME); \
258 } \ 259 } \
259 else \ 260 else \
303 return static_cast<EIGHT_BYTE_INT> (a) >> -n; 304 return static_cast<EIGHT_BYTE_INT> (a) >> -n;
304 else 305 else
305 return static_cast<EIGHT_BYTE_INT> (a); 306 return static_cast<EIGHT_BYTE_INT> (a);
306 } 307 }
307 308
308 // Note that the bitshift operators are undefined if shifted by more bits than 309 // Note that the bitshift operators are undefined if shifted by more
309 // in the type. Therefore need to test for the size of the shift 310 // bits than in the type, so we need to test for the size of the
311 // shift.
312
310 #define DO_BITSHIFT(T) \ 313 #define DO_BITSHIFT(T) \
311 if (! error_state) \ 314 if (! error_state) \
315 { \
316 double d1, d2; \
317 \
318 if (n.all_integers (d1, d2)) \
312 { \ 319 { \
313 double d1, d2; \ 320 int m_nel = m.numel (); \
314 \ 321 int n_nel = n.numel (); \
315 if (n.all_integers (d1, d2)) \ 322 \
316 { \ 323 bool is_scalar_op = (m_nel == 1 || n_nel == 1); \
317 int m_nel = m.numel (); \ 324 \
318 int n_nel = n.numel (); \ 325 dim_vector m_dv = m.dims (); \
319 \ 326 dim_vector n_dv = n.dims (); \
320 bool is_scalar_op = (m_nel == 1 || n_nel == 1); \ 327 \
321 \ 328 bool is_array_op = (m_dv == n_dv); \
322 dim_vector m_dv = m.dims (); \ 329 \
323 dim_vector n_dv = n.dims (); \ 330 if (is_array_op || is_scalar_op) \
324 \ 331 { \
325 bool is_array_op = (m_dv == n_dv); \ 332 T ## NDArray result; \
326 \ 333 \
327 if (is_array_op || is_scalar_op) \ 334 if (m_nel != 1) \
328 { \ 335 result.resize (m_dv); \
329 T ## NDArray result; \ 336 else \
330 \ 337 result.resize (n_dv); \
331 if (m_nel != 1) \ 338 \
332 result.resize (m_dv); \ 339 for (int i = 0; i < m_nel; i++) \
333 else \ 340 if (is_scalar_op) \
334 result.resize (n_dv); \ 341 for (int k = 0; k < n_nel; k++) \
335 \ 342 if (static_cast<int> (n(k)) >= bits_in_type) \
336 for (int i = 0; i < m_nel; i++) \ 343 result(i+k) = 0; \
337 if (is_scalar_op) \
338 for (int k = 0; k < n_nel; k++) \
339 if (static_cast<int> (n(k)) >= bits_in_type) \
340 result(i+k) = 0; \
341 else \
342 result(i+k) = bitshift (m(i), static_cast<int> (n(k))) & mask; \
343 else \ 344 else \
344 if (static_cast<int> (n(i)) >= bits_in_type) \ 345 result(i+k) = bitshift (m(i), static_cast<int> (n(k))) & mask; \
345 result(i) = 0; \ 346 else \
346 else \ 347 if (static_cast<int> (n(i)) >= bits_in_type) \
347 result(i) = bitshift (m(i), static_cast<int> (n(i))) & mask; \ 348 result(i) = 0; \
348 \ 349 else \
349 retval = result; \ 350 result(i) = bitshift (m(i), static_cast<int> (n(i))) & mask; \
350 } \ 351 \
351 else \ 352 retval = result; \
352 error ("bitshift: size of A and N must match, or one operand must be a scalar"); \ 353 } \
353 } \ 354 else \
354 else \ 355 error ("bitshift: size of A and N must match, or one operand must be a scalar"); \
355 error ("bitshift: expecting second argument to be integer"); \ 356 } \
356 } 357 else \
357 358 error ("bitshift: expecting second argument to be integer"); \
358 #define DO_UBITSHIFT(T, N) \ 359 }
359 do \ 360
360 { \ 361 #define DO_UBITSHIFT(T, N) \
361 int bits_in_type = sizeof (octave_ ## T) << 3; \ 362 do \
362 T ## NDArray m = m_arg.T ## _array_value (); \ 363 { \
363 octave_ ## T mask = ~0ULL; \ 364 int bits_in_type = sizeof (octave_ ## T) << 3; \
364 if ((N) < static_cast<int>(sizeof (octave_ ## T) << 3)) \ 365 T ## NDArray m = m_arg.T ## _array_value (); \
365 mask = mask >> ((sizeof (octave_ ## T) << 3) - (N)); \ 366 octave_ ## T mask = ~0ULL; \
366 else if ((N) < 1) \ 367 if ((N) < static_cast<int> (sizeof (octave_ ## T) << 3)) \
367 mask = 0; \ 368 mask = mask >> ((sizeof (octave_ ## T) << 3) - (N)); \
368 DO_BITSHIFT (T); \ 369 else if ((N) < 1) \
369 } \ 370 mask = 0; \
371 DO_BITSHIFT (T); \
372 } \
370 while (0) 373 while (0)
371 374
372 #define DO_SBITSHIFT(T, N) \ 375 #define DO_SBITSHIFT(T, N) \
373 do \ 376 do \
374 { \ 377 { \
375 int bits_in_type = sizeof (octave_ ## T) << 3; \ 378 int bits_in_type = sizeof (octave_ ## T) << 3; \
376 T ## NDArray m = m_arg.T ## _array_value (); \ 379 T ## NDArray m = m_arg.T ## _array_value (); \
377 octave_ ## T mask = -1; \ 380 octave_ ## T mask = -1; \
378 if ((N) < static_cast<int>(sizeof (octave_ ## T) << 3)) \ 381 if ((N) < static_cast<int>(sizeof (octave_ ## T) << 3)) \
379 mask = mask >> ((sizeof (octave_ ## T) << 3) - (N)); \ 382 mask = mask >> ((sizeof (octave_ ## T) << 3) - (N)); \
380 else if ((N) < 1) \ 383 else if ((N) < 1) \
381 mask = 0; \ 384 mask = 0; \
382 DO_BITSHIFT (T); \ 385 DO_BITSHIFT (T); \
383 } \ 386 } \
384 while (0) 387 while (0)
385 388
386 DEFUN (bitshift, args, , 389 DEFUN (bitshift, args, ,
387 "-*- texinfo -*-\n\ 390 "-*- texinfo -*-\n\
388 @deftypefn {Function File} {} bitshift (@var{a}, @var{k})\n\ 391 @deftypefn {Function File} {} bitshift (@var{a}, @var{k})\n\
477 Returns the largest integer that can be represented as a floating point\n\ 480 Returns the largest integer that can be represented as a floating point\n\
478 value. That is for IEEE-754 compatiable systems with @code{2^53 - 1}.\n\ 481 value. That is for IEEE-754 compatiable systems with @code{2^53 - 1}.\n\
479 @end deftypefn") 482 @end deftypefn")
480 { 483 {
481 octave_value retval; 484 octave_value retval;
482 if (args.length() != 0) 485 if (args.length () != 0)
483 print_usage ("bitmax"); 486 print_usage ("bitmax");
484 else 487 else
485 retval = ((double)0x1FFFFFFFFFFFFFLL); 488 retval = (static_cast<double> (0x1FFFFFFFFFFFFFLL));
486 return retval; 489 return retval;
487 } 490 }
488 491
489 DEFUN (intmax, args, , 492 DEFUN (intmax, args, ,
490 "-*- texinfo -*-\n\ 493 "-*- texinfo -*-\n\
493 { 496 {
494 octave_value retval; 497 octave_value retval;
495 std::string cname = "int32"; 498 std::string cname = "int32";
496 int nargin = args.length (); 499 int nargin = args.length ();
497 500
498 if (nargin == 1 && args(0).is_string()) 501 if (nargin == 1 && args(0).is_string ())
499 cname = args(0).string_value (); 502 cname = args(0).string_value ();
500 else if (nargin != 0) 503 else if (nargin != 0)
501 { 504 {
502 print_usage ("intmax"); 505 print_usage ("intmax");
503 return retval; 506 return retval;
504 } 507 }
505 508
506 if (cname == "uint8") 509 if (cname == "uint8")
507 retval = octave_uint8 (std::numeric_limits<octave_uint8_t>::max()); 510 retval = octave_uint8 (std::numeric_limits<octave_uint8_t>::max ());
508 else if (cname == "uint16") 511 else if (cname == "uint16")
509 retval = octave_uint16 (std::numeric_limits<octave_uint16_t>::max()); 512 retval = octave_uint16 (std::numeric_limits<octave_uint16_t>::max ());
510 else if (cname == "uint32") 513 else if (cname == "uint32")
511 retval = octave_uint32 (std::numeric_limits<octave_uint32_t>::max()); 514 retval = octave_uint32 (std::numeric_limits<octave_uint32_t>::max ());
512 else if (cname == "uint64") 515 else if (cname == "uint64")
513 retval = octave_uint64 (std::numeric_limits<octave_uint64_t>::max()); 516 retval = octave_uint64 (std::numeric_limits<octave_uint64_t>::max ());
514 else if (cname == "int8") 517 else if (cname == "int8")
515 retval = octave_int8 (std::numeric_limits<octave_int8_t>::max()); 518 retval = octave_int8 (std::numeric_limits<octave_int8_t>::max ());
516 else if (cname == "int16") 519 else if (cname == "int16")
517 retval = octave_int16 (std::numeric_limits<octave_int16_t>::max()); 520 retval = octave_int16 (std::numeric_limits<octave_int16_t>::max ());
518 else if (cname == "int32") 521 else if (cname == "int32")
519 retval = octave_int32 (std::numeric_limits<octave_int32_t>::max()); 522 retval = octave_int32 (std::numeric_limits<octave_int32_t>::max ());
520 else if (cname == "int64") 523 else if (cname == "int64")
521 retval = octave_int64 (std::numeric_limits<octave_int64_t>::max()); 524 retval = octave_int64 (std::numeric_limits<octave_int64_t>::max ());
522 else 525 else
523 error ("intmax: not defined for '%s' objects", cname.c_str ()); 526 error ("intmax: not defined for '%s' objects", cname.c_str ());
524 527
525 return retval; 528 return retval;
526 } 529 }
532 { 535 {
533 octave_value retval; 536 octave_value retval;
534 std::string cname = "int32"; 537 std::string cname = "int32";
535 int nargin = args.length (); 538 int nargin = args.length ();
536 539
537 if (nargin == 1 && args(0).is_string()) 540 if (nargin == 1 && args(0).is_string ())
538 cname = args(0).string_value (); 541 cname = args(0).string_value ();
539 else if (nargin != 0) 542 else if (nargin != 0)
540 { 543 {
541 print_usage ("intmin"); 544 print_usage ("intmin");
542 return retval; 545 return retval;
543 } 546 }
544 547
545 if (cname == "uint8") 548 if (cname == "uint8")
546 retval = octave_uint8 (std::numeric_limits<octave_uint8_t>::min()); 549 retval = octave_uint8 (std::numeric_limits<octave_uint8_t>::min ());
547 else if (cname == "uint16") 550 else if (cname == "uint16")
548 retval = octave_uint16 (std::numeric_limits<octave_uint16_t>::min()); 551 retval = octave_uint16 (std::numeric_limits<octave_uint16_t>::min());
549 else if (cname == "uint32") 552 else if (cname == "uint32")
550 retval = octave_uint32 (std::numeric_limits<octave_uint32_t>::min()); 553 retval = octave_uint32 (std::numeric_limits<octave_uint32_t>::min ());
551 else if (cname == "uint64") 554 else if (cname == "uint64")
552 retval = octave_uint64 (std::numeric_limits<octave_uint64_t>::min()); 555 retval = octave_uint64 (std::numeric_limits<octave_uint64_t>::min ());
553 else if (cname == "int8") 556 else if (cname == "int8")
554 retval = octave_int8 (std::numeric_limits<octave_int8_t>::min()); 557 retval = octave_int8 (std::numeric_limits<octave_int8_t>::min ());
555 else if (cname == "int16") 558 else if (cname == "int16")
556 retval = octave_int16 (std::numeric_limits<octave_int16_t>::min()); 559 retval = octave_int16 (std::numeric_limits<octave_int16_t>::min ());
557 else if (cname == "int32") 560 else if (cname == "int32")
558 retval = octave_int32 (std::numeric_limits<octave_int32_t>::min()); 561 retval = octave_int32 (std::numeric_limits<octave_int32_t>::min ());
559 else if (cname == "int64") 562 else if (cname == "int64")
560 retval = octave_int64 (std::numeric_limits<octave_int64_t>::min()); 563 retval = octave_int64 (std::numeric_limits<octave_int64_t>::min ());
561 else 564 else
562 error ("intmin: not defined for '%s' objects", cname.c_str ()); 565 error ("intmin: not defined for '%s' objects", cname.c_str ());
563 566
564 return retval; 567 return retval;
565 } 568 }