octave-lyh: liboctave/fCNDArray.cc annotate

annotate liboctave/fCNDArray.cc @ 9612:66970dd627f6

further liboctave design improvements

author	Jaroslav Hajek <highegg@gmail.com>
date	Fri, 04 Sep 2009 11:22:53 +0200
parents	a9b37bae1802
children	192d94cff6c1

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
8956 d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	46 FloatComplexNDArray::FloatComplexNDArray (const charNDArray& a)
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	47 : MArrayN<FloatComplex> (a.dims ())
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	48 {
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	49 octave_idx_type n = a.numel ();
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	50 for (octave_idx_type i = 0; i < n; i++)
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	51 xelem (i) = static_cast<unsigned char> (a(i));
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	52 }
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	53
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	54 #if defined (HAVE_FFTW)
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	55
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	56 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	57 FloatComplexNDArray::fourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	58 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	59 dim_vector dv = dims ();
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 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	62 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	63
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	64 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	65 octave_idx_type n = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	66
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	67 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	68 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	69
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	70 octave_idx_type howmany = numel () / dv (dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	71 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	72 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	73 octave_idx_type dist = (stride == 1 ? n : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	74
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	75 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	76 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	77 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	78
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	79 // 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	80 for (octave_idx_type k = 0; k < nloop; k++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	81 octave_fftw::fft (in + k * stride * n, out + k * stride * n,
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	82 n, howmany, stride, dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	83
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	84 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	87 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	88 FloatComplexNDArray::ifourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	89 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	90 dim_vector dv = dims ();
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 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	93 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	94
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	95 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	96 octave_idx_type n = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	97
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	98 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	99 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	100
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	101 octave_idx_type howmany = numel () / dv (dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	102 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	103 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	104 octave_idx_type dist = (stride == 1 ? n : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	105
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	106 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	107 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	108 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	109
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	110 // 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	111 for (octave_idx_type k = 0; k < nloop; k++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	112 octave_fftw::ifft (in + k * stride * n, out + k * stride * n,
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	113 n, howmany, stride, dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	114
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	115 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	118 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	119 FloatComplexNDArray::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	120 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	121 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	122 if (dv.length () < 2)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	123 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	124
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	125 dim_vector dv2(dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	126 const FloatComplex *in = fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	127 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	128 FloatComplex *out = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	129 octave_idx_type howmany = numel() / dv(0) / dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	130 octave_idx_type dist = dv(0) * dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	131
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	132 for (octave_idx_type i=0; i < howmany; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	133 octave_fftw::fftNd (in + idist, out + idist, 2, dv2);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	134
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	135 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	138 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	139 FloatComplexNDArray::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	140 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	141 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	142 if (dv.length () < 2)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	143 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	144
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	145 dim_vector dv2(dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	146 const FloatComplex *in = fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	147 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	148 FloatComplex *out = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	149 octave_idx_type howmany = numel() / dv(0) / dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	150 octave_idx_type dist = dv(0) * dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	151
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	152 for (octave_idx_type i=0; i < howmany; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	153 octave_fftw::ifftNd (in + idist, out + idist, 2, dv2);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	154
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	155 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	158 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	159 FloatComplexNDArray::fourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	160 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	161 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	162 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	163
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	164 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	165 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	166 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	167
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	168 octave_fftw::fftNd (in, out, rank, dv);
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 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	173 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	174 FloatComplexNDArray::ifourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	175 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	176 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	177 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	178
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	179 const FloatComplex *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	180 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	181 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	182
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	183 octave_fftw::ifftNd (in, out, rank, dv);
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 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	188 #else
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	189
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	190 extern "C"
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 F77_RET_T
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	193 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	194
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	195 F77_RET_T
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	196 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	197
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	198 F77_RET_T
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	199 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	200 }
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	201
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	202 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	203 FloatComplexNDArray::fourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	204 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	205 dim_vector dv = dims ();
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 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	208 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	209
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	210 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	211 octave_idx_type npts = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	212 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	213 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	214 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	215
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	216 OCTAVE_LOCAL_BUFFER (FloatComplex, tmp, npts);
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_idx_type stride = 1;
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 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	221 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	222
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	223 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	224 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	225 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	226 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	227
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	228 F77_FUNC (cffti, CFFTI) (npts, pwsave);
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 for (octave_idx_type k = 0; k < nloop; k++)
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 j = 0; j < howmany; j++)
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 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	235
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	236 for (octave_idx_type i = 0; i < npts; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	237 tmp[i] = elem((i + knpts)stride + j*dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	238
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	239 F77_FUNC (cfftf, CFFTF) (npts, tmp, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	240
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	241 for (octave_idx_type i = 0; i < npts; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	242 retval ((i + knpts)stride + j*dist) = tmp[i];
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	243 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	244 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	245
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	246 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	249 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	250 FloatComplexNDArray::ifourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	251 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	252 dim_vector dv = dims ();
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 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	255 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	256
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	257 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	258 octave_idx_type npts = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	259 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	260 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	261 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	262
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	263 OCTAVE_LOCAL_BUFFER (FloatComplex, tmp, npts);
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_idx_type stride = 1;
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 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	268 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	269
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	270 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	271 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	272 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	273 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	274
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	275 F77_FUNC (cffti, CFFTI) (npts, pwsave);
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 for (octave_idx_type k = 0; k < nloop; k++)
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 j = 0; j < howmany; j++)
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 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	282
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	283 for (octave_idx_type i = 0; i < npts; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	284 tmp[i] = elem((i + knpts)stride + j*dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	285
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	286 F77_FUNC (cfftb, CFFTB) (npts, tmp, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	287
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	288 for (octave_idx_type i = 0; i < npts; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	289 retval ((i + knpts)stride + j*dist) = tmp[i] /
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	290 static_cast<float> (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	291 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	292 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	293
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	294 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	297 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	298 FloatComplexNDArray::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	299 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	300 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	301 dim_vector dv2 (dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	302 int rank = 2;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	303 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	304 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	305
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	306 for (int i = 0; i < rank; i++)
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 octave_idx_type npts = dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	309 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	310 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	311 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	312 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	313 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	314
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	315 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	316 howmany = (stride == 1 ? howmany :
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	317 (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	318 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	319 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	320
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	321 F77_FUNC (cffti, CFFTI) (npts, pwsave);
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 for (octave_idx_type k = 0; k < nloop; k++)
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 j = 0; j < howmany; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	326 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	327 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	328
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	329 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	330 prow[l] = retval ((l + knpts)stride + j*dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	331
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	332 F77_FUNC (cfftf, CFFTF) (npts, prow, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	333
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	334 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	335 retval ((l + knpts)stride + j*dist) = prow[l];
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	336 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	337 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	338
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	339 stride *= dv2(i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	342 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	345 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	346 FloatComplexNDArray::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	347 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	348 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	349 dim_vector dv2 (dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	350 int rank = 2;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	351 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	352 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	353
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	354 for (int i = 0; i < rank; i++)
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 octave_idx_type npts = dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	357 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	358 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	359 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	360 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	361 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	362
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	363 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	364 howmany = (stride == 1 ? howmany :
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	365 (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	366 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	367 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	368
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	369 F77_FUNC (cffti, CFFTI) (npts, pwsave);
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 for (octave_idx_type k = 0; k < nloop; k++)
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 j = 0; j < howmany; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	374 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	375 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	376
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	377 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	378 prow[l] = retval ((l + knpts)stride + j*dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	379
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	380 F77_FUNC (cfftb, CFFTB) (npts, prow, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	381
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	382 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	383 retval ((l + knpts)stride + j*dist) = prow[l] /
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	384 static_cast<float> (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	385 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	386 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	387
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	388 stride *= dv2(i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	391 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	394 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	395 FloatComplexNDArray::fourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	396 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	397 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	398 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	399 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	400 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	401
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	402 for (int i = 0; i < rank; i++)
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 octave_idx_type npts = dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	405 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	406 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	407 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	408 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	409 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	410
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	411 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	412 howmany = (stride == 1 ? howmany :
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	413 (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	414 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	415 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	416
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	417 F77_FUNC (cffti, CFFTI) (npts, pwsave);
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 for (octave_idx_type k = 0; k < nloop; k++)
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 j = 0; j < howmany; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	422 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	423 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	424
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	425 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	426 prow[l] = retval ((l + knpts)stride + j*dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	427
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	428 F77_FUNC (cfftf, CFFTF) (npts, prow, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	429
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	430 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	431 retval ((l + knpts)stride + j*dist) = prow[l];
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	432 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	433 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	434
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	435 stride *= dv(i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	438 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	441 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	442 FloatComplexNDArray::ifourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	443 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	444 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	445 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	446 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	447 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	448
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	449 for (int i = 0; i < rank; i++)
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 octave_idx_type npts = dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	452 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	453 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	454 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	455 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	456 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	457
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	458 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	459 howmany = (stride == 1 ? howmany :
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	460 (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	461 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	462 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	463
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	464 F77_FUNC (cffti, CFFTI) (npts, pwsave);
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 for (octave_idx_type k = 0; k < nloop; k++)
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 j = 0; j < howmany; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	469 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	470 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	471
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	472 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	473 prow[l] = retval ((l + knpts)stride + j*dist);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	474
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	475 F77_FUNC (cfftb, CFFTB) (npts, prow, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	476
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	477 for (octave_idx_type l = 0; l < npts; l++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	478 retval ((l + knpts)stride + j*dist) = prow[l] /
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	479 static_cast<float> (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	480 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	481 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	482
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	483 stride *= dv(i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	486 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	489 #endif
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 // unary operations
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 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	494 FloatComplexNDArray::operator ! (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	495 {
9553 0c72d9284087 further bool ops tweaks Jaroslav Hajek <highegg@gmail.com> parents: 9551 diff changeset	496 return do_mx_unary_op<boolNDArray, FloatComplexNDArray> (*this, mx_inline_not);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	497 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	498
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	499 // FIXME -- this is not quite the right thing.
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 bool
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	502 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	503 {
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	504 octave_idx_type nel = nelem ();
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	505
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	506 for (octave_idx_type i = 0; i < nel; i++)
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 FloatComplex val = elem (i);
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	509 if (xisnan (val))
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	510 return true;
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	511 }
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	512 return false;
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	513 }
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	514
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	515 bool
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	516 FloatComplexNDArray::any_element_is_inf_or_nan (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	517 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	518 octave_idx_type nel = nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	519
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	520 for (octave_idx_type i = 0; i < nel; i++)
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 FloatComplex val = elem (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	523 if (xisinf (val) \|\| xisnan (val))
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	524 return true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	525 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	526 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	527 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	528
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	529 // Return true if no elements have imaginary components.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	530
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	531 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	532 FloatComplexNDArray::all_elements_are_real (void) const
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 octave_idx_type nel = nelem ();
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 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	537 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	538 float ip = std::imag (elem (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	539
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	540 if (ip != 0.0 \|\| lo_ieee_signbit (ip))
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	541 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	542 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	543
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	544 return true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	545 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	546
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	547 // 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	548 // 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	549 // 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	550
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	551 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	552 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	553 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	554 octave_idx_type nel = nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	555
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	556 if (nel > 0)
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 FloatComplex val = elem (0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	559
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	560 float r_val = std::real (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	561 float i_val = std::imag (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	562
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	563 max_val = r_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	564 min_val = r_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	565
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	566 if (i_val > max_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	567 max_val = i_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	568
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	569 if (i_val < max_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	570 min_val = i_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	571 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	572 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	573 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	574
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	575 for (octave_idx_type i = 0; i < nel; i++)
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 FloatComplex val = elem (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	578
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	579 float r_val = std::real (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	580 float i_val = std::imag (val);
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 if (r_val > max_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	583 max_val = r_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	584
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	585 if (i_val > max_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	586 max_val = i_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	587
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	588 if (r_val < min_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	589 min_val = r_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	590
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	591 if (i_val < min_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	592 min_val = i_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	593
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	594 if (D_NINT (r_val) != r_val \|\| D_NINT (i_val) != i_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	595 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	596 }
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 return true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	599 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	600
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	601 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	602 FloatComplexNDArray::too_large_for_float (void) const
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 octave_idx_type nel = nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	605
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	606 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	607 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	608 FloatComplex val = elem (i);
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 float r_val = std::real (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	611 float i_val = std::imag (val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	612
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	613 if ((! (xisnan (r_val) \|\| xisinf (r_val))
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	614 && fabs (r_val) > FLT_MAX)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	615 \|\| (! (xisnan (i_val) \|\| xisinf (i_val))
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	616 && fabs (i_val) > FLT_MAX))
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	617 return true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	618 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	619
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	620 return false;
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 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	624 FloatComplexNDArray::all (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	625 {
9227 8145f2255276 use explicit template qualifs to please Intel C++ and MSVC++ Jaroslav Hajek <highegg@gmail.com> parents: 8999 diff changeset	626 return do_mx_red_op<boolNDArray, FloatComplex> (*this, dim, mx_inline_all);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	627 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	628
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	629 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	630 FloatComplexNDArray::any (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	631 {
9227 8145f2255276 use explicit template qualifs to please Intel C++ and MSVC++ Jaroslav Hajek <highegg@gmail.com> parents: 8999 diff changeset	632 return do_mx_red_op<boolNDArray, FloatComplex> (*this, dim, mx_inline_any);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	635 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	636 FloatComplexNDArray::cumprod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	637 {
9227 8145f2255276 use explicit template qualifs to please Intel C++ and MSVC++ Jaroslav Hajek <highegg@gmail.com> parents: 8999 diff changeset	638 return do_mx_cum_op<FloatComplexNDArray, FloatComplex> (*this, dim, mx_inline_cumprod);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	639 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	640
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::cumsum (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	643 {
9227 8145f2255276 use explicit template qualifs to please Intel C++ and MSVC++ Jaroslav Hajek <highegg@gmail.com> parents: 8999 diff changeset	644 return do_mx_cum_op<FloatComplexNDArray, FloatComplex> (*this, dim, mx_inline_cumsum);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	648 FloatComplexNDArray::prod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	649 {
9227 8145f2255276 use explicit template qualifs to please Intel C++ and MSVC++ Jaroslav Hajek <highegg@gmail.com> parents: 8999 diff changeset	650 return do_mx_red_op<FloatComplexNDArray, FloatComplex> (*this, dim, mx_inline_prod);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	651 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	652
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	653 FloatComplexNDArray
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	654 FloatComplexNDArray::sum (int dim) const
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	655 {
9227 8145f2255276 use explicit template qualifs to please Intel C++ and MSVC++ Jaroslav Hajek <highegg@gmail.com> parents: 8999 diff changeset	656 return do_mx_red_op<FloatComplexNDArray, FloatComplex> (*this, dim, mx_inline_sum);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	657 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	658
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	659 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	660 FloatComplexNDArray::sumsq (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	661 {
9227 8145f2255276 use explicit template qualifs to please Intel C++ and MSVC++ Jaroslav Hajek <highegg@gmail.com> parents: 8999 diff changeset	662 return do_mx_red_op<FloatNDArray, FloatComplex> (*this, dim, mx_inline_sumsq);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	665 FloatComplexNDArray
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	666 FloatComplexNDArray::diff (octave_idx_type order, int dim) const
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	667 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	668 return do_mx_diff_op<FloatComplexNDArray> (*this, dim, order, mx_inline_diff);
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	669 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	670
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	671 FloatComplexNDArray
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	672 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	673 {
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 insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	676 return *this;
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 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	680 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	681 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	682 FloatComplexNDArray tmp (rb);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	683 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	684 insert (tmp, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	685 return *this;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	688 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	689 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	690 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	691 FloatComplexNDArray retval (ra);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	692 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	693 retval.insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	694 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	695 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	696
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	697 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	698
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	699 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	700 FloatComplexNDArray::max (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	701 {
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	702 return do_mx_minmax_op<FloatComplexNDArray> (*this, dim, mx_inline_max);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	705 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	706 FloatComplexNDArray::max (ArrayN<octave_idx_type>& idx_arg, int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	707 {
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	708 return do_mx_minmax_op<FloatComplexNDArray> (*this, idx_arg, dim, mx_inline_max);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	709 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	710
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	711 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	712 FloatComplexNDArray::min (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	713 {
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	714 return do_mx_minmax_op<FloatComplexNDArray> (*this, dim, mx_inline_min);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	715 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	716
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	717 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	718 FloatComplexNDArray::min (ArrayN<octave_idx_type>& idx_arg, int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	719 {
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	720 return do_mx_minmax_op<FloatComplexNDArray> (*this, idx_arg, dim, mx_inline_min);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	721 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	722
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	723 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	724 FloatComplexNDArray::cummax (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	725 {
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	726 return do_mx_cumminmax_op<FloatComplexNDArray> (*this, dim, mx_inline_cummax);
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
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	729 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	730 FloatComplexNDArray::cummax (ArrayN<octave_idx_type>& idx_arg, int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	731 {
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	732 return do_mx_cumminmax_op<FloatComplexNDArray> (*this, idx_arg, dim, mx_inline_cummax);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	733 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	734
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	735 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	736 FloatComplexNDArray::cummin (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	737 {
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	738 return do_mx_cumminmax_op<FloatComplexNDArray> (*this, dim, mx_inline_cummin);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	739 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	740
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	741 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	742 FloatComplexNDArray::cummin (ArrayN<octave_idx_type>& idx_arg, int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	743 {
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	744 return do_mx_cumminmax_op<FloatComplexNDArray> (*this, idx_arg, dim, mx_inline_cummin);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	745 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	746
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	747 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	748 FloatComplexNDArray::abs (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	749 {
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	750 return FloatNDArray (mx_inline_cabs_dup (data (), length ()),
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	751 dims ());
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	752 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	753
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	754 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	755 FloatComplexNDArray::isnan (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	756 {
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	757 return ArrayN<bool> (fastmap<bool> (xisnan));
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	758 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	759
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	760 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	761 FloatComplexNDArray::isinf (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	762 {
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	763 return ArrayN<bool> (fastmap<bool> (xisinf));
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	764 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	765
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	766 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	767 FloatComplexNDArray::isfinite (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	768 {
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	769 return ArrayN<bool> (fastmap<bool> (xfinite));
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	770 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	771
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	772 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	773 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	774 {
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	775 return FloatComplexNDArray (mx_inline_conj_dup (a.data (), a.length ()),
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	776 a.dims ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	777 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	778
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	779 FloatComplexNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	780 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	781 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	782 dim_vector a_dv = a.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	783
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	784 int n = a_dv.length ();
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 if (n == dimensions.length ())
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 Array<octave_idx_type> a_ra_idx (a_dv.length (), 0);
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 a_ra_idx.elem (0) = r;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	791 a_ra_idx.elem (1) = c;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	792
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	793 for (int i = 0; i < n; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	794 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	795 if (a_ra_idx (i) < 0 \|\| (a_ra_idx (i) + a_dv (i)) > dimensions (i))
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	796 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	797 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	798 ("Array<T>::insert: range error for insert");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	799 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	800 }
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	803 a_ra_idx.elem (0) = 0;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	804 a_ra_idx.elem (1) = 0;
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 octave_idx_type n_elt = a.numel ();
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 // IS make_unique () NECCESSARY HERE??
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	809
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	810 for (octave_idx_type i = 0; i < n_elt; i++)
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<octave_idx_type> ra_idx = a_ra_idx;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	813
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	814 ra_idx.elem (0) = a_ra_idx (0) + r;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	815 ra_idx.elem (1) = a_ra_idx (1) + c;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	816
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	817 elem (ra_idx) = a.elem (a_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 increment_index (a_ra_idx, a_dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	820 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	823 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	824 ("Array<T>::insert: invalid indexing operation");
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 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	827 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	828
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	829 FloatComplexNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	830 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	831 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	832 Array<FloatComplex>::insert (a, r, c);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	833 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	834 }
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 FloatComplexNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	837 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	838 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	839 Array<FloatComplex>::insert (a, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	840 return *this;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	843 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	844 FloatComplexNDArray::matrix_value (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	845 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	846 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	847
8981 ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	848 if (ndims () == 2)
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	849 retval = FloatComplexMatrix (Array2<FloatComplex> (*this));
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	850 else
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	851 (*current_liboctave_error_handler)
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	852 ("invalid conversion of FloatComplexNDArray to FloatComplexMatrix");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	853
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	854 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	855 }
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 void
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	858 FloatComplexNDArray::increment_index (Array<octave_idx_type>& ra_idx,
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	859 const dim_vector& dimensions,
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	860 int start_dimension)
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 ::increment_index (ra_idx, dimensions, start_dimension);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	865 octave_idx_type
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	866 FloatComplexNDArray::compute_index (Array<octave_idx_type>& ra_idx,
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	867 const dim_vector& dimensions)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	868 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	869 return ::compute_index (ra_idx, dimensions);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	870 }
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 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	873 FloatComplexNDArray::diag (octave_idx_type k) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	874 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	875 return MArrayN<FloatComplex>::diag (k);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	876 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	877
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	878 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	879 FloatComplexNDArray::map (dmapper fcn) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	880 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	881 return MArrayN<FloatComplex>::map<float> (func_ptr (fcn));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	882 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	883
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	884 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	885 FloatComplexNDArray::map (cmapper fcn) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	886 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	887 return MArrayN<FloatComplex>::map<FloatComplex> (func_ptr (fcn));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	888 }
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 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	891 FloatComplexNDArray::map (bmapper fcn) const
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 MArrayN<FloatComplex>::map<bool> (func_ptr (fcn));
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	896 // This contains no information on the array structure !!!
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	897 std::ostream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	898 operator << (std::ostream& os, const FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	899 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	900 octave_idx_type nel = a.nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	901
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	902 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	903 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	904 os << " ";
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	905 octave_write_complex (os, a.elem (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	906 os << "\n";
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	907 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	908 return os;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	909 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	910
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	911 std::istream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	912 operator >> (std::istream& is, FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	913 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	914 octave_idx_type nel = a.nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	915
8999 dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	916 if (nel > 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	917 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	918 FloatComplex tmp;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	919 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	920 {
9469 c6edba80dfae sanity checks for loading sparse matrices John W. Eaton <jwe@octave.org> parents: 9227 diff changeset	921 tmp = octave_read_value<FloatComplex> (is);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	922 if (is)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	923 a.elem (i) = tmp;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	924 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	925 goto done;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	926 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	927 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	928
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	929 done:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	930
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	931 return is;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	932 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	933
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	934 // FIXME -- it would be nice to share code among the min/max
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	935 // functions below.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	936
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	937 #define EMPTY_RETURN_CHECK(T) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	938 if (nel == 0) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	939 return T (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	940
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	941 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	942 min (const FloatComplex& c, const FloatComplexNDArray& m)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	943 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	944 dim_vector dv = m.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	945 int nel = dv.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	946
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	947 EMPTY_RETURN_CHECK (FloatComplexNDArray);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	948
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	949 FloatComplexNDArray result (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	950
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	951 for (int i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	952 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	953 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	954 result (i) = xmin (c, m (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	955 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	956
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	957 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	958 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	959
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	960 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	961 min (const FloatComplexNDArray& m, const FloatComplex& c)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	962 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	963 dim_vector dv = m.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	964 int nel = dv.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	965
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	966 EMPTY_RETURN_CHECK (FloatComplexNDArray);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	967
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	968 FloatComplexNDArray result (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	969
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	970 for (int i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	971 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	972 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	973 result (i) = xmin (c, m (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	974 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	975
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	976 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	977 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	978
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	979 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	980 min (const FloatComplexNDArray& a, const FloatComplexNDArray& b)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	981 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	982 dim_vector dv = a.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	983 int nel = dv.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	984
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	985 if (dv != b.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	986 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	987 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	988 ("two-arg min expecting args of same size");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	989 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	990 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	991
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	992 EMPTY_RETURN_CHECK (FloatComplexNDArray);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	993
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	994 FloatComplexNDArray result (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	995
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	996 for (int i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	997 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	998 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	999 result (i) = xmin (a (i), b (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1000 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1001
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1002 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1003 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1004
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1005 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1006 max (const FloatComplex& c, const FloatComplexNDArray& m)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1007 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1008 dim_vector dv = m.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1009 int nel = dv.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1010
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1011 EMPTY_RETURN_CHECK (FloatComplexNDArray);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1012
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1013 FloatComplexNDArray result (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1014
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1015 for (int i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1016 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1017 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1018 result (i) = xmax (c, m (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1019 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1020
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1021 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1022 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1023
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1024 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1025 max (const FloatComplexNDArray& m, const FloatComplex& c)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1026 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1027 dim_vector dv = m.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1028 int nel = dv.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1029
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1030 EMPTY_RETURN_CHECK (FloatComplexNDArray);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1031
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1032 FloatComplexNDArray result (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1033
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1034 for (int i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1035 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1036 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1037 result (i) = xmax (c, m (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1038 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1039
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1040 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1041 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1042
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1043 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1044 max (const FloatComplexNDArray& a, const FloatComplexNDArray& b)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1045 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1046 dim_vector dv = a.dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1047 int nel = dv.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1048
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1049 if (dv != b.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1050 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1051 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1052 ("two-arg max expecting args of same size");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1053 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1054 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1055
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1056 EMPTY_RETURN_CHECK (FloatComplexNDArray);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1057
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1058 FloatComplexNDArray result (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1059
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1060 for (int i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1061 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1062 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1063 result (i) = xmax (a (i), b (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1064 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1065
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1066 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1067 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1068
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	1069 NDS_CMP_OPS (FloatComplexNDArray, FloatComplex)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	1070 NDS_BOOL_OPS (FloatComplexNDArray, FloatComplex)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1071
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	1072 SND_CMP_OPS (FloatComplex, FloatComplexNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	1073 SND_BOOL_OPS (FloatComplex, FloatComplexNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1074
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	1075 NDND_CMP_OPS (FloatComplexNDArray, FloatComplexNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	1076 NDND_BOOL_OPS (FloatComplexNDArray, FloatComplexNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1077
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1078 FloatComplexNDArray& operator *= (FloatComplexNDArray& a, float s)
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1079 {
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1080 if (a.is_shared ())
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	1081 a = a * s;
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	1082 else
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	1083 do_ms_inplace_op<FloatComplexNDArray, float> (a, s, mx_inline_mul2);
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1084 return a;
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1085 }
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1086
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1087 FloatComplexNDArray& operator /= (FloatComplexNDArray& a, float s)
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1088 {
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1089 if (a.is_shared ())
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	1090 a = a / s;
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	1091 else
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	1092 do_ms_inplace_op<FloatComplexNDArray, float> (a, s, mx_inline_div2);
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1093 return a;
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1094 }
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	1095
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1096 /*
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1097 ;;; Local Variables: ***
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1098 ;;; mode: C++ ***
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1099 ;;; End: ***
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1100 */

Mercurial > hg > octave-lyh

annotate liboctave/fCNDArray.cc @ 9612:66970dd627f6