GNU Octave  4.2.1
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
CNDArray.cc
Go to the documentation of this file.
1 // N-D Array manipulations.
2 /*
3 
4 Copyright (C) 1996-2017 John W. Eaton
5 Copyright (C) 2009 VZLU Prague, a.s.
6 
7 This file is part of Octave.
8 
9 Octave is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3 of the License, or (at your
12 option) any later version.
13 
14 Octave is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
18 
19 You should have received a copy of the GNU General Public License
20 along with Octave; see the file COPYING. If not, see
21 <http://www.gnu.org/licenses/>.
22 
23 */
24 
25 #if defined (HAVE_CONFIG_H)
26 # include "config.h"
27 #endif
28 
29 #include <cfloat>
30 
31 #include <vector>
32 
33 #include "Array-util.h"
34 #include "CNDArray.h"
35 #include "f77-fcn.h"
36 #include "functor.h"
37 #include "lo-ieee.h"
38 #include "lo-mappers.h"
39 #include "mx-base.h"
40 #include "mx-op-defs.h"
41 #include "mx-cnda-s.h"
42 #include "oct-fftw.h"
43 #include "oct-locbuf.h"
44 
45 #include "bsxfun-defs.cc"
46 
48  : MArray<Complex> (a.dims ())
49 {
50  octave_idx_type n = a.numel ();
51  for (octave_idx_type i = 0; i < n; i++)
52  xelem (i) = static_cast<unsigned char> (a(i));
53 }
54 
55 #if defined (HAVE_FFTW)
56 
58 ComplexNDArray::fourier (int dim) const
59 {
60  dim_vector dv = dims ();
61 
62  if (dim > dv.ndims () || dim < 0)
63  return ComplexNDArray ();
64 
65  octave_idx_type stride = 1;
66  octave_idx_type n = dv(dim);
67 
68  for (int i = 0; i < dim; i++)
69  stride *= dv(i);
70 
71  octave_idx_type howmany = numel () / dv(dim);
72  howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
73  octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
74  octave_idx_type dist = (stride == 1 ? n : 1);
75 
76  const Complex *in (fortran_vec ());
78  Complex *out (retval.fortran_vec ());
79 
80  // Need to be careful here about the distance between fft's
81  for (octave_idx_type k = 0; k < nloop; k++)
82  octave_fftw::fft (in + k * stride * n, out + k * stride * n,
83  n, howmany, stride, dist);
84 
85  return retval;
86 }
87 
89 ComplexNDArray::ifourier (int dim) const
90 {
91  dim_vector dv = dims ();
92 
93  if (dim > dv.ndims () || dim < 0)
94  return ComplexNDArray ();
95 
96  octave_idx_type stride = 1;
97  octave_idx_type n = dv(dim);
98 
99  for (int i = 0; i < dim; i++)
100  stride *= dv(i);
101 
102  octave_idx_type howmany = numel () / dv(dim);
103  howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
104  octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
105  octave_idx_type dist = (stride == 1 ? n : 1);
106 
107  const Complex *in (fortran_vec ());
108  ComplexNDArray retval (dv);
109  Complex *out (retval.fortran_vec ());
110 
111  // Need to be careful here about the distance between fft's
112  for (octave_idx_type k = 0; k < nloop; k++)
113  octave_fftw::ifft (in + k * stride * n, out + k * stride * n,
114  n, howmany, stride, dist);
115 
116  return retval;
117 }
118 
121 {
122  dim_vector dv = dims ();
123  if (dv.ndims () < 2)
124  return ComplexNDArray ();
125 
126  dim_vector dv2 (dv(0), dv(1));
127  const Complex *in = fortran_vec ();
128  ComplexNDArray retval (dv);
129  Complex *out = retval.fortran_vec ();
130  octave_idx_type howmany = numel () / dv(0) / dv(1);
131  octave_idx_type dist = dv(0) * dv(1);
132 
133  for (octave_idx_type i=0; i < howmany; i++)
134  octave_fftw::fftNd (in + i*dist, out + i*dist, 2, dv2);
135 
136  return retval;
137 }
138 
141 {
142  dim_vector dv = dims ();
143  if (dv.ndims () < 2)
144  return ComplexNDArray ();
145 
146  dim_vector dv2 (dv(0), dv(1));
147  const Complex *in = fortran_vec ();
148  ComplexNDArray retval (dv);
149  Complex *out = retval.fortran_vec ();
150  octave_idx_type howmany = numel () / dv(0) / dv(1);
151  octave_idx_type dist = dv(0) * dv(1);
152 
153  for (octave_idx_type i=0; i < howmany; i++)
154  octave_fftw::ifftNd (in + i*dist, out + i*dist, 2, dv2);
155 
156  return retval;
157 }
158 
161 {
162  dim_vector dv = dims ();
163  int rank = dv.ndims ();
164 
165  const Complex *in (fortran_vec ());
166  ComplexNDArray retval (dv);
167  Complex *out (retval.fortran_vec ());
168 
169  octave_fftw::fftNd (in, out, rank, dv);
170 
171  return retval;
172 }
173 
176 {
177  dim_vector dv = dims ();
178  int rank = dv.ndims ();
179 
180  const Complex *in (fortran_vec ());
181  ComplexNDArray retval (dv);
182  Complex *out (retval.fortran_vec ());
183 
184  octave_fftw::ifftNd (in, out, rank, dv);
185 
186  return retval;
187 }
188 
189 #else
190 
191 #include "lo-fftpack-proto.h"
192 
194 ComplexNDArray::fourier (int dim) const
195 {
196  dim_vector dv = dims ();
197 
198  if (dim > dv.ndims () || dim < 0)
199  return ComplexNDArray ();
200 
201  ComplexNDArray retval (dv);
202  octave_idx_type npts = dv(dim);
203  octave_idx_type nn = 4*npts+15;
204  Array<Complex> wsave (dim_vector (nn, 1));
205  Complex *pwsave = wsave.fortran_vec ();
206 
208 
209  octave_idx_type stride = 1;
210 
211  for (int i = 0; i < dim; i++)
212  stride *= dv(i);
213 
214  octave_idx_type howmany = numel () / npts;
215  howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
216  octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
217  octave_idx_type dist = (stride == 1 ? npts : 1);
218 
219  F77_FUNC (zffti, ZFFTI) (npts, F77_DBLE_CMPLX_ARG (pwsave));
220 
221  for (octave_idx_type k = 0; k < nloop; k++)
222  {
223  for (octave_idx_type j = 0; j < howmany; j++)
224  {
225  octave_quit ();
226 
227  for (octave_idx_type i = 0; i < npts; i++)
228  tmp[i] = elem ((i + k*npts)*stride + j*dist);
229 
230  F77_FUNC (zfftf, ZFFTF) (npts, F77_DBLE_CMPLX_ARG (tmp),
231  F77_DBLE_CMPLX_ARG (pwsave));
232 
233  for (octave_idx_type i = 0; i < npts; i++)
234  retval((i + k*npts)*stride + j*dist) = tmp[i];
235  }
236  }
237 
238  return retval;
239 }
240 
242 ComplexNDArray::ifourier (int dim) const
243 {
244  dim_vector dv = dims ();
245 
246  if (dim > dv.ndims () || dim < 0)
247  return ComplexNDArray ();
248 
249  ComplexNDArray retval (dv);
250  octave_idx_type npts = dv(dim);
251  octave_idx_type nn = 4*npts+15;
252  Array<Complex> wsave (dim_vector (nn, 1));
253  Complex *pwsave = wsave.fortran_vec ();
254 
256 
257  octave_idx_type stride = 1;
258 
259  for (int i = 0; i < dim; i++)
260  stride *= dv(i);
261 
262  octave_idx_type howmany = numel () / npts;
263  howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
264  octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
265  octave_idx_type dist = (stride == 1 ? npts : 1);
266 
267  F77_FUNC (zffti, ZFFTI) (npts, F77_DBLE_CMPLX_ARG (pwsave));
268 
269  for (octave_idx_type k = 0; k < nloop; k++)
270  {
271  for (octave_idx_type j = 0; j < howmany; j++)
272  {
273  octave_quit ();
274 
275  for (octave_idx_type i = 0; i < npts; i++)
276  tmp[i] = elem ((i + k*npts)*stride + j*dist);
277 
278  F77_FUNC (zfftb, ZFFTB) (npts, F77_DBLE_CMPLX_ARG (tmp),
279  F77_DBLE_CMPLX_ARG (pwsave));
280 
281  for (octave_idx_type i = 0; i < npts; i++)
282  retval((i + k*npts)*stride + j*dist) = tmp[i] /
283  static_cast<double> (npts);
284  }
285  }
286 
287  return retval;
288 }
289 
291 ComplexNDArray::fourier2d (void) const
292 {
293  dim_vector dv = dims ();
294  dim_vector dv2 (dv(0), dv(1));
295  int rank = 2;
296  ComplexNDArray retval (*this);
297  octave_idx_type stride = 1;
298 
299  for (int i = 0; i < rank; i++)
300  {
301  octave_idx_type npts = dv2(i);
302  octave_idx_type nn = 4*npts+15;
303  Array<Complex> wsave (dim_vector (nn, 1));
304  Complex *pwsave = wsave.fortran_vec ();
305  Array<Complex> row (dim_vector (npts, 1));
306  Complex *prow = row.fortran_vec ();
307 
308  octave_idx_type howmany = numel () / npts;
309  howmany = (stride == 1 ? howmany :
310  (howmany > stride ? stride : howmany));
311  octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
312  octave_idx_type dist = (stride == 1 ? npts : 1);
313 
314  F77_FUNC (zffti, ZFFTI) (npts, F77_DBLE_CMPLX_ARG (pwsave));
315 
316  for (octave_idx_type k = 0; k < nloop; k++)
317  {
318  for (octave_idx_type j = 0; j < howmany; j++)
319  {
320  octave_quit ();
321 
322  for (octave_idx_type l = 0; l < npts; l++)
323  prow[l] = retval((l + k*npts)*stride + j*dist);
324 
325  F77_FUNC (zfftf, ZFFTF) (npts, F77_DBLE_CMPLX_ARG (prow),
326  F77_DBLE_CMPLX_ARG (pwsave));
327 
328  for (octave_idx_type l = 0; l < npts; l++)
329  retval((l + k*npts)*stride + j*dist) = prow[l];
330  }
331  }
332 
333  stride *= dv2(i);
334  }
335 
336  return retval;
337 }
338 
340 ComplexNDArray::ifourier2d (void) const
341 {
342  dim_vector dv = dims ();
343  dim_vector dv2 (dv(0), dv(1));
344  int rank = 2;
345  ComplexNDArray retval (*this);
346  octave_idx_type stride = 1;
347 
348  for (int i = 0; i < rank; i++)
349  {
350  octave_idx_type npts = dv2(i);
351  octave_idx_type nn = 4*npts+15;
352  Array<Complex> wsave (dim_vector (nn, 1));
353  Complex *pwsave = wsave.fortran_vec ();
354  Array<Complex> row (dim_vector (npts, 1));
355  Complex *prow = row.fortran_vec ();
356 
357  octave_idx_type howmany = numel () / npts;
358  howmany = (stride == 1 ? howmany :
359  (howmany > stride ? stride : howmany));
360  octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
361  octave_idx_type dist = (stride == 1 ? npts : 1);
362 
363  F77_FUNC (zffti, ZFFTI) (npts, F77_DBLE_CMPLX_ARG (pwsave));
364 
365  for (octave_idx_type k = 0; k < nloop; k++)
366  {
367  for (octave_idx_type j = 0; j < howmany; j++)
368  {
369  octave_quit ();
370 
371  for (octave_idx_type l = 0; l < npts; l++)
372  prow[l] = retval((l + k*npts)*stride + j*dist);
373 
374  F77_FUNC (zfftb, ZFFTB) (npts, F77_DBLE_CMPLX_ARG (prow),
375  F77_DBLE_CMPLX_ARG (pwsave));
376 
377  for (octave_idx_type l = 0; l < npts; l++)
378  retval((l + k*npts)*stride + j*dist) =
379  prow[l] / static_cast<double> (npts);
380  }
381  }
382 
383  stride *= dv2(i);
384  }
385 
386  return retval;
387 }
388 
390 ComplexNDArray::fourierNd (void) const
391 {
392  dim_vector dv = dims ();
393  int rank = dv.ndims ();
394  ComplexNDArray retval (*this);
395  octave_idx_type stride = 1;
396 
397  for (int i = 0; i < rank; i++)
398  {
399  octave_idx_type npts = dv(i);
400  octave_idx_type nn = 4*npts+15;
401  Array<Complex> wsave (dim_vector (nn, 1));
402  Complex *pwsave = wsave.fortran_vec ();
403  Array<Complex> row (dim_vector (npts, 1));
404  Complex *prow = row.fortran_vec ();
405 
406  octave_idx_type howmany = numel () / npts;
407  howmany = (stride == 1 ? howmany :
408  (howmany > stride ? stride : howmany));
409  octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
410  octave_idx_type dist = (stride == 1 ? npts : 1);
411 
412  F77_FUNC (zffti, ZFFTI) (npts, F77_DBLE_CMPLX_ARG (pwsave));
413 
414  for (octave_idx_type k = 0; k < nloop; k++)
415  {
416  for (octave_idx_type j = 0; j < howmany; j++)
417  {
418  octave_quit ();
419 
420  for (octave_idx_type l = 0; l < npts; l++)
421  prow[l] = retval((l + k*npts)*stride + j*dist);
422 
423  F77_FUNC (zfftf, ZFFTF) (npts, F77_DBLE_CMPLX_ARG (prow),
424  F77_DBLE_CMPLX_ARG (pwsave));
425 
426  for (octave_idx_type l = 0; l < npts; l++)
427  retval((l + k*npts)*stride + j*dist) = prow[l];
428  }
429  }
430 
431  stride *= dv(i);
432  }
433 
434  return retval;
435 }
436 
438 ComplexNDArray::ifourierNd (void) const
439 {
440  dim_vector dv = dims ();
441  int rank = dv.ndims ();
442  ComplexNDArray retval (*this);
443  octave_idx_type stride = 1;
444 
445  for (int i = 0; i < rank; i++)
446  {
447  octave_idx_type npts = dv(i);
448  octave_idx_type nn = 4*npts+15;
449  Array<Complex> wsave (dim_vector (nn, 1));
450  Complex *pwsave = wsave.fortran_vec ();
451  Array<Complex> row (dim_vector (npts, 1));
452  Complex *prow = row.fortran_vec ();
453 
454  octave_idx_type howmany = numel () / npts;
455  howmany = (stride == 1 ? howmany :
456  (howmany > stride ? stride : howmany));
457  octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
458  octave_idx_type dist = (stride == 1 ? npts : 1);
459 
460  F77_FUNC (zffti, ZFFTI) (npts, F77_DBLE_CMPLX_ARG (pwsave));
461 
462  for (octave_idx_type k = 0; k < nloop; k++)
463  {
464  for (octave_idx_type j = 0; j < howmany; j++)
465  {
466  octave_quit ();
467 
468  for (octave_idx_type l = 0; l < npts; l++)
469  prow[l] = retval((l + k*npts)*stride + j*dist);
470 
471  F77_FUNC (zfftb, ZFFTB) (npts, F77_DBLE_CMPLX_ARG (prow),
472  F77_DBLE_CMPLX_ARG (pwsave));
473 
474  for (octave_idx_type l = 0; l < npts; l++)
475  retval((l + k*npts)*stride + j*dist) =
476  prow[l] / static_cast<double> (npts);
477  }
478  }
479 
480  stride *= dv(i);
481  }
482 
483  return retval;
484 }
485 
486 #endif
487 
488 // unary operations
489 
492 {
493  if (any_element_is_nan ())
495 
496  return do_mx_unary_op<bool, Complex> (*this, mx_inline_not);
497 }
498 
499 // FIXME: this is not quite the right thing.
500 
501 bool
503 {
504  return do_mx_check<Complex> (*this, mx_inline_any_nan);
505 }
506 
507 bool
509 {
510  return ! do_mx_check<Complex> (*this, mx_inline_all_finite);
511 }
512 
513 // Return true if no elements have imaginary components.
514 
515 bool
517 {
518  return do_mx_check<Complex> (*this, mx_inline_all_real);
519 }
520 
521 // Return nonzero if any element of CM has a non-integer real or
522 // imaginary part. Also extract the largest and smallest (real or
523 // imaginary) values and return them in MAX_VAL and MIN_VAL.
524 
525 bool
526 ComplexNDArray::all_integers (double& max_val, double& min_val) const
527 {
528  octave_idx_type nel = numel ();
529 
530  if (nel > 0)
531  {
532  Complex val = elem (0);
533 
534  double r_val = val.real ();
535  double i_val = val.imag ();
536 
537  max_val = r_val;
538  min_val = r_val;
539 
540  if (i_val > max_val)
541  max_val = i_val;
542 
543  if (i_val < max_val)
544  min_val = i_val;
545  }
546  else
547  return false;
548 
549  for (octave_idx_type i = 0; i < nel; i++)
550  {
551  Complex val = elem (i);
552 
553  double r_val = val.real ();
554  double i_val = val.imag ();
555 
556  if (r_val > max_val)
557  max_val = r_val;
558 
559  if (i_val > max_val)
560  max_val = i_val;
561 
562  if (r_val < min_val)
563  min_val = r_val;
564 
565  if (i_val < min_val)
566  min_val = i_val;
567 
568  if (octave::math::x_nint (r_val) != r_val
569  || octave::math::x_nint (i_val) != i_val)
570  return false;
571  }
572 
573  return true;
574 }
575 
576 bool
578 {
580 }
581 
583 ComplexNDArray::all (int dim) const
584 {
585  return do_mx_red_op<bool, Complex> (*this, dim, mx_inline_all);
586 }
587 
589 ComplexNDArray::any (int dim) const
590 {
591  return do_mx_red_op<bool, Complex> (*this, dim, mx_inline_any);
592 }
593 
595 ComplexNDArray::cumprod (int dim) const
596 {
597  return do_mx_cum_op<Complex, Complex> (*this, dim, mx_inline_cumprod);
598 }
599 
601 ComplexNDArray::cumsum (int dim) const
602 {
603  return do_mx_cum_op<Complex, Complex> (*this, dim, mx_inline_cumsum);
604 }
605 
607 ComplexNDArray::prod (int dim) const
608 {
609  return do_mx_red_op<Complex, Complex> (*this, dim, mx_inline_prod);
610 }
611 
613 ComplexNDArray::sum (int dim) const
614 {
615  return do_mx_red_op<Complex, Complex> (*this, dim, mx_inline_sum);
616 }
617 
619 ComplexNDArray::xsum (int dim) const
620 {
621  return do_mx_red_op<Complex, Complex> (*this, dim, mx_inline_xsum);
622 }
623 
625 ComplexNDArray::sumsq (int dim) const
626 {
627  return do_mx_red_op<double, Complex> (*this, dim, mx_inline_sumsq);
628 }
629 
631 ComplexNDArray::diff (octave_idx_type order, int dim) const
632 {
633  return do_mx_diff_op<Complex> (*this, dim, order, mx_inline_diff);
634 }
635 
639 {
640  if (rb.numel () > 0)
641  insert (rb, ra_idx);
642  return *this;
643 }
644 
647 {
648  ComplexNDArray tmp (rb);
649  if (rb.numel () > 0)
650  insert (tmp, ra_idx);
651  return *this;
652 }
653 
656 {
657  ComplexNDArray retval (ra);
658  if (rb.numel () > 0)
659  retval.insert (rb, ra_idx);
660  return retval;
661 }
662 
665 
667 ComplexNDArray::max (int dim) const
668 {
669  return do_mx_minmax_op<Complex> (*this, dim, mx_inline_max);
670 }
671 
674 {
675  return do_mx_minmax_op<Complex> (*this, idx_arg, dim, mx_inline_max);
676 }
677 
679 ComplexNDArray::min (int dim) const
680 {
681  return do_mx_minmax_op<Complex> (*this, dim, mx_inline_min);
682 }
683 
686 {
687  return do_mx_minmax_op<Complex> (*this, idx_arg, dim, mx_inline_min);
688 }
689 
691 ComplexNDArray::cummax (int dim) const
692 {
693  return do_mx_cumminmax_op<Complex> (*this, dim, mx_inline_cummax);
694 }
695 
698 {
699  return do_mx_cumminmax_op<Complex> (*this, idx_arg, dim, mx_inline_cummax);
700 }
701 
703 ComplexNDArray::cummin (int dim) const
704 {
705  return do_mx_cumminmax_op<Complex> (*this, dim, mx_inline_cummin);
706 }
707 
710 {
711  return do_mx_cumminmax_op<Complex> (*this, idx_arg, dim, mx_inline_cummin);
712 }
713 
714 NDArray
716 {
717  return do_mx_unary_map<double, Complex, std::abs> (*this);
718 }
719 
722 {
723  return do_mx_unary_map<bool, Complex, octave::math::isnan> (*this);
724 }
725 
728 {
729  return do_mx_unary_map<bool, Complex, octave::math::isinf> (*this);
730 }
731 
734 {
735  return do_mx_unary_map<bool, Complex, octave::math::finite> (*this);
736 }
737 
740 {
741  return do_mx_unary_map<Complex, Complex, std::conj<double> > (a);
742 }
743 
746 {
747  dim_vector a_dv = a.dims ();
748 
749  int n = a_dv.ndims ();
750 
751  if (n != dimensions.ndims ())
753  ("Array<T>::insert: invalid indexing operation");
754 
755  Array<octave_idx_type> a_ra_idx (dim_vector (a_dv.ndims (), 1), 0);
756 
757  a_ra_idx.elem (0) = r;
758  a_ra_idx.elem (1) = c;
759 
760  for (int i = 0; i < n; i++)
761  {
762  if (a_ra_idx(i) < 0 || (a_ra_idx(i) + a_dv(i)) > dimensions(i))
763  (*current_liboctave_error_handler)
764  ("Array<T>::insert: range error for insert");
765  }
766 
767  a_ra_idx.elem (0) = 0;
768  a_ra_idx.elem (1) = 0;
769 
770  octave_idx_type n_elt = a.numel ();
771 
772  // IS make_unique () NECESSARY HERE?
773 
774  for (octave_idx_type i = 0; i < n_elt; i++)
775  {
776  Array<octave_idx_type> ra_idx = a_ra_idx;
777 
778  ra_idx.elem (0) = a_ra_idx(0) + r;
779  ra_idx.elem (1) = a_ra_idx(1) + c;
780 
781  elem (ra_idx) = a.elem (a_ra_idx);
782 
783  increment_index (a_ra_idx, a_dv);
784  }
785 
786  return *this;
787 }
788 
792 {
793  Array<Complex>::insert (a, r, c);
794  return *this;
795 }
796 
800 {
801  Array<Complex>::insert (a, ra_idx);
802  return *this;
803 }
804 
805 void
807  const dim_vector& dimensions,
808  int start_dimension)
809 {
810  ::increment_index (ra_idx, dimensions, start_dimension);
811 }
812 
815  const dim_vector& dimensions)
816 {
817  return ::compute_index (ra_idx, dimensions);
818 }
819 
822 {
823  return MArray<Complex>::diag (k);
824 }
825 
828 {
829  return MArray<Complex>::diag (m, n);
830 }
831 
832 // This contains no information on the array structure !!!
833 std::ostream&
834 operator << (std::ostream& os, const ComplexNDArray& a)
835 {
836  octave_idx_type nel = a.numel ();
837 
838  for (octave_idx_type i = 0; i < nel; i++)
839  {
840  os << " ";
841  octave_write_complex (os, a.elem (i));
842  os << "\n";
843  }
844  return os;
845 }
846 
847 std::istream&
848 operator >> (std::istream& is, ComplexNDArray& a)
849 {
850  octave_idx_type nel = a.numel ();
851 
852  if (nel > 0)
853  {
854  Complex tmp;
855  for (octave_idx_type i = 0; i < nel; i++)
856  {
857  tmp = octave_read_value<Complex> (is);
858  if (is)
859  a.elem (i) = tmp;
860  else
861  return is;
862  }
863  }
864 
865  return is;
866 }
867 
869 
871 NDS_BOOL_OPS (ComplexNDArray, Complex)
872 
873 SND_CMP_OPS (Complex, ComplexNDArray)
874 SND_BOOL_OPS (Complex, ComplexNDArray)
875 
876 NDND_CMP_OPS (ComplexNDArray, ComplexNDArray)
877 NDND_BOOL_OPS (ComplexNDArray, ComplexNDArray)
878 
879 ComplexNDArray& operator *= (ComplexNDArray& a, double s)
880 {
881  if (a.is_shared ())
882  a = a * s;
883  else
884  do_ms_inplace_op<Complex, double> (a, s, mx_inline_mul2);
885  return a;
886 }
887 
889 {
890  if (a.is_shared ())
891  return a = a / s;
892  else
893  do_ms_inplace_op<Complex, double> (a, s, mx_inline_div2);
894  return a;
895 }
896 
899 
dim_vector dimensions
Definition: Array.h:214
T mx_inline_xsum(const T *v, octave_idx_type n)
Definition: mx-inlines.cc:1651
octave_idx_type compute_index(octave_idx_type n, const dim_vector &dims)
Definition: Array-util.cc:176
void mx_inline_mul2(size_t n, R *r, const X *x)
Definition: mx-inlines.cc:129
ComplexNDArray concat(const ComplexNDArray &rb, const Array< octave_idx_type > &ra_idx)
Definition: CNDArray.cc:637
std::istream & operator>>(std::istream &is, ComplexNDArray &a)
Definition: CNDArray.cc:848
#define NDS_BOOL_OPS(ND, S)
Definition: mx-op-defs.h:255
#define NDS_CMP_OPS(ND, S)
Definition: mx-op-defs.h:238
bool all_integers(double &max_val, double &min_val) const
Definition: CNDArray.cc:526
ComplexNDArray conj(const ComplexNDArray &a)
Definition: CNDArray.cc:739
void mx_inline_cummax(const T *v, T *r, octave_idx_type n)
Definition: mx-inlines.cc:1147
ComplexNDArray ifourier2d(void) const
Definition: CNDArray.cc:140
static int fft(const double *in, Complex *out, size_t npts, size_t nsamples=1, octave_idx_type stride=1, octave_idx_type dist=-1)
Definition: oct-fftw.cc:860
const octave_base_value const Array< octave_idx_type > & ra_idx
bool any_element_is_nan(void) const
Definition: CNDArray.cc:502
#define SND_CMP_OPS(S, ND)
Definition: mx-op-defs.h:285
#define BSXFUN_OP_DEF_MXLOOP(OP, ARRAY, LOOP)
Definition: bsxfun-defs.cc:222
ComplexNDArray diag(octave_idx_type k=0) const
Definition: CNDArray.cc:821
octave_idx_type numel(void) const
Number of elements in the array.
Definition: Array.h:363
subroutine zffti(n, wsave)
Definition: zffti.f:1
identity matrix If supplied two scalar respectively For allows like xample val
Definition: data.cc:5068
static octave_idx_type nn
Definition: DASPK.cc:71
OCTAVE_NORETURN liboctave_error_handler current_liboctave_error_handler
Definition: lo-error.c:38
#define F77_DBLE_CMPLX_ARG(x)
Definition: f77-fcn.h:345
ComplexNDArray & operator/=(ComplexNDArray &a, double s)
Definition: CNDArray.cc:888
bool mx_inline_all_finite(size_t n, const T *x)
Definition: mx-inlines.cc:256
ComplexNDArray fourier(int dim=1) const
Definition: CNDArray.cc:58
for large enough k
Definition: lu.cc:606
#define MINMAX_FCNS(T, S)
Definition: mx-op-defs.h:584
void octave_write_complex(std::ostream &os, const Complex &c)
Definition: lo-utils.cc:401
ComplexNDArray concat(NDArray &ra, ComplexNDArray &rb, const Array< octave_idx_type > &ra_idx)
Definition: CNDArray.cc:655
Array< T > diag(octave_idx_type k=0) const
Get the kth super or subdiagonal.
Definition: Array.cc:2529
ComplexNDArray ifourierNd(void) const
Definition: CNDArray.cc:175
Complex & elem(octave_idx_type n)
Definition: Array.h:482
Template for N-dimensional array classes with like-type math operators.
Definition: MArray.h:32
T mx_inline_sumsq(const T *v, octave_idx_type n)
Definition: mx-inlines.cc:716
void mx_inline_max(const T *v, T *r, octave_idx_type n)
Definition: mx-inlines.cc:925
s
Definition: file-io.cc:2682
void err_nan_to_logical_conversion(void)
bool mx_inline_any(const T *v, octave_idx_type n)
Definition: mx-inlines.cc:716
subroutine zfftb(n, c, wsave)
Definition: zfftb.f:1
ComplexNDArray fourier2d(void) const
Definition: CNDArray.cc:120
static void increment_index(Array< octave_idx_type > &ra_idx, const dim_vector &dimensions, int start_dimension=0)
Definition: CNDArray.cc:806
static int fftNd(const double *, Complex *, const int, const dim_vector &)
Definition: oct-fftw.cc:925
bool too_large_for_float(void) const
Definition: CNDArray.cc:577
Array< T > & insert(const Array< T > &a, const Array< octave_idx_type > &idx)
Insert an array into another at a specified position.
Definition: Array.cc:1601
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
Definition: cellfun.cc:398
ComplexNDArray sumsq(int dim=-1) const
Definition: CNDArray.cc:625
ComplexNDArray ifourier(int dim=1) const
Definition: CNDArray.cc:89
ComplexNDArray min(int dim=-1) const
Definition: CNDArray.cc:679
bool mx_inline_all_real(size_t n, const std::complex< T > *x)
Definition: mx-inlines.cc:295
boolNDArray operator!(void) const
Definition: CNDArray.cc:491
const dim_vector & dims(void) const
Return a const-reference so that dims ()(i) works efficiently.
Definition: Array.h:439
ComplexNDArray cumprod(int dim=-1) const
Definition: CNDArray.cc:595
ComplexNDArray prod(int dim=-1) const
Definition: CNDArray.cc:607
#define NDND_CMP_OPS(ND1, ND2)
Definition: mx-op-defs.h:332
ComplexNDArray sum(int dim=-1) const
Definition: CNDArray.cc:613
bool all_elements_are_real(void) const
Definition: CNDArray.cc:516
bool test_any(F fcn) const
Simpler calls.
Definition: Array.h:811
ComplexNDArray & insert(const NDArray &a, octave_idx_type r, octave_idx_type c)
Definition: CNDArray.cc:745
#define NDND_BOOL_OPS(ND1, ND2)
Definition: mx-op-defs.h:349
nd deftypefn *octave_map m
Definition: ov-struct.cc:2058
NDArray abs(void) const
Definition: CNDArray.cc:715
ComplexNDArray cummin(int dim=-1) const
Definition: CNDArray.cc:703
static int ifft(const Complex *in, Complex *out, size_t npts, size_t nsamples=1, octave_idx_type stride=1, octave_idx_type dist=-1)
Definition: oct-fftw.cc:900
octave_int< T > pow(const octave_int< T > &a, const octave_int< T > &b)
double tmp
Definition: data.cc:6300
octave_value retval
Definition: data.cc:6294
#define SND_BOOL_OPS(S, ND)
Definition: mx-op-defs.h:302
boolNDArray all(int dim=-1) const
Definition: CNDArray.cc:583
F77_RET_T F77_FUNC(xstopx, XSTOPX) const
Definition: f77-fcn.c:53
ComplexNDArray xsum(int dim=-1) const
Definition: CNDArray.cc:619
bool any_element_is_inf_or_nan(void) const
Definition: CNDArray.cc:508
void mx_inline_cummin(const T *v, T *r, octave_idx_type n)
Definition: mx-inlines.cc:1146
void mx_inline_pow(size_t n, R *r, const X *x, const Y *y)
Definition: mx-inlines.cc:402
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
Definition: lu.cc:138
the exceeded dimensions are set to if fewer subscripts than dimensions are the exceeding dimensions are merged into the final requested dimension For consider the following dims
Definition: sub2ind.cc:255
bool mx_inline_any_nan(size_t n, const T *x)
Definition: mx-inlines.cc:243
static int ifftNd(const Complex *, Complex *, const int, const dim_vector &)
Definition: oct-fftw.cc:971
#define BSXFUN_STDREL_DEFS_MXLOOP(ARRAY)
Definition: bsxfun-defs.cc:245
ComplexNDArray fourierNd(void) const
Definition: CNDArray.cc:160
Complex & xelem(octave_idx_type n)
Definition: Array.h:455
T mx_inline_sum(const T *v, octave_idx_type n)
Definition: mx-inlines.cc:714
ComplexNDArray cumsum(int dim=-1) const
Definition: CNDArray.cc:601
ComplexNDArray max(int dim=-1) const
Definition: CNDArray.cc:667
void mx_inline_cumprod(const T *v, T *r, octave_idx_type n)
Definition: mx-inlines.cc:821
ComplexNDArray(void)
Definition: CNDArray.h:40
static octave_idx_type compute_index(Array< octave_idx_type > &ra_idx, const dim_vector &dimensions)
Definition: CNDArray.cc:814
void mx_inline_cumsum(const T *v, T *r, octave_idx_type n)
Definition: mx-inlines.cc:820
std::ostream & operator<<(std::ostream &os, const ComplexNDArray &a)
Definition: CNDArray.cc:834
bool is_shared(void)
Definition: Array.h:588
=val(i)}if ode{val(i)}occurs in table i
Definition: lookup.cc:239
boolNDArray isfinite(void) const
Definition: CNDArray.cc:733
octave_idx_type ndims(void) const
Number of dimensions.
Definition: dim-vector.h:301
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the IEEE symbol NaN(Not a Number).NaN is the result of operations which do not produce a well defined 0 result.Common operations which produce a NaN are arithmetic with infinity ex($\infty-\infty $)
#define OCTAVE_LOCAL_BUFFER(T, buf, size)
Definition: oct-locbuf.h:200
bool xtoo_large_for_float(double x)
Definition: lo-utils.cc:54
ComplexNDArray diff(octave_idx_type order=1, int dim=-1) const
Definition: CNDArray.cc:631
boolNDArray isinf(void) const
Definition: CNDArray.cc:727
static const Complex Complex_NaN_result(octave::numeric_limits< double >::NaN(), octave::numeric_limits< double >::NaN())
bool mx_inline_all(const T *v, octave_idx_type n)
Definition: mx-inlines.cc:716
#define BSXFUN_STDOP_DEFS_MXLOOP(ARRAY)
Definition: bsxfun-defs.cc:237
std::complex< double > Complex
Definition: oct-cmplx.h:31
const Complex * fortran_vec(void) const
Definition: Array.h:584
void mx_inline_div2(size_t n, R *r, const X *x)
Definition: mx-inlines.cc:130
void mx_inline_not(size_t n, bool *r, const X *x)
Definition: mx-inlines.cc:182
write the output to stdout if nargout is
Definition: load-save.cc:1576
Vector representing the dimensions (size) of an Array.
Definition: dim-vector.h:87
T mx_inline_prod(const T *v, octave_idx_type n)
Definition: mx-inlines.cc:715
dim_vector dv
Definition: sub2ind.cc:263
ComplexNDArray cummax(int dim=-1) const
Definition: CNDArray.cc:691
T x_nint(T x)
Definition: lo-mappers.h:299
boolNDArray any(int dim=-1) const
Definition: CNDArray.cc:589
where the brackets indicate optional arguments and and character or cell array For character arrays the conversion is repeated for every row
Definition: str2double.cc:342
subroutine zfftf(n, c, wsave)
Definition: zfftf.f:1
boolNDArray isnan(void) const
Definition: CNDArray.cc:721
void mx_inline_diff(const T *v, T *r, octave_idx_type n, octave_idx_type order)
Definition: mx-inlines.cc:1343
void mx_inline_min(const T *v, T *r, octave_idx_type n)
Definition: mx-inlines.cc:924