octave-lyh: liboctave/fNDArray.cc annotate

annotate liboctave/fNDArray.cc @ 14435:f312918f16d2

doc: Add cross-references between fgets and fgetl in docstrings. file-io.cc (fgets, fgetl): Add cross-references between fgets and fgetl in docstrings.

author	Rik <octave@nomad.inbox5.com>
date	Mon, 05 Mar 2012 13:18:51 -0800
parents	72c96de7a403
children	e8e86ae3abbc

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
14138 72c96de7a403 maint: update copyright notices for 2012 John W. Eaton <jwe@octave.org> parents: 13756 diff changeset	4 Copyright (C) 1996-2012 John W. Eaton
9601 a9b37bae1802 add a couple of missing copyright statements Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	5 Copyright (C) 2009 VZLU Prague, a.s.
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	6
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	7 This file is part of Octave.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	8
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	9 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	10 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	11 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	12 option) any later version.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	13
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	14 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	15 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	16 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	17 for more details.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	18
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	19 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	20 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	21 <http://www.gnu.org/licenses/>.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	22
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 #ifdef HAVE_CONFIG_H
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	26 #include <config.h>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	27 #endif
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	28
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	29 #include <cfloat>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	30
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	31 #include <vector>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	32
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	33 #include "Array-util.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	34 #include "f77-fcn.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	35 #include "fNDArray.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	36 #include "functor.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	37 #include "lo-error.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"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	40 #include "mx-base.h"
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	41 #include "mx-op-defs.h"
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	42 #include "oct-fftw.h"
8377 25bc2d31e1bf improve OCTAVE_LOCAL_BUFFER Jaroslav Hajek <highegg@gmail.com> parents: 7922 diff changeset	43 #include "oct-locbuf.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	44
9743 26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	45 #include "bsxfun-defs.cc"
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	46
8956 d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	47 FloatNDArray::FloatNDArray (const charNDArray& a)
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	48 : MArray<float> (a.dims ())
8956 d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	49 {
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	50 octave_idx_type n = a.numel ();
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	51 for (octave_idx_type i = 0; i < n; i++)
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	52 xelem (i) = static_cast<unsigned char> (a(i));
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	53 }
d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	54
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	55 #if defined (HAVE_FFTW)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	56
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	57 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	58 FloatNDArray::fourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	59 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	60 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	61
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	62 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	63 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	64
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	65 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	66 octave_idx_type n = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	67
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	68 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	69 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	70
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	71 octave_idx_type howmany = numel () / dv (dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	72 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	73 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	74 octave_idx_type dist = (stride == 1 ? n : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	75
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	76 const float *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	77 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	78 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	79
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	80 // 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	81 for (octave_idx_type k = 0; k < nloop; k++)
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	82 octave_fftw::fft (in + k * stride * n, out + k * stride * n,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	83 n, howmany, stride, dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	84
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	85 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	88 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	89 FloatNDArray::ifourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	90 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	91 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	92
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	93 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	94 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	95
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	96 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	97 octave_idx_type n = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	98
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	99 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	100 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	101
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	102 octave_idx_type howmany = numel () / dv (dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	103 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	104 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	105 octave_idx_type dist = (stride == 1 ? n : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	106
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	107 FloatComplexNDArray retval (*this);
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++)
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	112 octave_fftw::ifft (out + k * stride * n, out + k * stride * n,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	113 n, howmany, stride, dist);
7789 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 FloatNDArray::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 float *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 FloatNDArray::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 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	147 FloatComplex *out = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	148 octave_idx_type howmany = numel() / dv(0) / dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	149 octave_idx_type dist = dv(0) * dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	150
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	151 for (octave_idx_type i=0; i < howmany; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	152 octave_fftw::ifftNd (out + idist, out + idist, 2, dv2);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	153
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	154 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	155 }
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 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	158 FloatNDArray::fourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	159 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	160 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	161 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	162
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	163 const float *in (fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	164 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	165 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	166
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	167 octave_fftw::fftNd (in, out, rank, dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	168
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	169 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	170 }
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 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	173 FloatNDArray::ifourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	174 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	175 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	176 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	177
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	178 FloatComplexNDArray tmp (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	179 FloatComplex *in (tmp.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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	189
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	190 extern "C"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	191 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	192 // Note that the original complex fft routines were not written for
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	193 // float complex arguments. They have been modified by adding an
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	194 // implicit float precision (a-h,o-z) statement at the beginning of
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	195 // each subroutine.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	196
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	197 F77_RET_T
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	198 F77_FUNC (cffti, CFFTI) (const octave_idx_type&, FloatComplex*);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	199
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	200 F77_RET_T
11518 141b3fb5cef7 style fixes John W. Eaton <jwe@octave.org> parents: 11130 diff changeset	201 F77_FUNC (cfftf, CFFTF) (const octave_idx_type&, FloatComplex*,
141b3fb5cef7 style fixes John W. Eaton <jwe@octave.org> parents: 11130 diff changeset	202 FloatComplex*);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	203
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	204 F77_RET_T
11518 141b3fb5cef7 style fixes John W. Eaton <jwe@octave.org> parents: 11130 diff changeset	205 F77_FUNC (cfftb, CFFTB) (const octave_idx_type&, FloatComplex*,
141b3fb5cef7 style fixes John W. Eaton <jwe@octave.org> parents: 11130 diff changeset	206 FloatComplex*);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	207 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	208
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	209 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	210 FloatNDArray::fourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	211 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	212 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	213
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	214 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	215 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	216
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	217 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	218 octave_idx_type npts = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	219 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	220 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	221 FloatComplex *pwsave = wsave.fortran_vec ();
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_LOCAL_BUFFER (FloatComplex, tmp, npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	224
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	225 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	226
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	227 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	228 stride *= dv(i);
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 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	231 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	232 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	233 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	234
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	235 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	236
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	237 for (octave_idx_type k = 0; k < nloop; k++)
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 for (octave_idx_type j = 0; j < howmany; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	240 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	241 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	242
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	243 for (octave_idx_type i = 0; i < npts; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	244 tmp[i] = elem((i + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	245
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	246 F77_FUNC (cfftf, CFFTF) (npts, tmp, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	247
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	248 for (octave_idx_type i = 0; i < npts; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	249 retval ((i + knpts)stride + j*dist) = tmp[i];
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	250 }
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	253 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	254 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	255
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	256 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	257 FloatNDArray::ifourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	258 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	259 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	260
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	261 if (dim > dv.length () \|\| dim < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	262 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	263
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	264 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	265 octave_idx_type npts = dv(dim);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	266 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	267 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	268 FloatComplex *pwsave = wsave.fortran_vec ();
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_LOCAL_BUFFER (FloatComplex, tmp, npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	271
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	272 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	273
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	274 for (int i = 0; i < dim; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	275 stride *= dv(i);
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 octave_idx_type howmany = numel () / npts;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	278 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	279 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	280 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	281
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	282 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	283
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	284 for (octave_idx_type k = 0; k < nloop; k++)
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 for (octave_idx_type j = 0; j < howmany; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	287 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	288 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	289
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	290 for (octave_idx_type i = 0; i < npts; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	291 tmp[i] = elem((i + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	292
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	293 F77_FUNC (cfftb, CFFTB) (npts, tmp, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	294
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	295 for (octave_idx_type i = 0; i < npts; i++)
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	296 retval ((i + knpts)stride + j*dist) = tmp[i] /
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	297 static_cast<float> (npts);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	298 }
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	301 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	302 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	303
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	304 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	305 FloatNDArray::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	306 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	307 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	308 dim_vector dv2 (dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	309 int rank = 2;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	310 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	311 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	312
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	313 for (int i = 0; i < rank; i++)
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 npts = dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	316 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	317 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	318 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	319 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	320 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	321
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	322 octave_idx_type howmany = numel () / npts;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	323 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	324 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	325 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	326 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	327
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	328 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	329
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	330 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	331 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	332 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	333 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	334 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	335
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	336 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	337 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	338
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	339 F77_FUNC (cfftf, CFFTF) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	340
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	341 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	342 retval ((l + knpts)stride + j*dist) = prow[l];
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	343 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	344 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	345
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	346 stride *= dv2(i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	349 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	350 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	351
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	352 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	353 FloatNDArray::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	354 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	355 dim_vector dv = dims();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	356 dim_vector dv2 (dv(0), dv(1));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	357 int rank = 2;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	358 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	359 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	360
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	361 for (int i = 0; i < rank; i++)
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 npts = dv2(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	364 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	365 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	366 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	367 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	368 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	369
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	370 octave_idx_type howmany = numel () / npts;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	371 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	372 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	373 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	374 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	375
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	376 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	377
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	378 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	379 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	380 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	381 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	382 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	383
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	384 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	385 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	386
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	387 F77_FUNC (cfftb, CFFTB) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	388
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	389 for (octave_idx_type l = 0; l < npts; l++)
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	390 retval ((l + knpts)stride + j*dist) = prow[l] /
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	391 static_cast<float> (npts);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	392 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	393 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	394
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	395 stride *= dv2(i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	398 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	399 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	400
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	401 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	402 FloatNDArray::fourierNd (void) const
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 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	405 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	406 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	407 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	408
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	409 for (int i = 0; i < rank; i++)
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 npts = dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	412 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	413 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	414 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	415 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	416 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	417
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	418 octave_idx_type howmany = numel () / npts;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	419 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	420 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	421 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	422 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	423
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	424 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	425
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	426 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	427 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	428 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	429 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	430 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	431
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	432 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	433 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	434
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	435 F77_FUNC (cfftf, CFFTF) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	436
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	437 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	438 retval ((l + knpts)stride + j*dist) = prow[l];
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	439 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	440 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	441
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	442 stride *= dv(i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	445 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	446 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	447
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	448 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	449 FloatNDArray::ifourierNd (void) const
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 dim_vector dv = dims ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	452 int rank = dv.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	453 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	454 octave_idx_type stride = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	455
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	456 for (int i = 0; i < rank; i++)
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 npts = dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	459 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	460 Array<FloatComplex> wsave (nn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	461 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	462 Array<FloatComplex> row (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	463 FloatComplex *prow = row.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	464
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	465 octave_idx_type howmany = numel () / npts;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	466 howmany = (stride == 1 ? howmany :
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	467 (howmany > stride ? stride : howmany));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	468 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	469 octave_idx_type dist = (stride == 1 ? npts : 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	470
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	471 F77_FUNC (cffti, CFFTI) (npts, pwsave);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	472
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	473 for (octave_idx_type k = 0; k < nloop; k++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	474 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	475 for (octave_idx_type j = 0; j < howmany; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	476 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	477 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	478
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	479 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	480 prow[l] = retval ((l + knpts)stride + j*dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	481
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	482 F77_FUNC (cfftb, CFFTB) (npts, prow, pwsave);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	483
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	484 for (octave_idx_type l = 0; l < npts; l++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	485 retval ((l + knpts)stride + j*dist) = prow[l] /
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	486 static_cast<float> (npts);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	487 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	488 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	489
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	490 stride *= dv(i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	491 }
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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	494 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	495
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	496 #endif
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 // unary operations
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	499
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	500 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	501 FloatNDArray::operator ! (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	502 {
11130 7c573eb981eb consistently give error for operator not applied to NaN values John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	503 if (any_element_is_nan ())
7c573eb981eb consistently give error for operator not applied to NaN values John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	504 gripe_nan_to_logical_conversion ();
7c573eb981eb consistently give error for operator not applied to NaN values John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	505
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	506 return do_mx_unary_op<bool, float> (*this, mx_inline_not);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	507 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	508
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	509 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	510 FloatNDArray::any_element_is_negative (bool neg_zero) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	511 {
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 11008 diff changeset	512 return (neg_zero ? test_all (xnegative_sign)
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 11008 diff changeset	513 : do_mx_check<float> (*this, mx_inline_any_negative));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	514 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	515
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	516 bool
13756 6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13012 diff changeset	517 FloatNDArray::any_element_is_positive (bool neg_zero) const
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13012 diff changeset	518 {
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13012 diff changeset	519 return (neg_zero ? test_all (xpositive_sign)
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13012 diff changeset	520 : do_mx_check<float> (*this, mx_inline_any_positive));
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13012 diff changeset	521 }
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13012 diff changeset	522
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13012 diff changeset	523 bool
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	524 FloatNDArray::any_element_is_nan (void) const
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	525 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	526 return do_mx_check<float> (*this, mx_inline_any_nan);
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	527 }
7789 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 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	530 FloatNDArray::any_element_is_inf_or_nan (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	531 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	532 return ! do_mx_check<float> (*this, mx_inline_all_finite);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	535 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	536 FloatNDArray::any_element_not_one_or_zero (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	537 {
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 11008 diff changeset	538 return ! test_all (xis_one_or_zero);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	541 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	542 FloatNDArray::all_elements_are_zero (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	543 {
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 11008 diff changeset	544 return test_all (xis_zero);
7789 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 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	548 FloatNDArray::all_elements_are_int_or_inf_or_nan (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	549 {
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 11008 diff changeset	550 return test_all (xis_int_or_inf_or_nan);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	551 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	552
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	553 // Return nonzero if any element of M is not an integer. Also extract
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	554 // the largest and smallest 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	555
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	556 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	557 FloatNDArray::all_integers (float& max_val, float& min_val) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	558 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	559 octave_idx_type nel = nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	560
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	561 if (nel > 0)
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 = elem (0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	564 min_val = elem (0);
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	567 return false;
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 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	570 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	571 float val = elem (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	572
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	573 if (val > max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	574 max_val = val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	575
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	576 if (val < min_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	577 min_val = val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	578
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 11008 diff changeset	579 if (! xisinteger (val))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	580 return false;
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	583 return true;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	586 bool
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	587 FloatNDArray::all_integers (void) const
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	588 {
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 11008 diff changeset	589 return test_all (xisinteger);
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	590 }
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	591
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	592 bool
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	593 FloatNDArray::too_large_for_float (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	594 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	595 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 // FIXME -- this is not quite the right thing.
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 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	601 FloatNDArray::all (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	602 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	603 return do_mx_red_op<bool, float> (*this, dim, mx_inline_all);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	604 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	605
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	606 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	607 FloatNDArray::any (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	608 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	609 return do_mx_red_op<bool, float> (*this, dim, mx_inline_any);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	610 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	611
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	612 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	613 FloatNDArray::cumprod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	614 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	615 return do_mx_cum_op<float, float> (*this, dim, mx_inline_cumprod);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	616 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	617
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	618 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	619 FloatNDArray::cumsum (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	620 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	621 return do_mx_cum_op<float, float> (*this, dim, mx_inline_cumsum);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	624 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	625 FloatNDArray::prod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	626 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	627 return do_mx_red_op<float, float> (*this, dim, mx_inline_prod);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	628 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	629
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	630 FloatNDArray
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	631 FloatNDArray::sum (int dim) const
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	632 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	633 return do_mx_red_op<float, float> (*this, dim, mx_inline_sum);
7789 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
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	636 NDArray
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	637 FloatNDArray::dsum (int dim) const
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	638 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	639 return do_mx_red_op<double, float> (*this, dim, mx_inline_dsum);
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	640 }
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	641
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	642 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	643 FloatNDArray::sumsq (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	644 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	645 return do_mx_red_op<float, float> (*this, dim, mx_inline_sumsq);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	648 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	649 FloatNDArray::max (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	650 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	651 return do_mx_minmax_op<float> (*this, dim, mx_inline_max);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	652 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	653
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	654 FloatNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	655 FloatNDArray::max (Array<octave_idx_type>& idx_arg, int dim) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	656 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	657 return do_mx_minmax_op<float> (*this, idx_arg, dim, mx_inline_max);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	660 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	661 FloatNDArray::min (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	662 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	663 return do_mx_minmax_op<float> (*this, dim, mx_inline_min);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	666 FloatNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	667 FloatNDArray::min (Array<octave_idx_type>& idx_arg, int dim) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	668 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	669 return do_mx_minmax_op<float> (*this, idx_arg, dim, mx_inline_min);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	670 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	671
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	672 FloatNDArray
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	673 FloatNDArray::cummax (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	674 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	675 return do_mx_cumminmax_op<float> (*this, dim, mx_inline_cummax);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	676 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	677
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	678 FloatNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	679 FloatNDArray::cummax (Array<octave_idx_type>& idx_arg, int dim) const
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	680 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	681 return do_mx_cumminmax_op<float> (*this, idx_arg, dim, mx_inline_cummax);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	682 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	683
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	684 FloatNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	685 FloatNDArray::cummin (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	686 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	687 return do_mx_cumminmax_op<float> (*this, dim, mx_inline_cummin);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	688 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	689
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	690 FloatNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	691 FloatNDArray::cummin (Array<octave_idx_type>& idx_arg, int dim) const
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	692 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	693 return do_mx_cumminmax_op<float> (*this, idx_arg, dim, mx_inline_cummin);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	694 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	695
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	696 FloatNDArray
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	697 FloatNDArray::diff (octave_idx_type order, int dim) const
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	698 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	699 return do_mx_diff_op<float> (*this, dim, order, mx_inline_diff);
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	700 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	701
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	702 FloatNDArray
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	703 FloatNDArray::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	704 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	705 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	706 insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	707 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	708 }
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 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	711 FloatNDArray::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	712 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	713 FloatComplexNDArray retval (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	714 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	715 retval.insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	716 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	717 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	718
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	719 charNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	720 FloatNDArray::concat (const charNDArray& rb, const Array<octave_idx_type>& ra_idx)
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 charNDArray retval (dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	723 octave_idx_type nel = numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	724
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	725 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	726 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	727 float d = elem (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	728
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	729 if (xisnan (d))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	730 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	731 (*current_liboctave_error_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	732 ("invalid conversion from NaN to character");
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	733 return retval;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	734 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	735 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	736 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	737 octave_idx_type ival = NINTbig (d);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	738
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	739 if (ival < 0 \|\| ival > UCHAR_MAX)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	740 // FIXME -- is there something
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	741 // better we could do? Should we warn the user?
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	742 ival = 0;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	743
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	744 retval.elem (i) = static_cast<char>(ival);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	745 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	746 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	747
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	748 if (rb.numel () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	749 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	750
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	751 retval.insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	752 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	753 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	754
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	755 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	756 real (const FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	757 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	758 return do_mx_unary_op<float, FloatComplex> (a, mx_inline_real);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	759 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	760
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	761 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	762 imag (const FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	763 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	764 return do_mx_unary_op<float, FloatComplex> (a, mx_inline_imag);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	765 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	766
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	767 FloatNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	768 FloatNDArray::insert (const FloatNDArray& a, octave_idx_type r, octave_idx_type c)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	769 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	770 Array<float>::insert (a, r, c);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	771 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	772 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	773
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	774 FloatNDArray&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	775 FloatNDArray::insert (const FloatNDArray& a, const Array<octave_idx_type>& ra_idx)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	776 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	777 Array<float>::insert (a, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	778 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	779 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	780
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	781 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	782 FloatNDArray::abs (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	783 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	784 return do_mx_unary_map<float, float, std::abs> (*this);
7789 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
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	787 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	788 FloatNDArray::isnan (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	789 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	790 return do_mx_unary_map<bool, float, xisnan> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	791 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	792
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	793 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	794 FloatNDArray::isinf (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	795 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	796 return do_mx_unary_map<bool, float, xisinf> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	797 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	798
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	799 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	800 FloatNDArray::isfinite (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	801 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	802 return do_mx_unary_map<bool, float, xfinite> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	803 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	804
8981 ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	805 FloatMatrix
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	806 FloatNDArray::matrix_value (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	807 {
8981 ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	808 FloatMatrix retval;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	809
8981 ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	810 if (ndims () == 2)
10352 a3635bc1ea19 remove Array2 Jaroslav Hajek <highegg@gmail.com> parents: 10350 diff changeset	811 retval = FloatMatrix (Array<float> (*this));
8981 ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	812 else
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	813 (*current_liboctave_error_handler)
ed5055b0a476 fix & simplify ndarray->matrix conversions Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	814 ("invalid conversion of FloatNDArray to FloatMatrix");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	815
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	816 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	817 }
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 void
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	820 FloatNDArray::increment_index (Array<octave_idx_type>& ra_idx,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	821 const dim_vector& dimensions,
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	822 int start_dimension)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	823 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	824 ::increment_index (ra_idx, dimensions, start_dimension);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	827 octave_idx_type
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	828 FloatNDArray::compute_index (Array<octave_idx_type>& ra_idx,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	829 const dim_vector& dimensions)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	830 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	831 return ::compute_index (ra_idx, dimensions);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	832 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	833
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	834 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	835 FloatNDArray::diag (octave_idx_type k) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	836 {
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	837 return MArray<float>::diag (k);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	840 // This contains no information on the array structure !!!
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	841 std::ostream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	842 operator << (std::ostream& os, const FloatNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	843 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	844 octave_idx_type nel = a.nelem ();
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 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	847 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	848 os << " ";
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	849 octave_write_float (os, a.elem (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	850 os << "\n";
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	851 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	852 return os;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	855 std::istream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	856 operator >> (std::istream& is, FloatNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	857 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	858 octave_idx_type nel = a.nelem ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	859
8999 dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	860 if (nel > 0)
7789 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 float tmp;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	863 for (octave_idx_type i = 0; i < nel; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	864 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	865 tmp = octave_read_value<float> (is);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	866 if (is)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	867 a.elem (i) = tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	868 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	869 goto done;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	870 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	871 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	872
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	873 done:
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 is;
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
10329 83fa590b8a09 simplify min/max definitions in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	878 MINMAX_FCNS (FloatNDArray, float)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	879
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	880 NDS_CMP_OPS (FloatNDArray, float)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	881 NDS_BOOL_OPS (FloatNDArray, float)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	882
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	883 SND_CMP_OPS (float, FloatNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	884 SND_BOOL_OPS (float, FloatNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	885
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	886 NDND_CMP_OPS (FloatNDArray, FloatNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	887 NDND_BOOL_OPS (FloatNDArray, FloatNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	888
9743 26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	889 BSXFUN_STDOP_DEFS_MXLOOP (FloatNDArray)
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	890 BSXFUN_STDREL_DEFS_MXLOOP (FloatNDArray)
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	891
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	892 BSXFUN_OP_DEF_MXLOOP (pow, FloatNDArray, mx_inline_pow)
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	893 BSXFUN_OP2_DEF_MXLOOP (pow, FloatComplexNDArray, FloatComplexNDArray,
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	894 FloatNDArray, mx_inline_pow)
13012 15eefbd9d4e8 Implement a few missing automatic bsxfun power operators Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11586 diff changeset	895 BSXFUN_OP2_DEF_MXLOOP (pow, FloatComplexNDArray, FloatNDArray,
15eefbd9d4e8 Implement a few missing automatic bsxfun power operators Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11586 diff changeset	896 FloatComplexNDArray, mx_inline_pow)

Mercurial > hg > octave-lyh

annotate liboctave/fNDArray.cc @ 14435:f312918f16d2