octave: liboctave/array/fCNDArray.cc annotate

annotate liboctave/array/fCNDArray.cc @ 29931:7faff48840eb

prefer data over fortran_vec for read-only access to data See also the discussion here: https://octave.discourse.group/t/rename-uses-of-fortran-vec-to-data-for-clarity/1439 * Array.h (const T * Array<T>::fortran_vec (void) const): Deprecate. Change all uses to call data instead.

author	John W. Eaton <jwe@octave.org>
date	Fri, 30 Jul 2021 11:46:05 -0400
parents	be669d935fb6
children	796f54d4ddbf

rev	line source
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	2 //
29358 0a5b15007766 update Octave Project Developers copyright for the new year John W. Eaton <jwe@octave.org> parents: 27923 diff changeset	3 // Copyright (C) 1996-2021 The Octave Project Developers
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	4 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	7 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	9 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	14 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	19 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	23 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	24 ////////////////////////////////////////////////////////////////////////
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	25
21724 aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef" John W. Eaton <jwe@octave.org> parents: 21723 diff changeset	26 #if defined (HAVE_CONFIG_H)
21301 40de9f8f23a6 Use '#include "config.h"' rather than <config.h>. Rik <rik@octave.org> parents: 21202 diff changeset	27 # include "config.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	28 #endif
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	29
23443 3f1bf237908b maint: Eliminate <cfloat.h> header from liboctave files. Rik <rik@octave.org> parents: 23220 diff changeset	30 #include <complex>
25438 cb1606f78f6b prefer <istream>, <ostream>, or <iosfwd> to <iostream> where possible John W. Eaton <jwe@octave.org> parents: 25054 diff changeset	31 #include <istream>
cb1606f78f6b prefer <istream>, <ostream>, or <iosfwd> to <iostream> where possible John W. Eaton <jwe@octave.org> parents: 25054 diff changeset	32 #include <ostream>
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	33
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	34 #include "Array-util.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	35 #include "f77-fcn.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	36 #include "fCNDArray.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	37 #include "lo-ieee.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	38 #include "lo-mappers.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	39 #include "mx-base.h"
8774 b756ce0002db split implementation and interface in mx-op-defs and MArray-defs Jaroslav Hajek <highegg@gmail.com> parents: 8751 diff changeset	40 #include "mx-op-defs.h"
19269 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 18725 diff changeset	41 #include "mx-fcnda-fs.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	42 #include "oct-fftw.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 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 FloatComplexNDArray::FloatComplexNDArray (const charNDArray& a)
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	48 : MArray<FloatComplex> (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)
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	56
7789 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 FloatComplexNDArray::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
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	62 if (dim > dv.ndims () \|\| dim < 0)
7789 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
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	71 octave_idx_type howmany = numel () / dv(dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	72 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	73 octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
7789 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
29931 7faff48840eb prefer data over fortran_vec for read-only access to data John W. Eaton <jwe@octave.org> parents: 29887 diff changeset	76 const FloatComplex *in (data ());
7789 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++)
23058 5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	82 octave::fftw::fft (in + k * stride * n, out + k * stride * n,
5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 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 FloatComplexNDArray::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
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	93 if (dim > dv.ndims () \|\| dim < 0)
7789 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
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	102 octave_idx_type howmany = numel () / dv(dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	103 howmany = (stride == 1 ? howmany : (howmany > stride ? stride : howmany));
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	104 octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
7789 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
29931 7faff48840eb prefer data over fortran_vec for read-only access to data John W. Eaton <jwe@octave.org> parents: 29887 diff changeset	107 const FloatComplex *in (data ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	108 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	109 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	110
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	111 // 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	112 for (octave_idx_type k = 0; k < nloop; k++)
23058 5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	113 octave::fftw::ifft (in + k * stride * n, out + k * stride * n,
5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	114 n, howmany, stride, dist);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	115
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	116 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	119 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	120 FloatComplexNDArray::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	121 {
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14844 diff changeset	122 dim_vector dv = dims ();
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	123 if (dv.ndims () < 2)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	124 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	125
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	126 dim_vector dv2 (dv(0), dv(1));
29931 7faff48840eb prefer data over fortran_vec for read-only access to data John W. Eaton <jwe@octave.org> parents: 29887 diff changeset	127 const FloatComplex *in = data ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	128 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	129 FloatComplex *out = retval.fortran_vec ();
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14844 diff changeset	130 octave_idx_type howmany = numel () / dv(0) / dv(1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	131 octave_idx_type dist = dv(0) * dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	132
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	133 for (octave_idx_type i=0; i < howmany; i++)
23058 5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	134 octave::fftw::fftNd (in + idist, out + idist, 2, dv2);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	135
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	136 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	139 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	140 FloatComplexNDArray::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	141 {
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14844 diff changeset	142 dim_vector dv = dims ();
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	143 if (dv.ndims () < 2)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	144 return FloatComplexNDArray ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	145
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	146 dim_vector dv2 (dv(0), dv(1));
29931 7faff48840eb prefer data over fortran_vec for read-only access to data John W. Eaton <jwe@octave.org> parents: 29887 diff changeset	147 const FloatComplex *in = data ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	148 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	149 FloatComplex *out = retval.fortran_vec ();
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14844 diff changeset	150 octave_idx_type howmany = numel () / dv(0) / dv(1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	151 octave_idx_type dist = dv(0) * dv(1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	152
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	153 for (octave_idx_type i=0; i < howmany; i++)
23058 5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	154 octave::fftw::ifftNd (in + idist, out + idist, 2, dv2);
7789 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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	157 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	158
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	159 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	160 FloatComplexNDArray::fourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	161 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	162 dim_vector dv = dims ();
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	163 int rank = dv.ndims ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	164
29931 7faff48840eb prefer data over fortran_vec for read-only access to data John W. Eaton <jwe@octave.org> parents: 29887 diff changeset	165 const FloatComplex *in (data ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	166 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	167 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	168
23058 5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	169 octave::fftw::fftNd (in, out, rank, dv);
7789 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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	172 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	173
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	174 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	175 FloatComplexNDArray::ifourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	176 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	177 dim_vector dv = dims ();
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	178 int rank = dv.ndims ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	179
29931 7faff48840eb prefer data over fortran_vec for read-only access to data John W. Eaton <jwe@octave.org> parents: 29887 diff changeset	180 const FloatComplex *in (data ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	181 FloatComplexNDArray retval (dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	182 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	183
23058 5839d16828cb move fftw classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	184 octave::fftw::ifftNd (in, out, rank, dv);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	185
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	186 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	189 #else
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9513 diff changeset	190
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	191 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	192 FloatComplexNDArray::fourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	193 {
26516 53d03e2e4948 silence unused parameter compiler warnings when building without FFTW Mike Miller <mtmiller@octave.org> parents: 26376 diff changeset	194 octave_unused_parameter (dim);
53d03e2e4948 silence unused parameter compiler warnings when building without FFTW Mike Miller <mtmiller@octave.org> parents: 26376 diff changeset	195
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	196 (*current_liboctave_error_handler)
59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	197 ("support for FFTW was unavailable or disabled when liboctave was built");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	198
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	199 return FloatComplexNDArray ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	200 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	201
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	202 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	203 FloatComplexNDArray::ifourier (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	204 {
26516 53d03e2e4948 silence unused parameter compiler warnings when building without FFTW Mike Miller <mtmiller@octave.org> parents: 26376 diff changeset	205 octave_unused_parameter (dim);
53d03e2e4948 silence unused parameter compiler warnings when building without FFTW Mike Miller <mtmiller@octave.org> parents: 26376 diff changeset	206
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	207 (*current_liboctave_error_handler)
59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	208 ("support for FFTW was unavailable or disabled when liboctave was built");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	209
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	210 return FloatComplexNDArray ();
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	213 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	214 FloatComplexNDArray::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	215 {
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	216 (*current_liboctave_error_handler)
59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	217 ("support for FFTW was unavailable or disabled when liboctave was built");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	218
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	219 return FloatComplexNDArray ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	220 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	221
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	222 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	223 FloatComplexNDArray::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	224 {
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	225 (*current_liboctave_error_handler)
59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	226 ("support for FFTW was unavailable or disabled when liboctave was built");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	227
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	228 return FloatComplexNDArray ();
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	231 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	232 FloatComplexNDArray::fourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	233 {
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	234 (*current_liboctave_error_handler)
59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	235 ("support for FFTW was unavailable or disabled when liboctave was built");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	236
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	237 return FloatComplexNDArray ();
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	240 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	241 FloatComplexNDArray::ifourierNd (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	242 {
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	243 (*current_liboctave_error_handler)
59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	244 ("support for FFTW was unavailable or disabled when liboctave was built");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	245
25586 59f4fda5c548 remove fftpack sources John W. Eaton <jwe@octave.org> parents: 25438 diff changeset	246 return FloatComplexNDArray ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	247 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	248
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	249 #endif
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	250
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	251 // unary operations
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 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	254 FloatComplexNDArray::operator ! (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	255 {
11130 7c573eb981eb consistently give error for operator not applied to NaN values John W. Eaton <jwe@octave.org> parents: 11008 diff changeset	256 if (any_element_is_nan ())
22327 d0562b3159c7 move more classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22323 diff changeset	257 octave::err_nan_to_logical_conversion ();
11130 7c573eb981eb consistently give error for operator not applied to NaN values John W. Eaton <jwe@octave.org> parents: 11008 diff changeset	258
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	259 return do_mx_unary_op<bool, FloatComplex> (*this, mx_inline_not);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	260 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	261
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	262 // FIXME: this is not quite the right thing.
7789 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 bool
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	265 FloatComplexNDArray::any_element_is_nan (void) const
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	266 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	267 return do_mx_check<FloatComplex> (*this, mx_inline_any_nan);
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	268 }
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	269
935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7789 diff changeset	270 bool
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	271 FloatComplexNDArray::any_element_is_inf_or_nan (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	272 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	273 return ! do_mx_check<FloatComplex> (*this, mx_inline_all_finite);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	274 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	275
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	276 // Return true if no elements have imaginary components.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	277
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	278 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	279 FloatComplexNDArray::all_elements_are_real (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	280 {
11008 3622db30ff05 simplify some array tests in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10362 diff changeset	281 return do_mx_check<FloatComplex> (*this, mx_inline_all_real);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	282 }
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 // Return nonzero if any element of CM has a non-integer real or
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	285 // imaginary part. Also extract the largest and smallest (real or
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	286 // imaginary) values and return them in MAX_VAL and MIN_VAL.
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	287
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	288 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	289 FloatComplexNDArray::all_integers (float& max_val, float& min_val) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	290 {
20228 00cf2847355d Deprecate Array::nelem() and Range::nelem() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	291 octave_idx_type nel = numel ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	292
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	293 if (nel > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	294 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	295 FloatComplex val = elem (0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	296
22274 edcad35c364f don't rely on std:: overloads of arg, conj, imag, and real for real args John W. Eaton <jwe@octave.org> parents: 22261 diff changeset	297 float r_val = val.real ();
edcad35c364f don't rely on std:: overloads of arg, conj, imag, and real for real args John W. Eaton <jwe@octave.org> parents: 22261 diff changeset	298 float i_val = val.imag ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	299
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	300 max_val = r_val;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	301 min_val = r_val;
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 if (i_val > max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	304 max_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	305
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	306 if (i_val < max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	307 min_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	308 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	309 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	310 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	311
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	312 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	313 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	314 FloatComplex val = elem (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	315
22274 edcad35c364f don't rely on std:: overloads of arg, conj, imag, and real for real args John W. Eaton <jwe@octave.org> parents: 22261 diff changeset	316 float r_val = val.real ();
edcad35c364f don't rely on std:: overloads of arg, conj, imag, and real for real args John W. Eaton <jwe@octave.org> parents: 22261 diff changeset	317 float i_val = val.imag ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	318
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	319 if (r_val > max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	320 max_val = r_val;
7789 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 if (i_val > max_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	323 max_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	324
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	325 if (r_val < min_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	326 min_val = r_val;
7789 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 if (i_val < min_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	329 min_val = i_val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	330
22402 4caa7b28d183 maint: Style check C++ code in liboctave/ Rik <rik@octave.org> parents: 22327 diff changeset	331 if (octave::math::x_nint (r_val) != r_val
4caa7b28d183 maint: Style check C++ code in liboctave/ Rik <rik@octave.org> parents: 22327 diff changeset	332 \|\| octave::math::x_nint (i_val) != i_val)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	333 return false;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	334 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	335
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	336 return true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	337 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	338
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	339 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	340 FloatComplexNDArray::too_large_for_float (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	341 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	342 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	343 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	344
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	345 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	346 FloatComplexNDArray::all (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	347 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	348 return do_mx_red_op<bool, FloatComplex> (*this, dim, mx_inline_all);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	349 }
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 boolNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	352 FloatComplexNDArray::any (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	353 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	354 return do_mx_red_op<bool, FloatComplex> (*this, dim, mx_inline_any);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	355 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	356
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	357 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	358 FloatComplexNDArray::cumprod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	359 {
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	360 return do_mx_cum_op<FloatComplex, FloatComplex> (*this, dim,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	361 mx_inline_cumprod);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	364 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	365 FloatComplexNDArray::cumsum (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	366 {
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	367 return do_mx_cum_op<FloatComplex, FloatComplex> (*this, dim,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	368 mx_inline_cumsum);
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	371 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	372 FloatComplexNDArray::prod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	373 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	374 return do_mx_red_op<FloatComplex, FloatComplex> (*this, dim, mx_inline_prod);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	375 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	376
18725 8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 17769 diff changeset	377 ComplexNDArray
8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 17769 diff changeset	378 FloatComplexNDArray::dprod (int dim) const
8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 17769 diff changeset	379 {
8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 17769 diff changeset	380 return do_mx_red_op<Complex, FloatComplex> (*this, dim, mx_inline_dprod);
8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 17769 diff changeset	381 }
8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 17769 diff changeset	382
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	383 FloatComplexNDArray
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	384 FloatComplexNDArray::sum (int dim) const
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	385 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	386 return do_mx_red_op<FloatComplex, FloatComplex> (*this, dim, mx_inline_sum);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	387 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	388
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	389 ComplexNDArray
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	390 FloatComplexNDArray::dsum (int dim) const
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	391 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	392 return do_mx_red_op<Complex, FloatComplex> (*this, dim, mx_inline_dsum);
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	393 }
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9612 diff changeset	394
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	395 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	396 FloatComplexNDArray::sumsq (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	397 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	398 return do_mx_red_op<float, FloatComplex> (*this, dim, mx_inline_sumsq);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	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
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	402 FloatComplexNDArray::diff (octave_idx_type order, int dim) const
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	403 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	404 return do_mx_diff_op<FloatComplex> (*this, dim, order, mx_inline_diff);
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	405 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	406
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 9469 diff changeset	407 FloatComplexNDArray
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	408 FloatComplexNDArray::concat (const FloatComplexNDArray& rb,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	409 const Array<octave_idx_type>& ra_idx)
7789 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 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	412 insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	413 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	414 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	415
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	416 FloatComplexNDArray
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	417 FloatComplexNDArray::concat (const FloatNDArray& rb,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	418 const Array<octave_idx_type>& ra_idx)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	419 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	420 FloatComplexNDArray tmp (rb);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	421 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	422 insert (tmp, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	423 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	424 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	425
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	426 FloatComplexNDArray
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	427 concat (NDArray& ra, FloatComplexNDArray& rb,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	428 const Array<octave_idx_type>& ra_idx)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	429 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	430 FloatComplexNDArray retval (ra);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	431 if (rb.numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	432 retval.insert (rb, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	433 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	434 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	435
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	436 static const FloatComplex FloatComplex_NaN_result (octave::numeric_limits<float>::NaN (),
bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	437 octave::numeric_limits<float>::NaN ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	438
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	439 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	440 FloatComplexNDArray::max (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	441 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	442 return do_mx_minmax_op<FloatComplex> (*this, dim, mx_inline_max);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	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 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	446 FloatComplexNDArray::max (Array<octave_idx_type>& idx_arg, int dim) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	447 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	448 return do_mx_minmax_op<FloatComplex> (*this, idx_arg, dim, mx_inline_max);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	449 }
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 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	452 FloatComplexNDArray::min (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	453 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	454 return do_mx_minmax_op<FloatComplex> (*this, dim, mx_inline_min);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	455 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	456
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	457 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	458 FloatComplexNDArray::min (Array<octave_idx_type>& idx_arg, int dim) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	459 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	460 return do_mx_minmax_op<FloatComplex> (*this, idx_arg, dim, mx_inline_min);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	461 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	462
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	463 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	464 FloatComplexNDArray::cummax (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	465 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	466 return do_mx_cumminmax_op<FloatComplex> (*this, dim, mx_inline_cummax);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	467 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	468
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	469 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	470 FloatComplexNDArray::cummax (Array<octave_idx_type>& idx_arg, int dim) const
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	471 {
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	472 return do_mx_cumminmax_op<FloatComplex> (*this, idx_arg, dim,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	473 mx_inline_cummax);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	474 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	475
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	476 FloatComplexNDArray
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	477 FloatComplexNDArray::cummin (int dim) const
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	478 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	479 return do_mx_cumminmax_op<FloatComplex> (*this, dim, mx_inline_cummin);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	480 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	481
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	482 FloatComplexNDArray
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9721 diff changeset	483 FloatComplexNDArray::cummin (Array<octave_idx_type>& idx_arg, int dim) const
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	484 {
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	485 return do_mx_cumminmax_op<FloatComplex> (*this, idx_arg, dim,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	486 mx_inline_cummin);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	487 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8774 diff changeset	488
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	489 FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	490 FloatComplexNDArray::abs (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	491 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	492 return do_mx_unary_map<float, FloatComplex, std::abs> (*this);
8650 a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	493 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	494
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	495 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	496 FloatComplexNDArray::isnan (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	497 {
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	498 return do_mx_unary_map<bool, FloatComplex, octave::math::isnan> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	499 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	500
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	501 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	502 FloatComplexNDArray::isinf (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	503 {
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	504 return do_mx_unary_map<bool, FloatComplex, octave::math::isinf> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	505 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	506
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	507 boolNDArray
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	508 FloatComplexNDArray::isfinite (void) const
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	509 {
23564 7049da1648c0 Deprecate octave::math::finite in favor of octave::math::isfinite. Rik <rik@octave.org> parents: 23534 diff changeset	510 return do_mx_unary_map<bool, FloatComplex, octave::math::isfinite> (*this);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	511 }
a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8981 diff changeset	512
8650 a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	513 FloatComplexNDArray
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	514 conj (const FloatComplexNDArray& a)
a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	515 {
23534 b6498c088fca maint: Don't write '> >' for declaration of templates that use templates. Rik <rik@octave.org> parents: 23461 diff changeset	516 return do_mx_unary_map<FloatComplex, FloatComplex, std::conj<float>> (a);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	517 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	518
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	519 FloatComplexNDArray&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	520 FloatComplexNDArray::insert (const NDArray& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	521 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	522 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	523 dim_vector a_dv = a.dims ();
29887 be669d935fb6 use m_prefix for data members in array classes John W. Eaton <jwe@octave.org> parents: 29359 diff changeset	524 dim_vector dv = dims ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	525
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	526 int n = a_dv.ndims ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	527
29887 be669d935fb6 use m_prefix for data members in array classes John W. Eaton <jwe@octave.org> parents: 29359 diff changeset	528 if (n == dv.ndims ())
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	529 {
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21562 diff changeset	530 Array<octave_idx_type> a_ra_idx (dim_vector (a_dv.ndims (), 1), 0);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	531
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	532 a_ra_idx.elem (0) = r;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	533 a_ra_idx.elem (1) = c;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	534
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	535 for (int i = 0; i < n; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	536 {
29887 be669d935fb6 use m_prefix for data members in array classes John W. Eaton <jwe@octave.org> parents: 29359 diff changeset	537 if (a_ra_idx(i) < 0 \|\| (a_ra_idx(i) + a_dv(i)) > dv(i))
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21100 diff changeset	538 (*current_liboctave_error_handler)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21100 diff changeset	539 ("Array<T>::insert: range error for insert");
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	540 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	541
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	542 a_ra_idx.elem (0) = 0;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	543 a_ra_idx.elem (1) = 0;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	544
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	545 octave_idx_type n_elt = a.numel ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	546
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	547 // IS make_unique () NECESSARY HERE?
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	548
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	549 for (octave_idx_type i = 0; i < n_elt; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	550 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	551 Array<octave_idx_type> ra_idx = a_ra_idx;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	552
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	553 ra_idx.elem (0) = a_ra_idx(0) + r;
b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	554 ra_idx.elem (1) = a_ra_idx(1) + c;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	555
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	556 elem (ra_idx) = a.elem (a_ra_idx);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	557
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	558 increment_index (a_ra_idx, a_dv);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	559 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	560 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	561 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	562 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	563 ("Array<T>::insert: invalid indexing operation");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	564
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	565 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	566 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	567
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	568 FloatComplexNDArray&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	569 FloatComplexNDArray::insert (const FloatComplexNDArray& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	570 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	571 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	572 Array<FloatComplex>::insert (a, r, c);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	573 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	574 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	575
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	576 FloatComplexNDArray&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	577 FloatComplexNDArray::insert (const FloatComplexNDArray& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	578 const Array<octave_idx_type>& ra_idx)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	579 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	580 Array<FloatComplex>::insert (a, ra_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	581 return *this;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	584 void
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	585 FloatComplexNDArray::increment_index (Array<octave_idx_type>& ra_idx,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	586 const dim_vector& dimensions,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	587 int start_dimension)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	588 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	589 ::increment_index (ra_idx, dimensions, start_dimension);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	590 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	591
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	592 octave_idx_type
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	593 FloatComplexNDArray::compute_index (Array<octave_idx_type>& ra_idx,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	594 const dim_vector& dimensions)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	595 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	596 return ::compute_index (ra_idx, dimensions);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	597 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	598
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	599 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	600 FloatComplexNDArray::diag (octave_idx_type k) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	601 {
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10329 diff changeset	602 return MArray<FloatComplex>::diag (k);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	603 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	604
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	605 FloatComplexNDArray
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	606 FloatComplexNDArray::diag (octave_idx_type m, octave_idx_type n) const
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	607 {
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	608 return MArray<FloatComplex>::diag (m, n);
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	609 }
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	610
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	611 // This contains no information on the array structure !!!
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	612 std::ostream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	613 operator << (std::ostream& os, const FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	614 {
20228 00cf2847355d Deprecate Array::nelem() and Range::nelem() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	615 octave_idx_type nel = a.numel ();
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 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	618 {
23807 336f89b6208b Use character literals 'c' rather than string literals "c" when possible. Rik <rik@octave.org> parents: 23564 diff changeset	619 os << ' ';
28628 83172e1c77f2 refactor octave_read_* and octave_write_* functions John W. Eaton <jwe@octave.org> parents: 27923 diff changeset	620 octave::write_value<Complex> (os, a.elem (i));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	621 os << "\n";
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 return os;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	624 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	625
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	626 std::istream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	627 operator >> (std::istream& is, FloatComplexNDArray& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	628 {
20228 00cf2847355d Deprecate Array::nelem() and Range::nelem() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	629 octave_idx_type nel = a.numel ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	630
8999 dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	631 if (nel > 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	632 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	633 FloatComplex tmp;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	634 for (octave_idx_type i = 0; i < nel; i++)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	635 {
28628 83172e1c77f2 refactor octave_read_* and octave_write_* functions John W. Eaton <jwe@octave.org> parents: 27923 diff changeset	636 tmp = octave::read_value<FloatComplex> (is);
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	637 if (is)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	638 a.elem (i) = tmp;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	639 else
21169 40051830f89b maint: Replace more instances of goto in liboctave with other constructs. Rik <rik@octave.org> parents: 21136 diff changeset	640 return is;
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	641 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	642 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	643
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	644 return is;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	645 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	646
10329 83fa590b8a09 simplify min/max definitions in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	647 MINMAX_FCNS (FloatComplexNDArray, FloatComplex)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	648
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	649 NDS_CMP_OPS (FloatComplexNDArray, FloatComplex)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	650 NDS_BOOL_OPS (FloatComplexNDArray, FloatComplex)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	651
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	652 SND_CMP_OPS (FloatComplex, FloatComplexNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	653 SND_BOOL_OPS (FloatComplex, FloatComplexNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	654
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	655 NDND_CMP_OPS (FloatComplexNDArray, FloatComplexNDArray)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	656 NDND_BOOL_OPS (FloatComplexNDArray, FloatComplexNDArray)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	657
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	658 FloatComplexNDArray& operator *= (FloatComplexNDArray& a, float s)
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	659 {
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	660 if (a.is_shared ())
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	661 a = a * s;
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	662 else
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	663 do_ms_inplace_op<FloatComplex, float> (a, s, mx_inline_mul2);
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	664 return a;
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	665 }
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	666
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	667 FloatComplexNDArray& operator /= (FloatComplexNDArray& a, float s)
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	668 {
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	669 if (a.is_shared ())
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	670 a = a / s;
66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	671 else
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10352 diff changeset	672 do_ms_inplace_op<FloatComplex, float> (a, s, mx_inline_div2);
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	673 return a;
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	674 }
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9523 diff changeset	675
9743 26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	676 BSXFUN_STDOP_DEFS_MXLOOP (FloatComplexNDArray)
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	677 BSXFUN_STDREL_DEFS_MXLOOP (FloatComplexNDArray)
26abff55f6fe optimize bsxfun for common built-in operations Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	678
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9825 diff changeset	679 BSXFUN_OP_DEF_MXLOOP (pow, FloatComplexNDArray, mx_inline_pow)

Mercurial > octave

annotate liboctave/array/fCNDArray.cc @ 29931:7faff48840eb