Mercurial > octave-nkf

comparison libinterp/corefcn/bitfcns.cc @ 20591:0650b8431037

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
eliminate more simple uses of error_state * besselj.cc, bitfcns.cc, utils.cc, chol.cc, ov-java.cc: Eliminate simple uses of error_state.
author John W. Eaton <jwe@octave.org>
date Mon, 05 Oct 2015 21:37:03 -0400
parents 4bb41929286b
children
comparison
equal deleted inserted replaced
20590:1a0a433c8263 20591:0650b8431037
180 { 180 {
181 if (arg0_is_bool && arg1_is_bool) 181 if (arg0_is_bool && arg1_is_bool)
182 { 182 {
183 boolNDArray x (args(0).bool_array_value ()); 183 boolNDArray x (args(0).bool_array_value ());
184 boolNDArray y (args(1).bool_array_value ()); 184 boolNDArray y (args(1).bool_array_value ());
185 if (! error_state) 185
186 retval = bitopx (fname, x, y).bool_array_value (); 186 retval = bitopx (fname, x, y).bool_array_value ();
187 } 187 }
188 else if (arg0_is_float && arg1_is_float) 188 else if (arg0_is_float && arg1_is_float)
189 { 189 {
190 uint64NDArray x (args(0).float_array_value ()); 190 uint64NDArray x (args(0).float_array_value ());
191 uint64NDArray y (args(1).float_array_value ()); 191 uint64NDArray y (args(1).float_array_value ());
192 if (! error_state) 192
193 retval = bitopx (fname, x, y).float_array_value (); 193 retval = bitopx (fname, x, y).float_array_value ();
194 } 194 }
195 else if (! (arg0_is_float || arg1_is_float)) 195 else if (! (arg0_is_float || arg1_is_float))
196 { 196 {
197 uint64NDArray x (args(0).array_value ()); 197 uint64NDArray x (args(0).array_value ());
198 uint64NDArray y (args(1).array_value ()); 198 uint64NDArray y (args(1).array_value ());
199 if (! error_state) 199
200 retval = bitopx (fname, x, y).array_value (); 200 retval = bitopx (fname, x, y).array_value ();
201 } 201 }
202 else 202 else
203 { 203 {
204 int p = (arg0_is_float ? 1 : 0); 204 int p = (arg0_is_float ? 1 : 0);
205 int q = (arg0_is_float ? 0 : 1); 205 int q = (arg0_is_float ? 0 : 1);
206 206
207 uint64NDArray x (args(p).array_value ()); 207 uint64NDArray x (args(p).array_value ());
208 uint64NDArray y (args(q).float_array_value ()); 208 uint64NDArray y (args(q).float_array_value ());
209 if (! error_state) 209
210 retval = bitopx (fname, x, y).float_array_value (); 210 retval = bitopx (fname, x, y).float_array_value ();
211 } 211 }
212 } 212 }
213 else 213 else
214 { 214 {
215 int p = (arg0_is_int ? 1 : 0); 215 int p = (arg0_is_int ? 1 : 0);
220 if (args(q).type_id () == octave_uint64_matrix::static_type_id () 220 if (args(q).type_id () == octave_uint64_matrix::static_type_id ()
221 || args(q).type_id () == octave_uint64_scalar::static_type_id ()) 221 || args(q).type_id () == octave_uint64_scalar::static_type_id ())
222 { 222 {
223 uint64NDArray x (dx); 223 uint64NDArray x (dx);
224 uint64NDArray y = args(q).uint64_array_value (); 224 uint64NDArray y = args(q).uint64_array_value ();
225 if (! error_state) 225
226 retval = bitopx (fname, x, y); 226 retval = bitopx (fname, x, y);
227 } 227 }
228 else if (args(q).type_id () == octave_uint32_matrix::static_type_id () 228 else if (args(q).type_id () == octave_uint32_matrix::static_type_id ()
229 || args(q).type_id () == octave_uint32_scalar::static_type_id ()) 229 || args(q).type_id () == octave_uint32_scalar::static_type_id ())
230 { 230 {
231 uint32NDArray x (dx); 231 uint32NDArray x (dx);
232 uint32NDArray y = args(q).uint32_array_value (); 232 uint32NDArray y = args(q).uint32_array_value ();
233 if (! error_state) 233
234 retval = bitopx (fname, x, y); 234 retval = bitopx (fname, x, y);
235 } 235 }
236 else if (args(q).type_id () == octave_uint16_matrix::static_type_id () 236 else if (args(q).type_id () == octave_uint16_matrix::static_type_id ()
237 || args(q).type_id () == octave_uint16_scalar::static_type_id ()) 237 || args(q).type_id () == octave_uint16_scalar::static_type_id ())
238 { 238 {
239 uint16NDArray x (dx); 239 uint16NDArray x (dx);
240 uint16NDArray y = args(q).uint16_array_value (); 240 uint16NDArray y = args(q).uint16_array_value ();
241 if (! error_state) 241
242 retval = bitopx (fname, x, y); 242 retval = bitopx (fname, x, y);
243 } 243 }
244 else if (args(q).type_id () == octave_uint8_matrix::static_type_id () 244 else if (args(q).type_id () == octave_uint8_matrix::static_type_id ()
245 || args(q).type_id () == octave_uint8_scalar::static_type_id ()) 245 || args(q).type_id () == octave_uint8_scalar::static_type_id ())
246 { 246 {
247 uint8NDArray x (dx); 247 uint8NDArray x (dx);
248 uint8NDArray y = args(q).uint8_array_value (); 248 uint8NDArray y = args(q).uint8_array_value ();
249 if (! error_state) 249
250 retval = bitopx (fname, x, y); 250 retval = bitopx (fname, x, y);
251 } 251 }
252 else if (args(q).type_id () == octave_int64_matrix::static_type_id () 252 else if (args(q).type_id () == octave_int64_matrix::static_type_id ()
253 || args(q).type_id () == octave_int64_scalar::static_type_id ()) 253 || args(q).type_id () == octave_int64_scalar::static_type_id ())
254 { 254 {
255 int64NDArray x (dx); 255 int64NDArray x (dx);
256 int64NDArray y = args(q).int64_array_value (); 256 int64NDArray y = args(q).int64_array_value ();
257 if (! error_state) 257
258 retval = bitopx (fname, x, y); 258 retval = bitopx (fname, x, y);
259 } 259 }
260 else if (args(q).type_id () == octave_int32_matrix::static_type_id () 260 else if (args(q).type_id () == octave_int32_matrix::static_type_id ()
261 || args(q).type_id () == octave_int32_scalar::static_type_id ()) 261 || args(q).type_id () == octave_int32_scalar::static_type_id ())
262 { 262 {
263 int32NDArray x (dx); 263 int32NDArray x (dx);
264 int32NDArray y = args(q).int32_array_value (); 264 int32NDArray y = args(q).int32_array_value ();
265 if (! error_state) 265
266 retval = bitopx (fname, x, y); 266 retval = bitopx (fname, x, y);
267 } 267 }
268 else if (args(q).type_id () == octave_int16_matrix::static_type_id () 268 else if (args(q).type_id () == octave_int16_matrix::static_type_id ()
269 || args(q).type_id () == octave_int16_scalar::static_type_id ()) 269 || args(q).type_id () == octave_int16_scalar::static_type_id ())
270 { 270 {
271 int16NDArray x (dx); 271 int16NDArray x (dx);
272 int16NDArray y = args(q).int16_array_value (); 272 int16NDArray y = args(q).int16_array_value ();
273 if (! error_state) 273
274 retval = bitopx (fname, x, y); 274 retval = bitopx (fname, x, y);
275 } 275 }
276 else if (args(q).type_id () == octave_int8_matrix::static_type_id () 276 else if (args(q).type_id () == octave_int8_matrix::static_type_id ()
277 || args(q).type_id () == octave_int8_scalar::static_type_id ()) 277 || args(q).type_id () == octave_int8_scalar::static_type_id ())
278 { 278 {
279 int8NDArray x (dx); 279 int8NDArray x (dx);
280 int8NDArray y = args(q).int8_array_value (); 280 int8NDArray y = args(q).int8_array_value ();
281 if (! error_state) 281
282 retval = bitopx (fname, x, y); 282 retval = bitopx (fname, x, y);
283 } 283 }
284 else 284 else
285 error ("%s: invalid operand type", fname.c_str ()); 285 error ("%s: invalid operand type", fname.c_str ());
286 } 286 }
287 } 287 }
290 if (args(0).type_id () == octave_uint64_matrix::static_type_id () 290 if (args(0).type_id () == octave_uint64_matrix::static_type_id ()
291 || args(0).type_id () == octave_uint64_scalar::static_type_id ()) 291 || args(0).type_id () == octave_uint64_scalar::static_type_id ())
292 { 292 {
293 uint64NDArray x = args(0).uint64_array_value (); 293 uint64NDArray x = args(0).uint64_array_value ();
294 uint64NDArray y = args(1).uint64_array_value (); 294 uint64NDArray y = args(1).uint64_array_value ();
295 if (! error_state) 295
296 retval = bitopx (fname, x, y); 296 retval = bitopx (fname, x, y);
297 } 297 }
298 else if (args(0).type_id () == octave_uint32_matrix::static_type_id () 298 else if (args(0).type_id () == octave_uint32_matrix::static_type_id ()
299 || args(0).type_id () == octave_uint32_scalar::static_type_id ()) 299 || args(0).type_id () == octave_uint32_scalar::static_type_id ())
300 { 300 {
301 uint32NDArray x = args(0).uint32_array_value (); 301 uint32NDArray x = args(0).uint32_array_value ();
302 uint32NDArray y = args(1).uint32_array_value (); 302 uint32NDArray y = args(1).uint32_array_value ();
303 if (! error_state) 303
304 retval = bitopx (fname, x, y); 304 retval = bitopx (fname, x, y);
305 } 305 }
306 else if (args(0).type_id () == octave_uint16_matrix::static_type_id () 306 else if (args(0).type_id () == octave_uint16_matrix::static_type_id ()
307 || args(0).type_id () == octave_uint16_scalar::static_type_id ()) 307 || args(0).type_id () == octave_uint16_scalar::static_type_id ())
308 { 308 {
309 uint16NDArray x = args(0).uint16_array_value (); 309 uint16NDArray x = args(0).uint16_array_value ();
310 uint16NDArray y = args(1).uint16_array_value (); 310 uint16NDArray y = args(1).uint16_array_value ();
311 if (! error_state) 311
312 retval = bitopx (fname, x, y); 312 retval = bitopx (fname, x, y);
313 } 313 }
314 else if (args(0).type_id () == octave_uint8_matrix::static_type_id () 314 else if (args(0).type_id () == octave_uint8_matrix::static_type_id ()
315 || args(0).type_id () == octave_uint8_scalar::static_type_id ()) 315 || args(0).type_id () == octave_uint8_scalar::static_type_id ())
316 { 316 {
317 uint8NDArray x = args(0).uint8_array_value (); 317 uint8NDArray x = args(0).uint8_array_value ();
318 uint8NDArray y = args(1).uint8_array_value (); 318 uint8NDArray y = args(1).uint8_array_value ();
319 if (! error_state) 319
320 retval = bitopx (fname, x, y); 320 retval = bitopx (fname, x, y);
321 } 321 }
322 else if (args(0).type_id () == octave_int64_matrix::static_type_id () 322 else if (args(0).type_id () == octave_int64_matrix::static_type_id ()
323 || args(0).type_id () == octave_int64_scalar::static_type_id ()) 323 || args(0).type_id () == octave_int64_scalar::static_type_id ())
324 { 324 {
325 int64NDArray x = args(0).int64_array_value (); 325 int64NDArray x = args(0).int64_array_value ();
326 int64NDArray y = args(1).int64_array_value (); 326 int64NDArray y = args(1).int64_array_value ();
327 if (! error_state) 327
328 retval = bitopx (fname, x, y); 328 retval = bitopx (fname, x, y);
329 } 329 }
330 else if (args(0).type_id () == octave_int32_matrix::static_type_id () 330 else if (args(0).type_id () == octave_int32_matrix::static_type_id ()
331 || args(0).type_id () == octave_int32_scalar::static_type_id ()) 331 || args(0).type_id () == octave_int32_scalar::static_type_id ())
332 { 332 {
333 int32NDArray x = args(0).int32_array_value (); 333 int32NDArray x = args(0).int32_array_value ();
334 int32NDArray y = args(1).int32_array_value (); 334 int32NDArray y = args(1).int32_array_value ();
335 if (! error_state) 335
336 retval = bitopx (fname, x, y); 336 retval = bitopx (fname, x, y);
337 } 337 }
338 else if (args(0).type_id () == octave_int16_matrix::static_type_id () 338 else if (args(0).type_id () == octave_int16_matrix::static_type_id ()
339 || args(0).type_id () == octave_int16_scalar::static_type_id ()) 339 || args(0).type_id () == octave_int16_scalar::static_type_id ())
340 { 340 {
341 int16NDArray x = args(0).int16_array_value (); 341 int16NDArray x = args(0).int16_array_value ();
342 int16NDArray y = args(1).int16_array_value (); 342 int16NDArray y = args(1).int16_array_value ();
343 if (! error_state) 343
344 retval = bitopx (fname, x, y); 344 retval = bitopx (fname, x, y);
345 } 345 }
346 else if (args(0).type_id () == octave_int8_matrix::static_type_id () 346 else if (args(0).type_id () == octave_int8_matrix::static_type_id ()
347 || args(0).type_id () == octave_int8_scalar::static_type_id ()) 347 || args(0).type_id () == octave_int8_scalar::static_type_id ())
348 { 348 {
349 int8NDArray x = args(0).int8_array_value (); 349 int8NDArray x = args(0).int8_array_value ();
350 int8NDArray y = args(1).int8_array_value (); 350 int8NDArray y = args(1).int8_array_value ();
351 if (! error_state) 351
352 retval = bitopx (fname, x, y); 352 retval = bitopx (fname, x, y);
353 } 353 }
354 else 354 else
355 error ("%s: invalid operand type", fname.c_str ()); 355 error ("%s: invalid operand type", fname.c_str ());
356 } 356 }
357 else 357 else
458 // Note that the bitshift operators are undefined if shifted by more 458 // Note that the bitshift operators are undefined if shifted by more
459 // bits than in the type, so we need to test for the size of the 459 // bits than in the type, so we need to test for the size of the
460 // shift. 460 // shift.
461 461
462 #define DO_BITSHIFT(T) \ 462 #define DO_BITSHIFT(T) \
463 if (! error_state) \ 463 double d1, d2; \
464 \
465 if (n.all_integers (d1, d2)) \
464 { \ 466 { \
465 double d1, d2; \ 467 int m_nel = m.numel (); \
468 int n_nel = n.numel (); \
466 \ 469 \
467 if (n.all_integers (d1, d2)) \ 470 bool is_scalar_op = (m_nel == 1 || n_nel == 1); \
471 \
472 dim_vector m_dv = m.dims (); \
473 dim_vector n_dv = n.dims (); \
474 \
475 bool is_array_op = (m_dv == n_dv); \
476 \
477 if (is_array_op || is_scalar_op) \
468 { \ 478 { \
469 int m_nel = m.numel (); \ 479 T ## NDArray result; \
470 int n_nel = n.numel (); \
471 \ 480 \
472 bool is_scalar_op = (m_nel == 1 || n_nel == 1); \ 481 if (m_nel != 1) \
482 result.resize (m_dv); \
483 else \
484 result.resize (n_dv); \
473 \ 485 \
474 dim_vector m_dv = m.dims (); \ 486 for (int i = 0; i < m_nel; i++) \
475 dim_vector n_dv = n.dims (); \ 487 if (is_scalar_op) \
488 for (int k = 0; k < n_nel; k++) \
489 if (static_cast<int> (n(k)) >= bits_in_type) \
490 result(i+k) = 0; \
491 else \
492 result(i+k) = bitshift (m(i), static_cast<int> (n(k)), mask); \
493 else \
494 if (static_cast<int> (n(i)) >= bits_in_type) \
495 result(i) = 0; \
496 else \
497 result(i) = bitshift (m(i), static_cast<int> (n(i)), mask); \
476 \ 498 \
477 bool is_array_op = (m_dv == n_dv); \ 499 retval = result; \
478 \
479 if (is_array_op || is_scalar_op) \
480 { \
481 T ## NDArray result; \
482 \
483 if (m_nel != 1) \
484 result.resize (m_dv); \
485 else \
486 result.resize (n_dv); \
487 \
488 for (int i = 0; i < m_nel; i++) \
489 if (is_scalar_op) \
490 for (int k = 0; k < n_nel; k++) \
491 if (static_cast<int> (n(k)) >= bits_in_type) \
492 result(i+k) = 0; \
493 else \
494 result(i+k) = bitshift (m(i), static_cast<int> (n(k)), mask); \
495 else \
496 if (static_cast<int> (n(i)) >= bits_in_type) \
497 result(i) = 0; \
498 else \
499 result(i) = bitshift (m(i), static_cast<int> (n(i)), mask); \
500 \
501 retval = result; \
502 } \
503 else \
504 error ("bitshift: size of A and N must match, or one operand must be a scalar"); \
505 } \ 500 } \
506 else \ 501 else \
507 error ("bitshift: expecting integer as second argument"); \ 502 error ("bitshift: size of A and N must match, or one operand must be a scalar"); \
508 } 503 } \
504 else \
505 error ("bitshift: expecting integer as second argument"); \
509 506
510 #define DO_UBITSHIFT(T, N) \ 507 #define DO_UBITSHIFT(T, N) \
511 do \ 508 do \
512 { \ 509 { \
513 int bits_in_type = octave_ ## T :: nbits (); \ 510 int bits_in_type = octave_ ## T :: nbits (); \
598 else if (nbits < 0) 595 else if (nbits < 0)
599 error ("bitshift: N must be positive"); 596 error ("bitshift: N must be positive");
600 } 597 }
601 } 598 }
602 } 599 }
603
604 if (error_state)
605 return retval;
606 600
607 octave_value m_arg = args(0); 601 octave_value m_arg = args(0);
608 std::string cname = m_arg.class_name (); 602 std::string cname = m_arg.class_name ();
609 603
610 if (cname == "uint8") 604 if (cname == "uint8")