Mercurial > octave

comparison src/ov-intx.h @ 11586:12df7854fa7c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
strip trailing whitespace from source files
author John W. Eaton <jwe@octave.org>
date Thu, 20 Jan 2011 17:24:59 -0500
parents fd0a3ac60b0e
children d3ccd2e37de6
comparison
equal deleted inserted replaced
11585:1473d0cf86d2 11586:12df7854fa7c
111 } 111 }
112 else 112 else
113 gripe_invalid_conversion (type_name (), "real scalar"); 113 gripe_invalid_conversion (type_name (), "real scalar");
114 114
115 return retval; 115 return retval;
116 116
117 } 117 }
118 118
119 float 119 float
120 float_value (bool = false) const 120 float_value (bool = false) const
121 { 121 {
130 } 130 }
131 else 131 else
132 gripe_invalid_conversion (type_name (), "real scalar"); 132 gripe_invalid_conversion (type_name (), "real scalar");
133 133
134 return retval; 134 return retval;
135 135
136 } 136 }
137 137
138 double scalar_value (bool = false) const { return double_value (); } 138 double scalar_value (bool = false) const { return double_value (); }
139 139
140 float float_scalar_value (bool = false) const { return float_value (); } 140 float float_scalar_value (bool = false) const { return float_value (); }
211 return retval; 211 return retval;
212 } 212 }
213 213
214 NDArray 214 NDArray
215 array_value (bool = false) const 215 array_value (bool = false) const
216 { 216 {
217 NDArray retval (matrix.dims ()); 217 NDArray retval (matrix.dims ());
218 double *vec = retval.fortran_vec (); 218 double *vec = retval.fortran_vec ();
219 octave_idx_type nel = matrix.numel (); 219 octave_idx_type nel = matrix.numel ();
220 for (octave_idx_type i = 0; i < nel; i++) 220 for (octave_idx_type i = 0; i < nel; i++)
221 vec[i] = matrix(i).double_value (); 221 vec[i] = matrix(i).double_value ();
222 return retval; 222 return retval;
223 } 223 }
224 224
225 FloatNDArray 225 FloatNDArray
226 float_array_value (bool = false) const 226 float_array_value (bool = false) const
227 { 227 {
228 FloatNDArray retval (matrix.dims ()); 228 FloatNDArray retval (matrix.dims ());
229 float *vec = retval.fortran_vec (); 229 float *vec = retval.fortran_vec ();
230 octave_idx_type nel = matrix.numel (); 230 octave_idx_type nel = matrix.numel ();
231 for (octave_idx_type i = 0; i < nel; i++) 231 for (octave_idx_type i = 0; i < nel; i++)
232 vec[i] = matrix(i).float_value (); 232 vec[i] = matrix(i).float_value ();
233 return retval; 233 return retval;
234 } 234 }
235 235
236 ComplexNDArray 236 ComplexNDArray
237 complex_array_value (bool = false) const 237 complex_array_value (bool = false) const
238 { 238 {
239 ComplexNDArray retval (matrix.dims ()); 239 ComplexNDArray retval (matrix.dims ());
240 Complex *vec = retval.fortran_vec (); 240 Complex *vec = retval.fortran_vec ();
241 octave_idx_type nel = matrix.numel (); 241 octave_idx_type nel = matrix.numel ();
242 for (octave_idx_type i = 0; i < nel; i++) 242 for (octave_idx_type i = 0; i < nel; i++)
243 vec[i] = Complex (matrix(i).double_value ()); 243 vec[i] = Complex (matrix(i).double_value ());
244 return retval; 244 return retval;
245 } 245 }
246 246
247 FloatComplexNDArray 247 FloatComplexNDArray
248 float_complex_array_value (bool = false) const 248 float_complex_array_value (bool = false) const
249 { 249 {
250 FloatComplexNDArray retval (matrix.dims ()); 250 FloatComplexNDArray retval (matrix.dims ());
251 FloatComplex *vec = retval.fortran_vec (); 251 FloatComplex *vec = retval.fortran_vec ();
252 octave_idx_type nel = matrix.numel (); 252 octave_idx_type nel = matrix.numel ();
253 for (octave_idx_type i = 0; i < nel; i++) 253 for (octave_idx_type i = 0; i < nel; i++)
254 vec[i] = FloatComplex (matrix(i).float_value ()); 254 vec[i] = FloatComplex (matrix(i).float_value ());
255 return retval; 255 return retval;
276 char_array_value (bool = false) const 276 char_array_value (bool = false) const
277 { 277 {
278 charNDArray retval (dims ()); 278 charNDArray retval (dims ());
279 279
280 octave_idx_type nel = numel (); 280 octave_idx_type nel = numel ();
281 281
282 char *vec = retval.fortran_vec (); 282 char *vec = retval.fortran_vec ();
283 for (octave_idx_type i = 0; i < nel; i++) 283 for (octave_idx_type i = 0; i < nel; i++)
284 vec[i] = matrix(i).char_value (); 284 vec[i] = matrix(i).char_value ();
285 285
286 return retval; 286 return retval;
287 } 287 }
288 288
289 // Use matrix_ref here to clear index cache. 289 // Use matrix_ref here to clear index cache.
290 void increment (void) 290 void increment (void)
291 { 291 {
292 matrix_ref() += OCTAVE_INT_T (1); 292 matrix_ref() += OCTAVE_INT_T (1);
293 } 293 }
294 294
295 void decrement (void) 295 void decrement (void)
296 { 296 {
297 matrix_ref() -= OCTAVE_INT_T (1); 297 matrix_ref() -= OCTAVE_INT_T (1);
298 } 298 }
299 299
300 void changesign (void) 300 void changesign (void)
301 { 301 {
302 matrix_ref ().changesign (); 302 matrix_ref ().changesign ();
303 } 303 }
304 304
305 idx_vector index_vector (void) const 305 idx_vector index_vector (void) const
306 { return idx_cache ? *idx_cache : set_idx_cache (idx_vector (matrix)); } 306 { return idx_cache ? *idx_cache : set_idx_cache (idx_vector (matrix)); }
307 307
308 int write (octave_stream& os, int block_size, 308 int write (octave_stream& os, int block_size,
309 oct_data_conv::data_type output_type, int skip, 309 oct_data_conv::data_type output_type, int skip,
310 oct_mach_info::float_format flt_fmt) const 310 oct_mach_info::float_format flt_fmt) const
352 case umap_isinf: 352 case umap_isinf:
353 return boolNDArray (matrix.dims (), false); 353 return boolNDArray (matrix.dims (), false);
354 case umap_finite: 354 case umap_finite:
355 return boolNDArray (matrix.dims (), true); 355 return boolNDArray (matrix.dims (), true);
356 356
357 default: 357 default:
358 { 358 {
359 octave_matrix m (array_value ()); 359 octave_matrix m (array_value ());
360 return m.map (umap); 360 return m.map (umap);
361 } 361 }
362 } 362 }
403 // 1x1 matrix back to a scalar value. Need a better solution 403 // 1x1 matrix back to a scalar value. Need a better solution
404 // to this problem. 404 // to this problem.
405 405
406 octave_value tmp 406 octave_value tmp
407 (new OCTAVE_VALUE_INT_MATRIX_T 407 (new OCTAVE_VALUE_INT_MATRIX_T
408 (OCTAVE_VALUE_INT_NDARRAY_EXTRACTOR_FUNCTION ())); 408 (OCTAVE_VALUE_INT_NDARRAY_EXTRACTOR_FUNCTION ()));
409 409
410 return tmp.do_index_op (idx, resize_ok); 410 return tmp.do_index_op (idx, resize_ok);
411 } 411 }
412 412
413 bool OCTAVE_TYPE_PREDICATE_FUNCTION (void) const { return true; } 413 bool OCTAVE_TYPE_PREDICATE_FUNCTION (void) const { return true; }
532 return retval; 532 return retval;
533 } 533 }
534 534
535 NDArray 535 NDArray
536 array_value (bool = false) const 536 array_value (bool = false) const
537 { 537 {
538 NDArray retval (dim_vector (1, 1)); 538 NDArray retval (dim_vector (1, 1));
539 retval(0) = scalar.double_value (); 539 retval(0) = scalar.double_value ();
540 return retval; 540 return retval;
541 } 541 }
542 542
543 FloatNDArray 543 FloatNDArray
544 float_array_value (bool = false) const 544 float_array_value (bool = false) const
545 { 545 {
546 FloatNDArray retval (dim_vector (1, 1)); 546 FloatNDArray retval (dim_vector (1, 1));
547 retval(0) = scalar.float_value (); 547 retval(0) = scalar.float_value ();
548 return retval; 548 return retval;
549 } 549 }
550 550
551 ComplexNDArray 551 ComplexNDArray
552 complex_array_value (bool = false) const 552 complex_array_value (bool = false) const
553 { 553 {
554 ComplexNDArray retval (dim_vector (1, 1)); 554 ComplexNDArray retval (dim_vector (1, 1));
555 retval(0) = FloatComplex (scalar.double_value ()); 555 retval(0) = FloatComplex (scalar.double_value ());
556 return retval; 556 return retval;
557 } 557 }
558 558
559 FloatComplexNDArray 559 FloatComplexNDArray
560 float_complex_array_value (bool = false) const 560 float_complex_array_value (bool = false) const
561 { 561 {
562 FloatComplexNDArray retval (dim_vector (1, 1)); 562 FloatComplexNDArray retval (dim_vector (1, 1));
563 retval(0) = FloatComplex (scalar.float_value ()); 563 retval(0) = FloatComplex (scalar.float_value ());
564 return retval; 564 return retval;
565 } 565 }
566 566
583 charNDArray retval (dim_vector (1, 1)); 583 charNDArray retval (dim_vector (1, 1));
584 retval(0) = scalar.char_value (); 584 retval(0) = scalar.char_value ();
585 return retval; 585 return retval;
586 } 586 }
587 587
588 void increment (void) 588 void increment (void)
589 { 589 {
590 scalar += OCTAVE_INT_T (1); 590 scalar += OCTAVE_INT_T (1);
591 } 591 }
592 592
593 void decrement (void) 593 void decrement (void)
594 { 594 {
595 scalar -= OCTAVE_INT_T (1); 595 scalar -= OCTAVE_INT_T (1);
596 } 596 }
597 597
598 idx_vector index_vector (void) const { return idx_vector (scalar); } 598 idx_vector index_vector (void) const { return idx_vector (scalar); }
599 599
600 int write (octave_stream& os, int block_size, 600 int write (octave_stream& os, int block_size,
642 case umap_isinf: 642 case umap_isinf:
643 return false; 643 return false;
644 case umap_finite: 644 case umap_finite:
645 return true; 645 return true;
646 646
647 default: 647 default:
648 { 648 {
649 octave_scalar m (scalar_value ()); 649 octave_scalar m (scalar_value ());
650 return m.map (umap); 650 return m.map (umap);
651 } 651 }
652 } 652 }