octave: liboctave/fCNDArray.cc annotate

annotate liboctave/fCNDArray.cc @ 11008:3622db30ff05

simplify some array tests in liboctave

author	Jaroslav Hajek <highegg@gmail.com>
date	Tue, 21 Sep 2010 13:09:12 +0200
parents	b47ab50a6aa8
children	7c573eb981eb

rev	line source
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1 // N-D Array manipulations.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2 /*
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3
8920 eb63fbe60fab update copyright notices John W. Eaton <jwe@octave.org> parents: 8777 diff changeset	4 Copyright (C) 1996, 1997, 2003, 2004, 2005, 2006, 2007, 2008, 2009
eb63fbe60fab update copyright notices John W. Eaton <jwe@octave.org> parents: 8777 diff changeset	5 John W. Eaton
9601 a9b37bae1802 add a couple of missing copyright statements Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	6 Copyright (C) 2009 VZLU Prague, a.s.
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	7
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	8 This file is part of Octave.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	9
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	10 Octave is free software; you can redistribute it and/or modify it
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	11 under the terms of the GNU General Public License as published by the
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	12 Free Software Foundation; either version 3 of the License, or (at your
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	13 option) any later version.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	14
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	15 Octave is distributed in the hope that it will be useful, but WITHOUT
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	18 for more details.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	19
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	20 You should have received a copy of the GNU General Public License
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	21 along with Octave; see the file COPYING. If not, see
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	22 <http://www.gnu.org/licenses/>.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	23
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	24 */
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	25
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	26 #ifdef HAVE_CONFIG_H
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	27 #include <config.h>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	28 #endif
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	29
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	30 #include <cfloat>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	31
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	32 #include <vector>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	33
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	34 #include "Array-util.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	35 #include "f77-fcn.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	36 #include "fCNDArray.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	37 #include "functor.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	38 #include "lo-ieee.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	39 #include "lo-mappers.h"
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	40 #include "MArray-defs.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	41 #include "mx-base.h"
8774 b756ce0002db split implementation and interface in mx-op-defs and MArray-defs Jaroslav Hajek <highegg@gmail.com> parents: 8751 diff changeset	42 #include "mx-op-defs.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	43 #include "oct-fftw.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	44 #include "oct-locbuf.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	45
9743 26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	46 #include "bsxfun-defs.cc"
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	47
8956 d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	48 FloatComplexNDArray::FloatComplexNDArray (const charNDArray& a)
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	49 : MArray<FloatComplex> (a.dims ())
8956 d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	50 {
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	51 octave_idx_type n = a.numel ();
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	52 for (octave_idx_type i = 0; i < n; i++)
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	53 xelem (i) = static_cast<unsigned char> (a(i));
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	54 }
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	55
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	56 #if defined (HAVE_FFTW)
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	57
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	58 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	59 FloatComplexNDArray::fourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	60 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	61 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	62
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	63 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	64 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	65
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	66 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	67 octave_idx_type n = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	68
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	69 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	70 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	71
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	72 octave_idx_type howmany = numel () / dv (dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	73 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	74 octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv (dim) / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	75 octave_idx_type dist = (stride == 1 ? n : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	76
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	77 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	78 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	79 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	80
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	81 // Need to be careful here about the distance between fft's
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	82 for (octave_idx_type k = 0; k < nloop; k++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	83 octave_fftw::fft (in + k * stride * n, out + k * stride * n,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	84 n, howmany, stride, dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	85
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	86 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	87 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	88
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	89 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	90 FloatComplexNDArray::ifourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	91 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	92 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	93
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	94 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	95 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	96
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	97 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	98 octave_idx_type n = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	99
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	100 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	101 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	102
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	103 octave_idx_type howmany = numel () / dv (dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	104 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	105 octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv (dim) / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	106 octave_idx_type dist = (stride == 1 ? n : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	107
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	108 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	109 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	110 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	111
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	112 // Need to be careful here about the distance between fft's
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	113 for (octave_idx_type k = 0; k < nloop; k++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	114 octave_fftw::ifft (in + k * stride * n, out + k * stride * n,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	115 n, howmany, stride, dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	116
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	117 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	118 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	119
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	120 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	121 FloatComplexNDArray::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	122 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	123 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	124 if (dv.length () < 2)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	125 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	126
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	127 dim_vector dv2(dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	128 const FloatComplex *in = fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	129 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	130 FloatComplex *out = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	131 octave_idx_type howmany = numel() / dv(0) / dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	132 octave_idx_type dist = dv(0) * dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	133
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	134 for (octave_idx_type i=0; i < howmany; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	135 octave_fftw::fftNd (in + idist, out + idist, 2, dv2);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	136
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	137 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	138 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	139
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	140 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	141 FloatComplexNDArray::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	142 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	143 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	144 if (dv.length () < 2)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	145 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	146
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	147 dim_vector dv2(dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	148 const FloatComplex *in = fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	149 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	150 FloatComplex *out = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	151 octave_idx_type howmany = numel() / dv(0) / dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	152 octave_idx_type dist = dv(0) * dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	153
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	154 for (octave_idx_type i=0; i < howmany; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	155 octave_fftw::ifftNd (in + idist, out + idist, 2, dv2);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	156
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	157 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	158 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	159
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	160 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	161 FloatComplexNDArray::fourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	162 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	163 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	164 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	165
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	166 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	167 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	168 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	169
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	170 octave_fftw::fftNd (in, out, rank, dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	171
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	172 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	173 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	174
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	175 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	176 FloatComplexNDArray::ifourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	177 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	178 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	179 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	180
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	181 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	182 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	183 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	184
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	185 octave_fftw::ifftNd (in, out, rank, dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	186
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	187 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	188 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	189
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	190 #else
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	191
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	192 extern "C"
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	193 {
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	194 F77_RET_T
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	195 F77_FUNC (cffti, CFFTI) (const octave_idx_type&, FloatComplex*);
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	196
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	197 F77_RET_T
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	198 F77_FUNC (cfftf, CFFTF) (const octave_idx_type&, FloatComplex, FloatComplex);
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	199
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	200 F77_RET_T
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	201 F77_FUNC (cfftb, CFFTB) (const octave_idx_type&, FloatComplex, FloatComplex);
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	202 }
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	203
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	204 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	205 FloatComplexNDArray::fourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	206 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	207 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	208
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	209 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	210 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	211
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	212 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	213 octave_idx_type npts = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	214 octave_idx_type nn = 4*npts+15;
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	215 Array<FloatComplex> wsave (nn, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	216 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	217
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	218 OCTAVE_LOCAL_BUFFER (FloatComplex, tmp, npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	219
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	220 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	221
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	222 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	223 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	224
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	225 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	226 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	227 octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	228 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	229
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	230 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	231
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	232 for (octave_idx_type k = 0; k < nloop; k++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	233 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	234 for (octave_idx_type j = 0; j < howmany; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	235 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	236 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	237
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	238 for (octave_idx_type i = 0; i < npts; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	239 tmp[i] = elem((i + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	240
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	241 F77_FUNC (cfftf, CFFTF) (npts, tmp, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	242
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	243 for (octave_idx_type i = 0; i < npts; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	244 retval ((i + knpts)stride + j*dist) = tmp[i];
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	245 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	246 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	247
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	248 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	249 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	250
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	251 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	252 FloatComplexNDArray::ifourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	253 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	254 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	255
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	256 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	257 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	258
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	259 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	260 octave_idx_type npts = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	261 octave_idx_type nn = 4*npts+15;
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	262 Array<FloatComplex> wsave (nn, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	263 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	264
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	265 OCTAVE_LOCAL_BUFFER (FloatComplex, tmp, npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	266
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	267 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	268
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	269 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	270 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	271
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	272 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	273 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	274 octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	275 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	276
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	277 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	278
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	279 for (octave_idx_type k = 0; k < nloop; k++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	280 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	281 for (octave_idx_type j = 0; j < howmany; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	282 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	283 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	284
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	285 for (octave_idx_type i = 0; i < npts; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	286 tmp[i] = elem((i + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	287
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	288 F77_FUNC (cfftb, CFFTB) (npts, tmp, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	289
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	290 for (octave_idx_type i = 0; i < npts; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	291 retval ((i + knpts)stride + j*dist) = tmp[i] /
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	292 static_cast<float> (npts);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	293 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	294 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	295
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	296 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	297 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	298
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	299 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	300 FloatComplexNDArray::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	301 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	302 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	303 dim_vector dv2 (dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	304 int rank = 2;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	305 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	306 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	307
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	308 for (int i = 0; i < rank; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	309 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	310 octave_idx_type npts = dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	311 octave_idx_type nn = 4*npts+15;
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	312 Array<FloatComplex> wsave (nn, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	313 FloatComplex *pwsave = wsave.fortran_vec ();
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	314 Array<FloatComplex> row (npts, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	315 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	316
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	317 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	318 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	319 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	320 octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	321 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	322
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	323 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	324
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	325 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	326 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	327 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	328 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	329 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	330
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	331 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	332 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	333
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	334 F77_FUNC (cfftf, CFFTF) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	335
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	336 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	337 retval ((l + knpts)stride + j*dist) = prow[l];
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	338 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	339 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	340
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	341 stride *= dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	342 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	343
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	344 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	345 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	346
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	347 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	348 FloatComplexNDArray::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	349 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	350 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	351 dim_vector dv2 (dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	352 int rank = 2;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	353 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	354 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	355
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	356 for (int i = 0; i < rank; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	357 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	358 octave_idx_type npts = dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	359 octave_idx_type nn = 4*npts+15;
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	360 Array<FloatComplex> wsave (nn, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	361 FloatComplex *pwsave = wsave.fortran_vec ();
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	362 Array<FloatComplex> row (npts, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	363 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	364
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	365 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	366 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	367 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	368 octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	369 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	370
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	371 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	372
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	373 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	374 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	375 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	376 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	377 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	378
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	379 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	380 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	381
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	382 F77_FUNC (cfftb, CFFTB) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	383
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	384 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	385 retval ((l + knpts)stride + j*dist) = prow[l] /
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	386 static_cast<float> (npts);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	387 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	388 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	389
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	390 stride *= dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	391 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	392
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	393 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	394 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	395
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	396 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	397 FloatComplexNDArray::fourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	398 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	399 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	400 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	401 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	402 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	403
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	404 for (int i = 0; i < rank; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	405 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	406 octave_idx_type npts = dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	407 octave_idx_type nn = 4*npts+15;
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	408 Array<FloatComplex> wsave (nn, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	409 FloatComplex *pwsave = wsave.fortran_vec ();
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	410 Array<FloatComplex> row (npts, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	411 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	412
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	413 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	414 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	415 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	416 octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	417 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	418
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	419 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	420
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	421 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	422 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	423 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	424 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	425 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	426
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	427 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	428 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	429
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	430 F77_FUNC (cfftf, CFFTF) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	431
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	432 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	433 retval ((l + knpts)stride + j*dist) = prow[l];
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	434 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	435 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	436
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	437 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	438 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	439
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	440 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	441 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	442
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	443 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	444 FloatComplexNDArray::ifourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	445 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	446 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	447 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	448 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	449 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	450
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	451 for (int i = 0; i < rank; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	452 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	453 octave_idx_type npts = dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	454 octave_idx_type nn = 4*npts+15;
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	455 Array<FloatComplex> wsave (nn, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	456 FloatComplex *pwsave = wsave.fortran_vec ();
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	457 Array<FloatComplex> row (npts, 1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	458 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	459
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	460 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	461 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	462 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	463 octave_idx_type nloop = (stride == 1 ? 1 : numel () / npts / stride);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	464 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	465
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	466 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	467
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	468 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	469 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	470 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	471 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	472 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	473
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	474 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	475 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	476
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	477 F77_FUNC (cfftb, CFFTB) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	478
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	479 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	480 retval ((l + knpts)stride + j*dist) = prow[l] /
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	481 static_cast<float> (npts);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	482 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	483 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	484
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	485 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	486 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	487
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	488 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	489 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	490
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	491 #endif
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	492
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	493 // unary operations
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	494
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	495 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	496 FloatComplexNDArray::operator ! (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	497 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	498 return do_mx_unary_op<bool, FloatComplex> (*this, mx_inline_not);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	499 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	500
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	501 // FIXME -- this is not quite the right thing.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	502
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	503 bool
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	504 FloatComplexNDArray::any_element_is_nan (void) const
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	505 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	506 return do_mx_check<FloatComplex> (*this, mx_inline_any_nan);
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	507 }
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	508
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	509 bool
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	510 FloatComplexNDArray::any_element_is_inf_or_nan (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	511 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	512 return ! do_mx_check<FloatComplex> (*this, mx_inline_all_finite);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	513 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	514
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	515 // Return true if no elements have imaginary components.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	516
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	517 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	518 FloatComplexNDArray::all_elements_are_real (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	519 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	520 return do_mx_check<FloatComplex> (*this, mx_inline_all_real);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	521 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	522
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	523 // Return nonzero if any element of CM has a non-integer real or
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	524 // imaginary part. Also extract the largest and smallest (real or
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	525 // imaginary) values and return them in MAX_VAL and MIN_VAL.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	526
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	527 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	528 FloatComplexNDArray::all_integers (float& max_val, float& min_val) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	529 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	530 octave_idx_type nel = nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	531
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	532 if (nel > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	533 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	534 FloatComplex val = elem (0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	535
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	536 float r_val = std::real (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	537 float i_val = std::imag (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	538
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	539 max_val = r_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	540 min_val = r_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	541
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	542 if (i_val > max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	543 max_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	544
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	545 if (i_val < max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	546 min_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	547 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	548 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	549 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	550
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	551 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	552 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	553 FloatComplex val = elem (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	554
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	555 float r_val = std::real (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	556 float i_val = std::imag (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	557
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	558 if (r_val > max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	559 max_val = r_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	560
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	561 if (i_val > max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	562 max_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	563
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	564 if (r_val < min_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	565 min_val = r_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	566
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	567 if (i_val < min_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	568 min_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	569
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	570 if (D_NINT (r_val) != r_val \|\| D_NINT (i_val) != i_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	571 return false;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	572 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	573
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	574 return true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	575 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	576
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	577 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	578 FloatComplexNDArray::too_large_for_float (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	579 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	580 octave_idx_type nel = nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	581
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	582 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	583 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	584 FloatComplex val = elem (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	585
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	586 float r_val = std::real (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	587 float i_val = std::imag (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	588
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	589 if ((! (xisnan (r_val) \|\| xisinf (r_val))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	590 && fabs (r_val) > FLT_MAX)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	591 \|\| (! (xisnan (i_val) \|\| xisinf (i_val))
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	592 && fabs (i_val) > FLT_MAX))
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	593 return true;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	594 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	595
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	596 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	597 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	598
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	599 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	600 FloatComplexNDArray::all (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	601 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	602 return do_mx_red_op<bool, FloatComplex> (*this, dim, mx_inline_all);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	603 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	604
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	605 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	606 FloatComplexNDArray::any (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	607 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	608 return do_mx_red_op<bool, FloatComplex> (*this, dim, mx_inline_any);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	609 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	610
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	611 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	612 FloatComplexNDArray::cumprod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	613 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	614 return do_mx_cum_op<FloatComplex, FloatComplex> (*this, dim, mx_inline_cumprod);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	615 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	616
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	617 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	618 FloatComplexNDArray::cumsum (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	619 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	620 return do_mx_cum_op<FloatComplex, FloatComplex> (*this, dim, mx_inline_cumsum);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	621 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	622
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	623 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	624 FloatComplexNDArray::prod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	625 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	626 return do_mx_red_op<FloatComplex, FloatComplex> (*this, dim, mx_inline_prod);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	627 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	628
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	629 FloatComplexNDArray
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	630 FloatComplexNDArray::sum (int dim) const
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	631 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	632 return do_mx_red_op<FloatComplex, FloatComplex> (*this, dim, mx_inline_sum);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	633 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	634
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	635 ComplexNDArray
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	636 FloatComplexNDArray::dsum (int dim) const
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	637 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	638 return do_mx_red_op<Complex, FloatComplex> (*this, dim, mx_inline_dsum);
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	639 }
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	640
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	641 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	642 FloatComplexNDArray::sumsq (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	643 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	644 return do_mx_red_op<float, FloatComplex> (*this, dim, mx_inline_sumsq);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	645 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	646
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	647 FloatComplexNDArray
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	648 FloatComplexNDArray::diff (octave_idx_type order, int dim) const
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	649 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	650 return do_mx_diff_op<FloatComplex> (*this, dim, order, mx_inline_diff);
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	651 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	652
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	653 FloatComplexNDArray
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	654 FloatComplexNDArray::concat (const FloatComplexNDArray& rb, const Array<octave_idx_type>& ra_idx)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	655 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	656 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	657 insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	658 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	659 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	660
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	661 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	662 FloatComplexNDArray::concat (const FloatNDArray& rb, const Array<octave_idx_type>& ra_idx)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	663 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	664 FloatComplexNDArray tmp (rb);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	665 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	666 insert (tmp, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	667 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	668 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	669
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	670 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	671 concat (NDArray& ra, FloatComplexNDArray& rb, const Array<octave_idx_type>& ra_idx)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	672 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	673 FloatComplexNDArray retval (ra);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	674 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	675 retval.insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	676 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	677 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	678
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	679 static const FloatComplex FloatComplex_NaN_result (octave_Float_NaN, octave_Float_NaN);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	680
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	681 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	682 FloatComplexNDArray::max (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	683 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	684 return do_mx_minmax_op<FloatComplex> (*this, dim, mx_inline_max);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	685 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	686
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	687 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	688 FloatComplexNDArray::max (Array<octave_idx_type>& idx_arg, int dim) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	689 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	690 return do_mx_minmax_op<FloatComplex> (*this, idx_arg, dim, mx_inline_max);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	691 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	692
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	693 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	694 FloatComplexNDArray::min (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	695 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	696 return do_mx_minmax_op<FloatComplex> (*this, dim, mx_inline_min);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	697 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	698
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	699 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	700 FloatComplexNDArray::min (Array<octave_idx_type>& idx_arg, int dim) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	701 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	702 return do_mx_minmax_op<FloatComplex> (*this, idx_arg, dim, mx_inline_min);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	703 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	704
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	705 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	706 FloatComplexNDArray::cummax (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	707 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	708 return do_mx_cumminmax_op<FloatComplex> (*this, dim, mx_inline_cummax);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	709 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	710
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	711 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	712 FloatComplexNDArray::cummax (Array<octave_idx_type>& idx_arg, int dim) const
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	713 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	714 return do_mx_cumminmax_op<FloatComplex> (*this, idx_arg, dim, mx_inline_cummax);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	715 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	716
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	717 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	718 FloatComplexNDArray::cummin (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	719 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	720 return do_mx_cumminmax_op<FloatComplex> (*this, dim, mx_inline_cummin);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	721 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	722
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	723 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	724 FloatComplexNDArray::cummin (Array<octave_idx_type>& idx_arg, int dim) const
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	725 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	726 return do_mx_cumminmax_op<FloatComplex> (*this, idx_arg, dim, mx_inline_cummin);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	727 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	728
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	729 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	730 FloatComplexNDArray::abs (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	731 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	732 return do_mx_unary_map<float, FloatComplex, std::abs> (*this);
8650 a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	733 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	734
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	735 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	736 FloatComplexNDArray::isnan (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	737 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	738 return do_mx_unary_map<bool, FloatComplex, xisnan> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	739 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	740
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	741 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	742 FloatComplexNDArray::isinf (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	743 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	744 return do_mx_unary_map<bool, FloatComplex, xisinf> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	745 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	746
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	747 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	748 FloatComplexNDArray::isfinite (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	749 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	750 return do_mx_unary_map<bool, FloatComplex, xfinite> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	751 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	752
8650 a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	753 FloatComplexNDArray
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	754 conj (const FloatComplexNDArray& a)
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	755 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	756 return do_mx_unary_map<FloatComplex, FloatComplex, std::conj> (a);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	757 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	758
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	759 FloatComplexNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	760 FloatComplexNDArray::insert (const NDArray& a, octave_idx_type r, octave_idx_type c)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	761 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	762 dim_vector a_dv = a.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	763
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	764 int n = a_dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	765
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	766 if (n == dimensions.length ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	767 {
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	768 Array<octave_idx_type> a_ra_idx (a_dv.length (), 1, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	769
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	770 a_ra_idx.elem (0) = r;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	771 a_ra_idx.elem (1) = c;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	772
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	773 for (int i = 0; i < n; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	774 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	775 if (a_ra_idx (i) < 0 \|\| (a_ra_idx (i) + a_dv (i)) > dimensions (i))
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	776 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	777 (*current_liboctave_error_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	778 ("Array<T>::insert: range error for insert");
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	779 return *this;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	780 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	781 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	782
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	783 a_ra_idx.elem (0) = 0;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	784 a_ra_idx.elem (1) = 0;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	785
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	786 octave_idx_type n_elt = a.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	787
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	788 // IS make_unique () NECCESSARY HERE??
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	789
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	790 for (octave_idx_type i = 0; i < n_elt; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	791 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	792 Array<octave_idx_type> ra_idx = a_ra_idx;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	793
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	794 ra_idx.elem (0) = a_ra_idx (0) + r;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	795 ra_idx.elem (1) = a_ra_idx (1) + c;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	796
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	797 elem (ra_idx) = a.elem (a_ra_idx);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	798
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	799 increment_index (a_ra_idx, a_dv);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	800 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	801 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	802 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	803 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	804 ("Array<T>::insert: invalid indexing operation");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	805
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	806 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	807 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	808
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	809 FloatComplexNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	810 FloatComplexNDArray::insert (const FloatComplexNDArray& a, octave_idx_type r, octave_idx_type c)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	811 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	812 Array<FloatComplex>::insert (a, r, c);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	813 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	814 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	815
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	816 FloatComplexNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	817 FloatComplexNDArray::insert (const FloatComplexNDArray& a, const Array<octave_idx_type>& ra_idx)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	818 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	819 Array<FloatComplex>::insert (a, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	820 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	821 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	822
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	823 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	824 FloatComplexNDArray::matrix_value (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	825 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	826 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	827
8981 ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	828 if (ndims () == 2)
10352 a3635bc1ea19 remove Array2 Jaroslav Hajek <highegg@gmail.com> parents: 10350 diff changeset	829 retval = FloatComplexMatrix (Array<FloatComplex> (*this));
8981 ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	830 else
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	831 (*current_liboctave_error_handler)
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	832 ("invalid conversion of FloatComplexNDArray to FloatComplexMatrix");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	833
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	834 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	835 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	836
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	837 void
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	838 FloatComplexNDArray::increment_index (Array<octave_idx_type>& ra_idx,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	839 const dim_vector& dimensions,
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	840 int start_dimension)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	841 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	842 ::increment_index (ra_idx, dimensions, start_dimension);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	843 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	844
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	845 octave_idx_type
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	846 FloatComplexNDArray::compute_index (Array<octave_idx_type>& ra_idx,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	847 const dim_vector& dimensions)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	848 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	849 return ::compute_index (ra_idx, dimensions);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	850 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	851
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	852 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	853 FloatComplexNDArray::diag (octave_idx_type k) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	854 {
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	855 return MArray<FloatComplex>::diag (k);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	856 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	857
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	858 // This contains no information on the array structure !!!
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	859 std::ostream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	860 operator << (std::ostream& os, const FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	861 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	862 octave_idx_type nel = a.nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	863
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	864 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	865 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	866 os << " ";
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	867 octave_write_complex (os, a.elem (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	868 os << "\n";
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	869 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	870 return os;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	871 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	872
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	873 std::istream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	874 operator >> (std::istream& is, FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	875 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	876 octave_idx_type nel = a.nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	877
8999 dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	878 if (nel > 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	879 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	880 FloatComplex tmp;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	881 for (octave_idx_type i = 0; i < nel; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	882 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	883 tmp = octave_read_value<FloatComplex> (is);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	884 if (is)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	885 a.elem (i) = tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	886 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	887 goto done;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	888 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	889 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	890
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	891 done:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	892
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	893 return is;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	894 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	895
10329 83fa590b8a09 simplify min/max definitions in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	896 MINMAX_FCNS (FloatComplexNDArray, FloatComplex)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	897
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	898 NDS_CMP_OPS (FloatComplexNDArray, FloatComplex)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	899 NDS_BOOL_OPS (FloatComplexNDArray, FloatComplex)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	900
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	901 SND_CMP_OPS (FloatComplex, FloatComplexNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	902 SND_BOOL_OPS (FloatComplex, FloatComplexNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	903
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	904 NDND_CMP_OPS (FloatComplexNDArray, FloatComplexNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	905 NDND_BOOL_OPS (FloatComplexNDArray, FloatComplexNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	906
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	907 FloatComplexNDArray& operator *= (FloatComplexNDArray& a, float s)
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	908 {
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	909 if (a.is_shared ())
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	910 a = a * s;
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	911 else
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	912 do_ms_inplace_op<FloatComplex, float> (a, s, mx_inline_mul2);
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	913 return a;
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	914 }
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	915
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	916 FloatComplexNDArray& operator /= (FloatComplexNDArray& a, float s)
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	917 {
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	918 if (a.is_shared ())
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	919 a = a / s;
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	920 else
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	921 do_ms_inplace_op<FloatComplex, float> (a, s, mx_inline_div2);
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	922 return a;
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	923 }
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	924
9743 26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	925 BSXFUN_STDOP_DEFS_MXLOOP (FloatComplexNDArray)
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	926 BSXFUN_STDREL_DEFS_MXLOOP (FloatComplexNDArray)
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	927
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9825 diff changeset	928 BSXFUN_OP_DEF_MXLOOP (pow, FloatComplexNDArray, mx_inline_pow)

Mercurial > octave

annotate liboctave/fCNDArray.cc @ 11008:3622db30ff05