octave: liboctave/array/fCMatrix.cc annotate

annotate liboctave/array/fCMatrix.cc @ 22323:bac0d6f07a3e

maint: Update copyright notices for 2016.

author	John W. Eaton <jwe@octave.org>
date	Wed, 17 Aug 2016 01:05:19 -0400
parents	93b3cdd36854
children	d0562b3159c7

rev	line source
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1 // Matrix manipulations.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2 /*
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3
22323 bac0d6f07a3e maint: Update copyright notices for 2016. John W. Eaton <jwe@octave.org> parents: 22322 diff changeset	4 Copyright (C) 1994-2016 John W. Eaton
11523 fd0a3ac60b0e update copyright notices John W. Eaton <jwe@octave.org> parents: 11518 diff changeset	5 Copyright (C) 2008-2009 Jaroslav Hajek
9601 a9b37bae1802 add a couple of missing copyright statements Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	6 Copyright (C) 2009 VZLU Prague, a.s.
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	7
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	8 This file is part of Octave.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	9
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	10 Octave is free software; you can redistribute it and/or modify it
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	11 under the terms of the GNU General Public License as published by the
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	12 Free Software Foundation; either version 3 of the License, or (at your
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	13 option) any later version.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	14
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	15 Octave is distributed in the hope that it will be useful, but WITHOUT
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	18 for more details.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	19
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	20 You should have received a copy of the GNU General Public License
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	21 along with Octave; see the file COPYING. If not, see
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	22 <http://www.gnu.org/licenses/>.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	23
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	24 */
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	25
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: 21273 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	30 #include <cfloat>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	31
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	32 #include <iostream>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	33 #include <vector>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	34
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	35 // FIXME
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	36 #include <sys/types.h>
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	37
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	38 #include "Array-util.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9469 diff changeset	39 #include "DET.h"
19269 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19065 diff changeset	40 #include "boolMatrix.h"
65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19065 diff changeset	41 #include "chMatrix.h"
21269 3c8a3d35661a better use of templates for Cholesky factorization John W. Eaton <jwe@octave.org> parents: 21266 diff changeset	42 #include "chol.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	43 #include "fCMatrix.h"
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	44 #include "fCNDArray.h"
19269 65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19065 diff changeset	45 #include "fCDiagMatrix.h"
65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19065 diff changeset	46 #include "fCColVector.h"
65554f5847ac don't include oct-locbuf.h in header files unnecessarily John W. Eaton <jwe@octave.org> parents: 19065 diff changeset	47 #include "fCRowVector.h"
21266 e69eaee28737 make better use of templates for Schur decomposition John W. Eaton <jwe@octave.org> parents: 21202 diff changeset	48 #include "schur.h"
21273 cbced1c09916 better use of templates for svd classes John W. Eaton <jwe@octave.org> parents: 21269 diff changeset	49 #include "svd.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	50 #include "functor.h"
22322 93b3cdd36854 move most f77 function decls to separate header files John W. Eaton <jwe@octave.org> parents: 22317 diff changeset	51 #include "lo-blas-proto.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	52 #include "lo-error.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	53 #include "lo-ieee.h"
22322 93b3cdd36854 move most f77 function decls to separate header files John W. Eaton <jwe@octave.org> parents: 22317 diff changeset	54 #include "lo-lapack-proto.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	55 #include "lo-mappers.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	56 #include "lo-utils.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	57 #include "mx-fcm-fdm.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9469 diff changeset	58 #include "mx-fcm-fs.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	59 #include "mx-fdm-fcm.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	60 #include "mx-inlines.cc"
8774 b756ce0002db split implementation and interface in mx-op-defs and MArray-defs Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	61 #include "mx-op-defs.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	62 #include "oct-cmplx.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9469 diff changeset	63 #include "oct-fftw.h"
0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9469 diff changeset	64 #include "oct-locbuf.h"
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	65 #include "oct-norm.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	66
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	67 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	68 octave::numeric_limits<float>::NaN ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	69
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	70 // FloatComplex Matrix class
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	71
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	72 FloatComplexMatrix::FloatComplexMatrix (const FloatMatrix& a)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	73 : FloatComplexNDArray (a)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	74 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	75 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	76
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	77 FloatComplexMatrix::FloatComplexMatrix (const FloatRowVector& rv)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	78 : FloatComplexNDArray (rv)
7789 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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	81
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	82 FloatComplexMatrix::FloatComplexMatrix (const FloatColumnVector& cv)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	83 : FloatComplexNDArray (cv)
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 }
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 FloatComplexMatrix::FloatComplexMatrix (const FloatDiagMatrix& a)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	88 : FloatComplexNDArray (a.dims (), 0.0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	89 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	90 for (octave_idx_type i = 0; i < a.length (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	91 elem (i, i) = a.elem (i, i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	92 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	93
19391 385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	94 FloatComplexMatrix::FloatComplexMatrix (const MDiagArray2<float>& a)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	95 : FloatComplexNDArray (a.dims (), 0.0)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	96 {
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	97 for (octave_idx_type i = 0; i < a.length (); i++)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	98 elem (i, i) = a.elem (i, i);
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	99 }
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	100
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	101 FloatComplexMatrix::FloatComplexMatrix (const DiagArray2<float>& a)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	102 : FloatComplexNDArray (a.dims (), 0.0)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	103 {
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	104 for (octave_idx_type i = 0; i < a.length (); i++)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	105 elem (i, i) = a.elem (i, i);
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	106 }
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	107
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	108 FloatComplexMatrix::FloatComplexMatrix (const FloatComplexRowVector& rv)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	109 : FloatComplexNDArray (rv)
7789 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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	112
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	113 FloatComplexMatrix::FloatComplexMatrix (const FloatComplexColumnVector& cv)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	114 : FloatComplexNDArray (cv)
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 }
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 FloatComplexMatrix::FloatComplexMatrix (const FloatComplexDiagMatrix& a)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	119 : FloatComplexNDArray (a.dims (), 0.0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	120 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	121 for (octave_idx_type i = 0; i < a.length (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	122 elem (i, i) = a.elem (i, i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	123 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	124
19391 385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	125 FloatComplexMatrix::FloatComplexMatrix (const MDiagArray2<FloatComplex>& a)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	126 : FloatComplexNDArray (a.dims (), 0.0)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	127 {
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	128 for (octave_idx_type i = 0; i < a.length (); i++)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	129 elem (i, i) = a.elem (i, i);
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	130 }
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	131
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	132 FloatComplexMatrix::FloatComplexMatrix (const DiagArray2<FloatComplex>& a)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	133 : FloatComplexNDArray (a.dims (), 0.0)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	134 {
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	135 for (octave_idx_type i = 0; i < a.length (); i++)
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	136 elem (i, i) = a.elem (i, i);
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	137 }
385499581a5e allow disabling of permutation and diagonal matrices John W. Eaton <jwe@octave.org> parents: 19321 diff changeset	138
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	139 // FIXME: could we use a templated mixed-type copy function
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	140 // here?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	141
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	142 FloatComplexMatrix::FloatComplexMatrix (const boolMatrix& a)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	143 : FloatComplexNDArray (a)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	144 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	145 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	146
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	147 FloatComplexMatrix::FloatComplexMatrix (const charMatrix& a)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	148 : FloatComplexNDArray (a.dims (), 0.0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	149 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	150 for (octave_idx_type i = 0; i < a.rows (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	151 for (octave_idx_type j = 0; j < a.cols (); j++)
8956 d91fa4b20bbb ensure nonnegative char -> real conversion Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	152 elem (i, j) = static_cast<unsigned char> (a.elem (i, j));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	153 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	154
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	155 FloatComplexMatrix::FloatComplexMatrix (const FloatMatrix& re,
57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	156 const FloatMatrix& im)
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 19269 diff changeset	157 : FloatComplexNDArray (re.dims ())
9663 7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	158 {
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	159 if (im.rows () != rows () \|\| im.cols () != cols ())
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	160 (*current_liboctave_error_handler) ("complex: internal error");
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	161
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	162 octave_idx_type nel = numel ();
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	163 for (octave_idx_type i = 0; i < nel; i++)
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	164 xelem (i) = FloatComplex (re(i), im(i));
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	165 }
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	166
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	167 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	168 FloatComplexMatrix::operator == (const FloatComplexMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	169 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	170 if (rows () != a.rows () \|\| cols () != a.cols ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	171 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	172
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	173 return mx_inline_equal (numel (), data (), a.data ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	174 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	175
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	176 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	177 FloatComplexMatrix::operator != (const FloatComplexMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	178 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	179 return !(*this == a);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	180 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	181
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	182 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	183 FloatComplexMatrix::is_hermitian (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	184 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	185 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	186 octave_idx_type nc = cols ();
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 if (is_square () && nr > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	189 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	190 for (octave_idx_type i = 0; i < nr; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	191 for (octave_idx_type j = i; j < nc; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	192 if (elem (i, j) != conj (elem (j, i)))
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	193 return false;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	194
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	195 return true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	196 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	197
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	198 return false;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	199 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	200
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	201 // destructive insert/delete/reorder operations
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	202
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	203 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	204 FloatComplexMatrix::insert (const FloatMatrix& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	205 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	206 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	207 octave_idx_type a_nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	208 octave_idx_type a_nc = a.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	209
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	210 if (r < 0 \|\| r + a_nr > rows () \|\| c < 0 \|\| c + a_nc > cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	211 (*current_liboctave_error_handler) ("range error for insert");
7789 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 if (a_nr >0 && a_nc > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	214 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	215 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	216
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	217 for (octave_idx_type j = 0; j < a_nc; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	218 for (octave_idx_type i = 0; i < a_nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	219 xelem (r+i, c+j) = a.elem (i, j);
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 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	223 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	224
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	225 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	226 FloatComplexMatrix::insert (const FloatRowVector& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	227 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	228 {
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	229 octave_idx_type a_len = a.numel ();
7789 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 if (r < 0 \|\| r >= rows () \|\| c < 0 \|\| c + a_len > cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	232 (*current_liboctave_error_handler) ("range error for insert");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	233
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	234 if (a_len > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	235 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	236 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	237
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	238 for (octave_idx_type i = 0; i < a_len; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	239 xelem (r, c+i) = a.elem (i);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	240 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	241
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	242 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	243 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	244
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	245 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	246 FloatComplexMatrix::insert (const FloatColumnVector& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	247 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	248 {
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	249 octave_idx_type a_len = a.numel ();
7789 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 if (r < 0 \|\| r + a_len > rows () \|\| c < 0 \|\| c >= cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	252 (*current_liboctave_error_handler) ("range error for insert");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	253
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	254 if (a_len > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	255 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	256 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	257
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	258 for (octave_idx_type i = 0; i < a_len; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	259 xelem (r+i, c) = a.elem (i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	262 return *this;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	265 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	266 FloatComplexMatrix::insert (const FloatDiagMatrix& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	267 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	268 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	269 octave_idx_type a_nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	270 octave_idx_type a_nc = a.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	271
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	272 if (r < 0 \|\| r + a_nr > rows () \|\| c < 0 \|\| c + a_nc > cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	273 (*current_liboctave_error_handler) ("range error for insert");
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 fill (0.0, r, c, r + a_nr - 1, c + a_nc - 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	276
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	277 octave_idx_type a_len = a.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	278
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	279 if (a_len > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	280 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	281 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	282
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	283 for (octave_idx_type i = 0; i < a_len; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	284 xelem (r+i, c+i) = a.elem (i, i);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	285 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	286
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	287 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	288 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	289
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	290 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	291 FloatComplexMatrix::insert (const FloatComplexMatrix& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	292 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	293 {
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	294 Array<FloatComplex>::insert (a, r, c);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	295 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	296 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	297
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	298 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	299 FloatComplexMatrix::insert (const FloatComplexRowVector& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	300 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	301 {
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	302 octave_idx_type a_len = a.numel ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	303 if (r < 0 \|\| r >= rows () \|\| c < 0 \|\| c + a_len > cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	304 (*current_liboctave_error_handler) ("range error for insert");
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 for (octave_idx_type i = 0; i < a_len; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	307 elem (r, c+i) = a.elem (i);
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 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	310 }
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 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	313 FloatComplexMatrix::insert (const FloatComplexColumnVector& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	314 octave_idx_type r, octave_idx_type c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	315 {
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	316 octave_idx_type a_len = a.numel ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	317
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	318 if (r < 0 \|\| r + a_len > rows () \|\| c < 0 \|\| c >= cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	319 (*current_liboctave_error_handler) ("range error for insert");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	320
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	321 if (a_len > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	322 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	323 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	324
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	325 for (octave_idx_type i = 0; i < a_len; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	326 xelem (r+i, c) = a.elem (i);
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	329 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	330 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	331
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	332 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	333 FloatComplexMatrix::insert (const FloatComplexDiagMatrix& a,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	334 octave_idx_type r, octave_idx_type c)
7789 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 octave_idx_type a_nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	337 octave_idx_type a_nc = a.cols ();
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 if (r < 0 \|\| r + a_nr > rows () \|\| c < 0 \|\| c + a_nc > cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	340 (*current_liboctave_error_handler) ("range error for insert");
7789 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 fill (0.0, r, c, r + a_nr - 1, c + a_nc - 1);
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 octave_idx_type a_len = a.length ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	345
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	346 if (a_len > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	347 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	348 make_unique ();
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 for (octave_idx_type i = 0; i < a_len; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	351 xelem (r+i, c+i) = a.elem (i, i);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	352 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	353
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	354 return *this;
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 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	358 FloatComplexMatrix::fill (float val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	359 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	360 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	361 octave_idx_type nc = cols ();
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 if (nr > 0 && nc > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	364 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	365 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	366
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	367 for (octave_idx_type j = 0; j < nc; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	368 for (octave_idx_type i = 0; i < nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	369 xelem (i, j) = val;
7789 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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	372 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	373 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	374
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	375 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	376 FloatComplexMatrix::fill (const FloatComplex& val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	377 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	378 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	379 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	380
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	381 if (nr > 0 && nc > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	382 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	383 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	384
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	385 for (octave_idx_type j = 0; j < nc; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	386 for (octave_idx_type i = 0; i < nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	387 xelem (i, j) = val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	388 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	389
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	390 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	391 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	392
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	393 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	394 FloatComplexMatrix::fill (float val, octave_idx_type r1, octave_idx_type c1,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	395 octave_idx_type r2, octave_idx_type c2)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	396 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	397 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	398 octave_idx_type nc = cols ();
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 if (r1 < 0 \|\| r2 < 0 \|\| c1 < 0 \|\| c2 < 0
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	401 \|\| r1 >= nr \|\| r2 >= nr \|\| c1 >= nc \|\| c2 >= nc)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	402 (*current_liboctave_error_handler) ("range error for fill");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	403
17663 7975d75f933c Use std::swap in liboctave instead of temporary variable. Rik <rik@octave.org> parents: 16300 diff changeset	404 if (r1 > r2) { std::swap (r1, r2); }
7975d75f933c Use std::swap in liboctave instead of temporary variable. Rik <rik@octave.org> parents: 16300 diff changeset	405 if (c1 > c2) { std::swap (c1, c2); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	406
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	407 if (r2 >= r1 && c2 >= c1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	408 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	409 make_unique ();
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 for (octave_idx_type j = c1; j <= c2; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	412 for (octave_idx_type i = r1; i <= r2; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	413 xelem (i, j) = val;
7789 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 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	417 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	418
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	419 FloatComplexMatrix&
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	420 FloatComplexMatrix::fill (const FloatComplex& val,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	421 octave_idx_type r1, octave_idx_type c1,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	422 octave_idx_type r2, octave_idx_type c2)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	423 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	424 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	425 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	426
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	427 if (r1 < 0 \|\| r2 < 0 \|\| c1 < 0 \|\| c2 < 0
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	428 \|\| r1 >= nr \|\| r2 >= nr \|\| c1 >= nc \|\| c2 >= nc)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	429 (*current_liboctave_error_handler) ("range error for fill");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	430
17663 7975d75f933c Use std::swap in liboctave instead of temporary variable. Rik <rik@octave.org> parents: 16300 diff changeset	431 if (r1 > r2) { std::swap (r1, r2); }
7975d75f933c Use std::swap in liboctave instead of temporary variable. Rik <rik@octave.org> parents: 16300 diff changeset	432 if (c1 > c2) { std::swap (c1, c2); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	433
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	434 if (r2 >= r1 && c2 >=c1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	435 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	436 make_unique ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	437
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	438 for (octave_idx_type j = c1; j <= c2; j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	439 for (octave_idx_type i = r1; i <= r2; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	440 xelem (i, j) = val;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	441 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	442
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	443 return *this;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	446 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	447 FloatComplexMatrix::append (const FloatMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	448 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	449 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	450 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	451 if (nr != a.rows ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	452 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	453
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	454 octave_idx_type nc_insert = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	455 FloatComplexMatrix retval (nr, nc + a.cols ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	456 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	457 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	458 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	459 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	460
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	461 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	462 FloatComplexMatrix::append (const FloatRowVector& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	463 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	464 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	465 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	466 if (nr != 1)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	467 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	468
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	469 octave_idx_type nc_insert = nc;
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	470 FloatComplexMatrix retval (nr, nc + a.numel ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	471 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	472 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	473 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	474 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	475
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	476 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	477 FloatComplexMatrix::append (const FloatColumnVector& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	478 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	479 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	480 octave_idx_type nc = cols ();
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	481 if (nr != a.numel ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	482 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	483
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	484 octave_idx_type nc_insert = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	485 FloatComplexMatrix retval (nr, nc + 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	486 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	487 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	488 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	489 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	490
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	491 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	492 FloatComplexMatrix::append (const FloatDiagMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	493 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	494 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	495 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	496 if (nr != a.rows ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	497 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	498
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	499 octave_idx_type nc_insert = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	500 FloatComplexMatrix retval (nr, nc + a.cols ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	501 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	502 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	503 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	504 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	505
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	506 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	507 FloatComplexMatrix::append (const FloatComplexMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	508 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	509 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	510 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	511 if (nr != a.rows ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	512 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	513
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	514 octave_idx_type nc_insert = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	515 FloatComplexMatrix retval (nr, nc + a.cols ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	516 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	517 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	518 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	519 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	520
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	521 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	522 FloatComplexMatrix::append (const FloatComplexRowVector& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	523 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	524 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	525 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	526 if (nr != 1)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	527 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	528
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	529 octave_idx_type nc_insert = nc;
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	530 FloatComplexMatrix retval (nr, nc + a.numel ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	531 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	532 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	533 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	534 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	535
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	536 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	537 FloatComplexMatrix::append (const FloatComplexColumnVector& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	538 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	539 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	540 octave_idx_type nc = cols ();
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	541 if (nr != a.numel ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	542 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	543
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	544 octave_idx_type nc_insert = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	545 FloatComplexMatrix retval (nr, nc + 1);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	546 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	547 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	548 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	549 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	550
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	551 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	552 FloatComplexMatrix::append (const FloatComplexDiagMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	553 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	554 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	555 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	556 if (nr != a.rows ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	557 (*current_liboctave_error_handler) ("row dimension mismatch for append");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	558
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	559 octave_idx_type nc_insert = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	560 FloatComplexMatrix retval (nr, nc + a.cols ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	561 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	562 retval.insert (a, 0, nc_insert);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	563 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	566 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	567 FloatComplexMatrix::stack (const FloatMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	568 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	569 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	570 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	571 if (nc != a.cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	572 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	573
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	574 octave_idx_type nr_insert = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	575 FloatComplexMatrix retval (nr + a.rows (), nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	576 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	577 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	578 return retval;
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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	581 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	582 FloatComplexMatrix::stack (const FloatRowVector& a) const
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 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	585 octave_idx_type nc = cols ();
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	586 if (nc != a.numel ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	587 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
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 octave_idx_type nr_insert = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	590 FloatComplexMatrix retval (nr + 1, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	591 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	592 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	593 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	594 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	595
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	596 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	597 FloatComplexMatrix::stack (const FloatColumnVector& a) const
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 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	600 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	601 if (nc != 1)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	602 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
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 octave_idx_type nr_insert = nr;
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	605 FloatComplexMatrix retval (nr + a.numel (), nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	606 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	607 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	608 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	609 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	610
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	611 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	612 FloatComplexMatrix::stack (const FloatDiagMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	613 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	614 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	615 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	616 if (nc != a.cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	617 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	618
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	619 octave_idx_type nr_insert = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	620 FloatComplexMatrix retval (nr + a.rows (), nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	621 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	622 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	623 return retval;
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 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	627 FloatComplexMatrix::stack (const FloatComplexMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	628 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	629 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	630 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	631 if (nc != a.cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	632 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	633
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	634 octave_idx_type nr_insert = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	635 FloatComplexMatrix retval (nr + a.rows (), nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	636 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	637 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	638 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	639 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	640
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	641 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	642 FloatComplexMatrix::stack (const FloatComplexRowVector& a) const
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 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	645 octave_idx_type nc = cols ();
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	646 if (nc != a.numel ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	647 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	648
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	649 octave_idx_type nr_insert = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	650 FloatComplexMatrix retval (nr + 1, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	651 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	652 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	653 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	654 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	655
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	656 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	657 FloatComplexMatrix::stack (const FloatComplexColumnVector& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	658 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	659 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	660 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	661 if (nc != 1)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	662 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	663
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	664 octave_idx_type nr_insert = nr;
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	665 FloatComplexMatrix retval (nr + a.numel (), nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	666 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	667 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	668 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	669 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	670
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	671 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	672 FloatComplexMatrix::stack (const FloatComplexDiagMatrix& a) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	673 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	674 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	675 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	676 if (nc != a.cols ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	677 (*current_liboctave_error_handler) ("column dimension mismatch for stack");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	678
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	679 octave_idx_type nr_insert = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	680 FloatComplexMatrix retval (nr + a.rows (), nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	681 retval.insert (*this, 0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	682 retval.insert (a, nr_insert, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	683 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	684 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	685
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	686 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	687 conj (const FloatComplexMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	688 {
13107 353c71c76f22 maint: fix compilation problem with g++ -std=c++0x option Júlio Hoffimann <julio.hoffimann@gmail.com> parents: 11596 diff changeset	689 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	690 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	691
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	692 // resize is the destructive equivalent for this one
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	693
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	694 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	695 FloatComplexMatrix::extract (octave_idx_type r1, octave_idx_type c1,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	696 octave_idx_type r2, octave_idx_type c2) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	697 {
17663 7975d75f933c Use std::swap in liboctave instead of temporary variable. Rik <rik@octave.org> parents: 16300 diff changeset	698 if (r1 > r2) { std::swap (r1, r2); }
7975d75f933c Use std::swap in liboctave instead of temporary variable. Rik <rik@octave.org> parents: 16300 diff changeset	699 if (c1 > c2) { std::swap (c1, c2); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	700
10805 8c858a1a2079 simplify Matrix::extract Jaroslav Hajek <highegg@gmail.com> parents: 10779 diff changeset	701 return index (idx_vector (r1, r2+1), idx_vector (c1, c2+1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	702 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	703
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	704 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	705 FloatComplexMatrix::extract_n (octave_idx_type r1, octave_idx_type c1,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	706 octave_idx_type nr, octave_idx_type nc) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	707 {
10806 7c542263a92a omissions from last two patches Jaroslav Hajek <highegg@gmail.com> parents: 10805 diff changeset	708 return index (idx_vector (r1, r1 + nr), idx_vector (c1, c1 + nc));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	709 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	710
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	711 // extract row or column i.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	712
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	713 FloatComplexRowVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	714 FloatComplexMatrix::row (octave_idx_type i) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	715 {
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	716 return index (idx_vector (i), idx_vector::colon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	717 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	718
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	719 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	720 FloatComplexMatrix::column (octave_idx_type i) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	721 {
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	722 return index (idx_vector::colon, idx_vector (i));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	723 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	724
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	725 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	726 FloatComplexMatrix::inverse (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	727 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	728 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	729 float rcon;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	730 MatrixType mattype (*this);
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	731 return inverse (mattype, info, rcon, 0, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	732 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	733
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	734 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	735 FloatComplexMatrix::inverse (octave_idx_type& info) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	736 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	737 float rcon;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	738 MatrixType mattype (*this);
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	739 return inverse (mattype, info, rcon, 0, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	740 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	741
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	742 FloatComplexMatrix
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	743 FloatComplexMatrix::inverse (octave_idx_type& info, float& rcon, bool force,
ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	744 bool calc_cond) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	745 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	746 MatrixType mattype (*this);
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	747 return inverse (mattype, info, rcon, force, calc_cond);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	748 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	749
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	750 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	751 FloatComplexMatrix::inverse (MatrixType &mattype) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	752 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	753 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	754 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	755 return inverse (mattype, info, rcon, 0, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	756 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	757
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	758 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	759 FloatComplexMatrix::inverse (MatrixType &mattype, octave_idx_type& info) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	760 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	761 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	762 return inverse (mattype, info, rcon, 0, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	763 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	764
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	765 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	766 FloatComplexMatrix::tinverse (MatrixType &mattype, octave_idx_type& info,
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	767 float& rcon, bool force, bool calc_cond) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	768 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	769 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	770
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	771 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	772 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	773
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	774 if (nr != nc \|\| nr == 0 \|\| nc == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	775 (*current_liboctave_error_handler) ("inverse requires square matrix");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	776
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	777 int typ = mattype.type ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	778 char uplo = (typ == MatrixType::Lower ? 'L' : 'U');
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	779 char udiag = 'N';
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	780 retval = *this;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	781 FloatComplex *tmp_data = retval.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	782
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	783 F77_XFCN (ctrtri, CTRTRI, (F77_CONST_CHAR_ARG2 (&uplo, 1),
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	784 F77_CONST_CHAR_ARG2 (&udiag, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	785 nr, F77_CMPLX_ARG (tmp_data), nr, info
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	786 F77_CHAR_ARG_LEN (1)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	787 F77_CHAR_ARG_LEN (1)));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	788
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	789 // Throw-away extra info LAPACK gives so as to not change output.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	790 rcon = 0.0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	791 if (info != 0)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	792 info = -1;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	793 else if (calc_cond)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	794 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	795 octave_idx_type ztrcon_info = 0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	796 char job = '1';
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	797
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	798 OCTAVE_LOCAL_BUFFER (FloatComplex, cwork, 2*nr);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	799 OCTAVE_LOCAL_BUFFER (float, rwork, nr);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	800
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	801 F77_XFCN (ctrcon, CTRCON, (F77_CONST_CHAR_ARG2 (&job, 1),
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	802 F77_CONST_CHAR_ARG2 (&uplo, 1),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	803 F77_CONST_CHAR_ARG2 (&udiag, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	804 nr, F77_CMPLX_ARG (tmp_data), nr, rcon,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	805 F77_CMPLX_ARG (cwork), rwork, ztrcon_info
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	806 F77_CHAR_ARG_LEN (1)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	807 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	808 F77_CHAR_ARG_LEN (1)));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	809
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	810 if (ztrcon_info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	811 info = -1;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	812 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	813
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	814 if (info == -1 && ! force)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	815 retval = *this; // Restore matrix contents.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	816
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	817 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	818 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	819
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	820 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	821 FloatComplexMatrix::finverse (MatrixType &mattype, octave_idx_type& info,
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	822 float& rcon, bool force, bool calc_cond) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	823 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	824 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	825
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	826 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	827 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	828
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	829 if (nr != nc)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	830 (*current_liboctave_error_handler) ("inverse requires square matrix");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	831
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	832 Array<octave_idx_type> ipvt (dim_vector (nr, 1));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	833 octave_idx_type *pipvt = ipvt.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	834
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	835 retval = *this;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	836 FloatComplex *tmp_data = retval.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	837
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	838 Array<FloatComplex> z (dim_vector (1, 1));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	839 octave_idx_type lwork = -1;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	840
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	841 // Query the optimum work array size.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	842
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	843 F77_XFCN (cgetri, CGETRI, (nc, F77_CMPLX_ARG (tmp_data), nr, pipvt,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	844 F77_CMPLX_ARG (z.fortran_vec ()), lwork, info));
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	845
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	846 lwork = static_cast<octave_idx_type> (octave::math::real (z(0)));
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	847 lwork = (lwork < 2 nc ? 2nc : lwork);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	848 z.resize (dim_vector (lwork, 1));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	849 FloatComplex *pz = z.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	850
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	851 info = 0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	852
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	853 // Calculate (always, see bug #45577) the norm of the matrix, for later use.
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	854 float anorm =
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	855 retval.abs ().sum ().row (static_cast<octave_idx_type>(0)).max ();
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	856
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	857 // Work around bug #45577, LAPACK crashes Octave if norm is NaN
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	858 // and bug #46330, segfault with matrices containing Inf & NaN
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	859 if (octave::math::isnan (anorm) \|\| octave::math::isinf (anorm))
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	860 info = -1;
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	861 else
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	862 F77_XFCN (cgetrf, CGETRF, (nc, nc, F77_CMPLX_ARG (tmp_data), nr, pipvt, info));
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	863
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	864 // Throw-away extra info LAPACK gives so as to not change output.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	865 rcon = 0.0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	866 if (info != 0)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	867 info = -1;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	868 else if (calc_cond)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	869 {
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	870 // Now calculate the condition number for non-singular matrix.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	871 octave_idx_type zgecon_info = 0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	872 char job = '1';
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	873 Array<float> rz (dim_vector (2 * nc, 1));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	874 float *prz = rz.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	875 F77_XFCN (cgecon, CGECON, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	876 nc, F77_CMPLX_ARG (tmp_data), nr, anorm,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	877 rcon, F77_CMPLX_ARG (pz), prz, zgecon_info
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	878 F77_CHAR_ARG_LEN (1)));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	879
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	880 if (zgecon_info != 0)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	881 info = -1;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	882 }
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	883
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	884 if ((info == -1 && ! force) \|\| octave::math::isinf (anorm))
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	885 retval = *this; // Restore contents.
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	886 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	887 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	888 octave_idx_type zgetri_info = 0;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	889
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	890 F77_XFCN (cgetri, CGETRI, (nc, F77_CMPLX_ARG (tmp_data), nr, pipvt,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	891 F77_CMPLX_ARG (pz), lwork, zgetri_info));
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	892
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	893 if (zgetri_info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	894 info = -1;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	895 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	896
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	897 if (info != 0)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	898 mattype.mark_as_rectangular ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	899
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	900 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	901 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	902
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	903 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	904 FloatComplexMatrix::inverse (MatrixType &mattype, octave_idx_type& info,
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	905 float& rcon, bool force, bool calc_cond) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	906 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	907 int typ = mattype.type (false);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	908 FloatComplexMatrix ret;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	909
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	910 if (typ == MatrixType::Unknown)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	911 typ = mattype.type (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	912
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	913 if (typ == MatrixType::Upper \|\| typ == MatrixType::Lower)
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	914 ret = tinverse (mattype, info, rcon, force, calc_cond);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	915 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	916 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	917 if (mattype.is_hermitian ())
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	918 {
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 22274 diff changeset	919 octave::math::chol<FloatComplexMatrix> chol (*this, info, true, calc_cond);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	920 if (info == 0)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	921 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	922 if (calc_cond)
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14557 diff changeset	923 rcon = chol.rcond ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	924 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	925 rcon = 1.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	926 ret = chol.inverse ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	927 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	928 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	929 mattype.mark_as_unsymmetric ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	930 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	931
20955 77f5591878bf maint: Use '! expr' rather than '!expr' to conform to coding guidelines. Rik <rik@octave.org> parents: 20711 diff changeset	932 if (! mattype.is_hermitian ())
15018 3d8ace26c5b4 maint: Use Octave coding conventions for cuddled parentheses in liboctave/. Rik <rik@octave.org> parents: 14846 diff changeset	933 ret = finverse (mattype, info, rcon, force, calc_cond);
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	934
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	935 if ((mattype.is_hermitian () \|\| calc_cond) && rcon == 0.)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	936 ret = FloatComplexMatrix (rows (), columns (),
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	937 FloatComplex (octave::numeric_limits<float>::Inf (), 0.));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	938 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	939
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	940 return ret;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	941 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	942
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	943 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	944 FloatComplexMatrix::pseudo_inverse (float tol) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	945 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	946 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	947
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 22274 diff changeset	948 octave::math::svd<FloatComplexMatrix> result (*this, octave::math::svd<FloatComplexMatrix>::Type::economy);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	949
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	950 FloatDiagMatrix S = result.singular_values ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	951 FloatComplexMatrix U = result.left_singular_matrix ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	952 FloatComplexMatrix V = result.right_singular_matrix ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	953
15448 0a0912a9ab6e Replace deprecated DiagArray2<T>::diag calls with DiagArray2<T>::extract_diag Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 15383 diff changeset	954 FloatColumnVector sigma = S.extract_diag ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	955
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	956 octave_idx_type r = sigma.numel () - 1;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	957 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	958 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	959
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	960 if (tol <= 0.0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	961 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	962 if (nr > nc)
15220 61822c866ba1 use std::numeric_limits<T>::epsilon in C++ code John W. Eaton <jwe@octave.org> parents: 15212 diff changeset	963 tol = nr * sigma.elem (0) * std::numeric_limits<double>::epsilon ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	964 else
15220 61822c866ba1 use std::numeric_limits<T>::epsilon in C++ code John W. Eaton <jwe@octave.org> parents: 15212 diff changeset	965 tol = nc * sigma.elem (0) * std::numeric_limits<double>::epsilon ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	966 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	967
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	968 while (r >= 0 && sigma.elem (r) < tol)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	969 r--;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	970
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	971 if (r < 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	972 retval = FloatComplexMatrix (nc, nr, 0.0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	973 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	974 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	975 FloatComplexMatrix Ur = U.extract (0, 0, nr-1, r);
21751 b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21724 diff changeset	976 FloatDiagMatrix D = FloatDiagMatrix (sigma.extract (0, r)).inverse ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	977 FloatComplexMatrix Vr = V.extract (0, 0, nc-1, r);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	978 retval = Vr * D * Ur.hermitian ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	979 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	980
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	981 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	982 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	983
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9469 diff changeset	984 #if defined (HAVE_FFTW)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	985
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	986 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	987 FloatComplexMatrix::fourier (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	988 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	989 size_t nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	990 size_t nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	991
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	992 FloatComplexMatrix retval (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	993
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	994 size_t npts, nsamples;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	995
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	996 if (nr == 1 \|\| nc == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	997 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	998 npts = nr > nc ? nr : nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	999 nsamples = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1000 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1001 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1002 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1003 npts = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1004 nsamples = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1005 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1006
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1007 const FloatComplex *in (data ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1008 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1009
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1010 octave_fftw::fft (in, out, npts, nsamples);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1011
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1012 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1013 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1014
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1015 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1016 FloatComplexMatrix::ifourier (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1017 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1018 size_t nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1019 size_t nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1020
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1021 FloatComplexMatrix retval (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1022
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1023 size_t npts, nsamples;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1024
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1025 if (nr == 1 \|\| nc == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1026 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1027 npts = nr > nc ? nr : nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1028 nsamples = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1029 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1030 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1031 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1032 npts = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1033 nsamples = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1034 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1035
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1036 const FloatComplex *in (data ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1037 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1038
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1039 octave_fftw::ifft (in, out, npts, nsamples);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1040
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1041 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1042 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1043
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1044 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1045 FloatComplexMatrix::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1046 {
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19864 diff changeset	1047 dim_vector dv (rows (), cols ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1048
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1049 FloatComplexMatrix retval (rows (), cols ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1050 const FloatComplex *in (data ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1051 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1052
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1053 octave_fftw::fftNd (in, out, 2, dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1054
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1055 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1056 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1057
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1058 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1059 FloatComplexMatrix::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1060 {
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19864 diff changeset	1061 dim_vector dv (rows (), cols ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1062
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1063 FloatComplexMatrix retval (rows (), cols ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1064 const FloatComplex *in (data ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1065 FloatComplex *out (retval.fortran_vec ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1066
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1067 octave_fftw::ifftNd (in, out, 2, dv);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1068
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1069 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1070 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1071
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1072 #else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1073
22322 93b3cdd36854 move most f77 function decls to separate header files John W. Eaton <jwe@octave.org> parents: 22317 diff changeset	1074 #include "lo-fftpack-proto.h"
9523 0ce82753dd72 more configure changes for libraries John W. Eaton <jwe@octave.org> parents: 9469 diff changeset	1075
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1076 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1077 FloatComplexMatrix::fourier (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1078 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1079 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1080
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1081 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1082 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1083
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1084 octave_idx_type npts, nsamples;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1085
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1086 if (nr == 1 \|\| nc == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1087 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1088 npts = nr > nc ? nr : nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1089 nsamples = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1090 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1091 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1092 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1093 npts = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1094 nsamples = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1095 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1096
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1097 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1098
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1099 Array<FloatComplex> wsave (dim_vector (nn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1100 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1101
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1102 retval = *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1103 FloatComplex *tmp_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1104
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1105 F77_FUNC (cffti, CFFTI) (npts, F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1106
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1107 for (octave_idx_type j = 0; j < nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1108 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10124 diff changeset	1109 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1110
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1111 F77_FUNC (cfftf, CFFTF) (npts, F77_CMPLX_ARG (&tmp_data[npts*j]), F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1112 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1113
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1114 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1115 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1116
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1117 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1118 FloatComplexMatrix::ifourier (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1119 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1120 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1121
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1122 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1123 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1124
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1125 octave_idx_type npts, nsamples;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1126
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1127 if (nr == 1 \|\| nc == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1128 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1129 npts = nr > nc ? nr : nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1130 nsamples = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1131 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1132 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1133 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1134 npts = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1135 nsamples = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1136 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1137
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1138 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1139
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1140 Array<FloatComplex> wsave (dim_vector (nn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1141 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1142
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1143 retval = *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1144 FloatComplex *tmp_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1145
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1146 F77_FUNC (cffti, CFFTI) (npts, F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1147
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1148 for (octave_idx_type j = 0; j < nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1149 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10124 diff changeset	1150 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1151
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1152 F77_FUNC (cfftb, CFFTB) (npts, F77_CMPLX_ARG (&tmp_data[npts*j]), F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1153 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1154
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1155 for (octave_idx_type j = 0; j < npts*nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1156 tmp_data[j] = tmp_data[j] / static_cast<float> (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1157
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1158 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1159 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1160
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1161 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1162 FloatComplexMatrix::fourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1163 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1164 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1165
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1166 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1167 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1168
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1169 octave_idx_type npts, nsamples;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1170
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1171 if (nr == 1 \|\| nc == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1172 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1173 npts = nr > nc ? nr : nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1174 nsamples = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1175 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1176 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1177 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1178 npts = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1179 nsamples = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1180 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1181
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1182 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1183
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1184 Array<FloatComplex> wsave (dim_vector (nn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1185 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1186
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1187 retval = *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1188 FloatComplex *tmp_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1189
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1190 F77_FUNC (cffti, CFFTI) (npts, F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1191
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1192 for (octave_idx_type j = 0; j < nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1193 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10124 diff changeset	1194 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1195
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1196 F77_FUNC (cfftf, CFFTF) (npts, F77_CMPLX_ARG (&tmp_data[npts*j]), F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1197 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1198
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1199 npts = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1200 nsamples = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1201 nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1202
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	1203 wsave.resize (dim_vector (nn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1204 pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1205
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1206 Array<FloatComplex> tmp (dim_vector (npts, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1207 FloatComplex *prow = tmp.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1208
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1209 F77_FUNC (cffti, CFFTI) (npts, F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1210
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1211 for (octave_idx_type j = 0; j < nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1212 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10124 diff changeset	1213 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1214
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1215 for (octave_idx_type i = 0; i < npts; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1216 prow[i] = tmp_data[i*nr + j];
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1217
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1218 F77_FUNC (cfftf, CFFTF) (npts, F77_CMPLX_ARG (prow), F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1219
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1220 for (octave_idx_type i = 0; i < npts; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1221 tmp_data[i*nr + j] = prow[i];
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1222 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1223
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1224 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1225 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1226
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1227 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1228 FloatComplexMatrix::ifourier2d (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1229 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1230 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1231
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1232 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1233 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1234
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1235 octave_idx_type npts, nsamples;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1236
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1237 if (nr == 1 \|\| nc == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1238 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1239 npts = nr > nc ? nr : nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1240 nsamples = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1241 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1242 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1243 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1244 npts = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1245 nsamples = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1246 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1247
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1248 octave_idx_type nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1249
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1250 Array<FloatComplex> wsave (dim_vector (nn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1251 FloatComplex *pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1252
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1253 retval = *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1254 FloatComplex *tmp_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1255
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1256 F77_FUNC (cffti, CFFTI) (npts, F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1257
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1258 for (octave_idx_type j = 0; j < nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1259 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10124 diff changeset	1260 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1261
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1262 F77_FUNC (cfftb, CFFTB) (npts, F77_CMPLX_ARG (&tmp_data[npts*j]), F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1263 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1264
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1265 for (octave_idx_type j = 0; j < npts*nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1266 tmp_data[j] = tmp_data[j] / static_cast<float> (npts);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1267
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1268 npts = nc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1269 nsamples = nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1270 nn = 4*npts+15;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1271
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	1272 wsave.resize (dim_vector (nn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1273 pwsave = wsave.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1274
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1275 Array<FloatComplex> tmp (dim_vector (npts, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1276 FloatComplex *prow = tmp.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1277
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1278 F77_FUNC (cffti, CFFTI) (npts, F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1279
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1280 for (octave_idx_type j = 0; j < nsamples; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1281 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10124 diff changeset	1282 octave_quit ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1283
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1284 for (octave_idx_type i = 0; i < npts; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1285 prow[i] = tmp_data[i*nr + j];
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1286
22261 77c4d43e06d1 Use new macros for passing complex arguments to Fortran FFTPACK subroutines Mike Miller <mtmiller@octave.org> parents: 22204 diff changeset	1287 F77_FUNC (cfftb, CFFTB) (npts, F77_CMPLX_ARG (prow), F77_CMPLX_ARG (pwsave));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1288
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1289 for (octave_idx_type i = 0; i < npts; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1290 tmp_data[i*nr + j] = prow[i] / static_cast<float> (npts);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1291 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1292
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1293 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1294 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1295
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1296 #endif
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1297
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1298 FloatComplexDET
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1299 FloatComplexMatrix::determinant (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1300 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1301 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1302 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1303 return determinant (info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1304 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1305
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1306 FloatComplexDET
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1307 FloatComplexMatrix::determinant (octave_idx_type& info) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1308 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1309 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1310 return determinant (info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1311 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1312
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1313 FloatComplexDET
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1314 FloatComplexMatrix::determinant (octave_idx_type& info, float& rcon,
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	1315 bool calc_cond) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1316 {
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1317 MatrixType mattype (*this);
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1318 return determinant (mattype, info, rcon, calc_cond);
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1319 }
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1320
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1321 FloatComplexDET
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1322 FloatComplexMatrix::determinant (MatrixType& mattype,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1323 octave_idx_type& info, float& rcon,
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	1324 bool calc_cond) const
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1325 {
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1326 FloatComplexDET retval (1.0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1327
13828 f1b023fd098d always initialize info and rcon in Matrix determinant methods John W. Eaton <jwe@octave.org> parents: 13107 diff changeset	1328 info = 0;
f1b023fd098d always initialize info and rcon in Matrix determinant methods John W. Eaton <jwe@octave.org> parents: 13107 diff changeset	1329 rcon = 0.0;
f1b023fd098d always initialize info and rcon in Matrix determinant methods John W. Eaton <jwe@octave.org> parents: 13107 diff changeset	1330
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1331 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1332 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1333
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1334 if (nr != nc)
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1335 (*current_liboctave_error_handler) ("matrix must be square");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1336
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1337 volatile int typ = mattype.type ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1338
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1339 // Even though the matrix is marked as singular (Rectangular), we may
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1340 // still get a useful number from the LU factorization, because it always
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1341 // completes.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1342
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1343 if (typ == MatrixType::Unknown)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1344 typ = mattype.type (*this);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1345 else if (typ == MatrixType::Rectangular)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1346 typ = MatrixType::Full;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1347
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1348 if (typ == MatrixType::Lower \|\| typ == MatrixType::Upper)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1349 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1350 for (octave_idx_type i = 0; i < nc; i++)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1351 retval *= elem (i,i);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1352 }
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1353 else if (typ == MatrixType::Hermitian)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1354 {
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1355 FloatComplexMatrix atmp = *this;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1356 FloatComplex *tmp_data = atmp.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1357
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1358 float anorm = 0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1359 if (calc_cond) anorm = xnorm (*this, 1);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1360
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1361 char job = 'L';
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1362 F77_XFCN (cpotrf, CPOTRF, (F77_CONST_CHAR_ARG2 (&job, 1), nr,
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1363 F77_CMPLX_ARG (tmp_data), nr, info
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1364 F77_CHAR_ARG_LEN (1)));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1365
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1366 if (info != 0)
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1367 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1368 rcon = 0.0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1369 mattype.mark_as_unsymmetric ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1370 typ = MatrixType::Full;
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1371 }
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1372 else
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1373 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1374 Array<FloatComplex> z (dim_vector (2 * nc, 1));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1375 FloatComplex *pz = z.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1376 Array<float> rz (dim_vector (nc, 1));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1377 float *prz = rz.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1378
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1379 F77_XFCN (cpocon, CPOCON, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1380 nr, F77_CMPLX_ARG (tmp_data), nr, anorm,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1381 rcon, F77_CMPLX_ARG (pz), prz, info
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1382 F77_CHAR_ARG_LEN (1)));
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1383
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1384 if (info != 0)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1385 rcon = 0.0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1386
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1387 for (octave_idx_type i = 0; i < nc; i++)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1388 retval *= atmp (i,i);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1389
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1390 retval = retval.square ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1391 }
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1392 }
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1393 else if (typ != MatrixType::Full)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1394 (*current_liboctave_error_handler) ("det: invalid dense matrix type");
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1395
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1396 if (typ == MatrixType::Full)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1397 {
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1398 Array<octave_idx_type> ipvt (dim_vector (nr, 1));
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1399 octave_idx_type *pipvt = ipvt.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1400
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1401 FloatComplexMatrix atmp = *this;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1402 FloatComplex *tmp_data = atmp.fortran_vec ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1403
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1404 info = 0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1405
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1406 // Calculate (always, see bug #45577) the norm of the matrix, for later use.
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1407 float anorm = xnorm (*this, 1);
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1408
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1409 // Work around bug #45577, LAPACK crashes Octave if norm is NaN
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1410 if (octave::math::isnan (anorm))
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1411 info = -1;
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1412 else
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1413 F77_XFCN (cgetrf, CGETRF, (nr, nr, F77_CMPLX_ARG (tmp_data), nr, pipvt, info));
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1414
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1415 // Throw-away extra info LAPACK gives so as to not change output.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1416 rcon = 0.0;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1417 if (info != 0)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1418 {
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1419 info = -1;
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1420 retval = FloatComplexDET ();
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1421 }
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1422 else
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1423 {
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1424 if (calc_cond)
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1425 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1426 // Now calc the condition number for non-singular matrix.
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1427 char job = '1';
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1428 Array<FloatComplex> z (dim_vector (2 * nc, 1));
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1429 FloatComplex *pz = z.fortran_vec ();
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1430 Array<float> rz (dim_vector (2 * nc, 1));
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1431 float *prz = rz.fortran_vec ();
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1432
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1433 F77_XFCN (cgecon, CGECON, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1434 nc, F77_CMPLX_ARG (tmp_data), nr, anorm,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1435 rcon, F77_CMPLX_ARG (pz), prz, info
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1436 F77_CHAR_ARG_LEN (1)));
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1437 }
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1438
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1439 if (info != 0)
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1440 {
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1441 info = -1;
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1442 retval = FloatComplexDET ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1443 }
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1444 else
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1445 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1446 for (octave_idx_type i = 0; i < nc; i++)
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1447 {
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1448 FloatComplex c = atmp(i,i);
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1449 retval *= (ipvt(i) != (i+1)) ? -c : c;
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1450 }
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1451 }
9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1452 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1453 }
8336 9813c07ca946 make det take advantage of matrix type Jaroslav Hajek <highegg@gmail.com> parents: 8335 diff changeset	1454
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1455 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1456 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1457
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1458 float
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1459 FloatComplexMatrix::rcond (void) const
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1460 {
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1461 MatrixType mattype (*this);
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1462 return rcond (mattype);
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1463 }
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1464
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1465 float
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1466 FloatComplexMatrix::rcond (MatrixType &mattype) const
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1467 {
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	1468 float rcon = octave::numeric_limits<float>::NaN ();
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1469 octave_idx_type nr = rows ();
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1470 octave_idx_type nc = cols ();
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1471
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1472 if (nr != nc)
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1473 (*current_liboctave_error_handler) ("matrix must be square");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1474
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1475 if (nr == 0 \|\| nc == 0)
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	1476 rcon = octave::numeric_limits<float>::Inf ();
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1477 else
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1478 {
16300 23c5f90f92cd eliminate some variable might be clobbered by 'longjmp' or 'vfork' warnings John W. Eaton <jwe@octave.org> parents: 15448 diff changeset	1479 volatile int typ = mattype.type ();
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1480
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1481 if (typ == MatrixType::Unknown)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1482 typ = mattype.type (*this);
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1483
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1484 // Only calculate the condition number for LU/Cholesky
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1485 if (typ == MatrixType::Upper)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1486 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1487 const FloatComplex *tmp_data = fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1488 octave_idx_type info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1489 char norm = '1';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1490 char uplo = 'U';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1491 char dia = 'N';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1492
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1493 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1494 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1495 Array<float> rz (dim_vector (nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1496 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1497
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1498 F77_XFCN (ctrcon, CTRCON, (F77_CONST_CHAR_ARG2 (&norm, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1499 F77_CONST_CHAR_ARG2 (&uplo, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1500 F77_CONST_CHAR_ARG2 (&dia, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1501 nr, F77_CONST_CMPLX_ARG (tmp_data), nr, rcon,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1502 F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1503 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1504 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1505 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1506
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1507 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1508 rcon = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1509 }
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1510 else if (typ == MatrixType::Permuted_Upper)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1511 (*current_liboctave_error_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1512 ("permuted triangular matrix not implemented");
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1513 else if (typ == MatrixType::Lower)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1514 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1515 const FloatComplex *tmp_data = fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1516 octave_idx_type info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1517 char norm = '1';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1518 char uplo = 'L';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1519 char dia = 'N';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1520
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1521 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1522 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1523 Array<float> rz (dim_vector (nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1524 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1525
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1526 F77_XFCN (ctrcon, CTRCON, (F77_CONST_CHAR_ARG2 (&norm, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1527 F77_CONST_CHAR_ARG2 (&uplo, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1528 F77_CONST_CHAR_ARG2 (&dia, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1529 nr, F77_CONST_CMPLX_ARG (tmp_data), nr, rcon,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1530 F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1531 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1532 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1533 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1534
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1535 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1536 rcon = 0.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1537 }
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1538 else if (typ == MatrixType::Permuted_Lower)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1539 (*current_liboctave_error_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1540 ("permuted triangular matrix not implemented");
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1541 else if (typ == MatrixType::Full \|\| typ == MatrixType::Hermitian)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1542 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1543 float anorm = -1.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1544
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1545 if (typ == MatrixType::Hermitian)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1546 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1547 octave_idx_type info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1548 char job = 'L';
15382 197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1549
197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1550 FloatComplexMatrix atmp = *this;
197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1551 FloatComplex *tmp_data = atmp.fortran_vec ();
197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1552
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1553 anorm = atmp.abs().sum().
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1554 row(static_cast<octave_idx_type>(0)).max();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1555
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1556 F77_XFCN (cpotrf, CPOTRF, (F77_CONST_CHAR_ARG2 (&job, 1), nr,
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1557 F77_CMPLX_ARG (tmp_data), nr, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1558 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1559
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1560 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1561 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1562 rcon = 0.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1563
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1564 mattype.mark_as_unsymmetric ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1565 typ = MatrixType::Full;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1566 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1567 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1568 {
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1569 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1570 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1571 Array<float> rz (dim_vector (nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1572 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1573
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1574 F77_XFCN (cpocon, CPOCON, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1575 nr, F77_CMPLX_ARG (tmp_data), nr, anorm,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1576 rcon, F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1577 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1578
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1579 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1580 rcon = 0.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1581 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1582 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1583
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1584 if (typ == MatrixType::Full)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1585 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1586 octave_idx_type info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1587
15382 197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1588 FloatComplexMatrix atmp = *this;
197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1589 FloatComplex *tmp_data = atmp.fortran_vec ();
197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1590
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1591 Array<octave_idx_type> ipvt (dim_vector (nr, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1592 octave_idx_type *pipvt = ipvt.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1593
15018 3d8ace26c5b4 maint: Use Octave coding conventions for cuddled parentheses in liboctave/. Rik <rik@octave.org> parents: 14846 diff changeset	1594 if (anorm < 0.)
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14557 diff changeset	1595 anorm = atmp.abs ().sum ().
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1596 row(static_cast<octave_idx_type>(0)).max ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1597
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1598 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1599 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1600 Array<float> rz (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1601 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1602
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1603 // Work around bug #45577, LAPACK crashes Octave if norm is NaN
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1604 if (octave::math::isnan (anorm))
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1605 info = -1;
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1606 else
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1607 F77_XFCN (cgetrf, CGETRF, (nr, nr, F77_CMPLX_ARG (tmp_data), nr, pipvt, info));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1608
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1609 if (info != 0)
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1610 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1611 rcon = 0.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1612 mattype.mark_as_rectangular ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1613 }
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1614 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1615 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1616 char job = '1';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1617 F77_XFCN (cgecon, CGECON, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1618 nc, F77_CMPLX_ARG (tmp_data), nr, anorm,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1619 rcon, F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1620 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1621
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1622 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1623 rcon = 0.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1624 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1625 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1626 }
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1627 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1628 rcon = 0.0;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1629 }
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1630
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1631 return rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1632 }
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	1633
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1634 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1635 FloatComplexMatrix::utsolve (MatrixType &mattype, const FloatComplexMatrix& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1636 octave_idx_type& info, float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1637 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1638 bool calc_cond, blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1639 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1640 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1641
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1642 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1643 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1644
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1645 if (nr != b.rows ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1646 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1647 ("matrix dimension mismatch solution of linear equations");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1648
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1649 if (nr == 0 \|\| nc == 0 \|\| b.cols () == 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1650 retval = FloatComplexMatrix (nc, b.cols (), FloatComplex (0.0, 0.0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1651 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1652 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1653 volatile int typ = mattype.type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1654
19864 17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions. John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1655 if (typ == MatrixType::Permuted_Upper \|\| typ == MatrixType::Upper)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1656 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1657 octave_idx_type b_nc = b.cols ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1658 rcon = 1.;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1659 info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1660
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1661 if (typ == MatrixType::Permuted_Upper)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1662 (*current_liboctave_error_handler)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1663 ("permuted triangular matrix not implemented");
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1664 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1665 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1666 const FloatComplex *tmp_data = fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1667
19446 0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1668 retval = b;
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1669 FloatComplex *result = retval.fortran_vec ();
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1670
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1671 char uplo = 'U';
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1672 char trans = get_blas_char (transt);
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1673 char dia = 'N';
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1674
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1675 F77_XFCN (ctrtrs, CTRTRS, (F77_CONST_CHAR_ARG2 (&uplo, 1),
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1676 F77_CONST_CHAR_ARG2 (&trans, 1),
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1677 F77_CONST_CHAR_ARG2 (&dia, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1678 nr, b_nc, F77_CONST_CMPLX_ARG (tmp_data), nr,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1679 F77_CMPLX_ARG (result), nr, info
19446 0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1680 F77_CHAR_ARG_LEN (1)
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1681 F77_CHAR_ARG_LEN (1)
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1682 F77_CHAR_ARG_LEN (1)));
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1683
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1684 if (calc_cond)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1685 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1686 char norm = '1';
19457 cb35d695713c avoid shadowed variable warnings from GCC John W. Eaton <jwe@octave.org> parents: 19446 diff changeset	1687 uplo = 'U';
cb35d695713c avoid shadowed variable warnings from GCC John W. Eaton <jwe@octave.org> parents: 19446 diff changeset	1688 dia = 'N';
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1689
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1690 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1691 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1692 Array<float> rz (dim_vector (nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1693 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1694
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1695 F77_XFCN (ctrcon, CTRCON, (F77_CONST_CHAR_ARG2 (&norm, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1696 F77_CONST_CHAR_ARG2 (&uplo, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1697 F77_CONST_CHAR_ARG2 (&dia, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1698 nr, F77_CONST_CMPLX_ARG (tmp_data), nr, rcon,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1699 F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1700 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1701 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1702 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1703
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1704 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1705 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1706
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1707 volatile float rcond_plus_one = rcon + 1.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1708
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	1709 if (rcond_plus_one == 1.0 \|\| octave::math::isnan (rcon))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1710 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1711 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1712
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1713 if (sing_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1714 sing_handler (rcon);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1715 else
21112 358aa7fcbd33 Rename errwarn_singular_matrix to warn_singular_matrix. Rik <rik@octave.org> parents: 21100 diff changeset	1716 warn_singular_matrix (rcon);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1717 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1718 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1719 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1720 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1721 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1722 (*current_liboctave_error_handler) ("incorrect matrix type");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1723 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1724
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1725 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1726 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1727
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1728 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1729 FloatComplexMatrix::ltsolve (MatrixType &mattype, const FloatComplexMatrix& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1730 octave_idx_type& info, float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1731 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1732 bool calc_cond, blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1733 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1734 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1735
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1736 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1737 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1738
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1739 if (nr != b.rows ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1740 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1741 ("matrix dimension mismatch solution of linear equations");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1742
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1743 if (nr == 0 \|\| nc == 0 \|\| b.cols () == 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1744 retval = FloatComplexMatrix (nc, b.cols (), FloatComplex (0.0, 0.0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1745 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1746 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1747 volatile int typ = mattype.type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1748
19864 17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions. John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1749 if (typ == MatrixType::Permuted_Lower \|\| typ == MatrixType::Lower)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1750 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1751 octave_idx_type b_nc = b.cols ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1752 rcon = 1.;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1753 info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1754
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1755 if (typ == MatrixType::Permuted_Lower)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1756 (*current_liboctave_error_handler)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1757 ("permuted triangular matrix not implemented");
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1758 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1759 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1760 const FloatComplex *tmp_data = fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1761
19446 0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1762 retval = b;
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1763 FloatComplex *result = retval.fortran_vec ();
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1764
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1765 char uplo = 'L';
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1766 char trans = get_blas_char (transt);
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1767 char dia = 'N';
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1768
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1769 F77_XFCN (ctrtrs, CTRTRS, (F77_CONST_CHAR_ARG2 (&uplo, 1),
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1770 F77_CONST_CHAR_ARG2 (&trans, 1),
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1771 F77_CONST_CHAR_ARG2 (&dia, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1772 nr, b_nc, F77_CONST_CMPLX_ARG (tmp_data), nr,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1773 F77_CMPLX_ARG (result), nr, info
19446 0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1774 F77_CHAR_ARG_LEN (1)
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1775 F77_CHAR_ARG_LEN (1)
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1776 F77_CHAR_ARG_LEN (1)));
0b4915fcd2eb don't skip solution of singular upper/lower triangular systems John W. Eaton <jwe@octave.org> parents: 19434 diff changeset	1777
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1778 if (calc_cond)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1779 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1780 char norm = '1';
19457 cb35d695713c avoid shadowed variable warnings from GCC John W. Eaton <jwe@octave.org> parents: 19446 diff changeset	1781 uplo = 'L';
cb35d695713c avoid shadowed variable warnings from GCC John W. Eaton <jwe@octave.org> parents: 19446 diff changeset	1782 dia = 'N';
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1783
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1784 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1785 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1786 Array<float> rz (dim_vector (nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1787 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1788
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1789 F77_XFCN (ctrcon, CTRCON, (F77_CONST_CHAR_ARG2 (&norm, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1790 F77_CONST_CHAR_ARG2 (&uplo, 1),
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1791 F77_CONST_CHAR_ARG2 (&dia, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1792 nr, F77_CONST_CMPLX_ARG (tmp_data), nr, rcon,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1793 F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1794 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1795 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1796 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1797
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1798 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1799 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1800
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1801 volatile float rcond_plus_one = rcon + 1.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1802
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	1803 if (rcond_plus_one == 1.0 \|\| octave::math::isnan (rcon))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1804 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1805 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1806
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1807 if (sing_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1808 sing_handler (rcon);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1809 else
21112 358aa7fcbd33 Rename errwarn_singular_matrix to warn_singular_matrix. Rik <rik@octave.org> parents: 21100 diff changeset	1810 warn_singular_matrix (rcon);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1811 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1812 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1813 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1814 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1815 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1816 (*current_liboctave_error_handler) ("incorrect matrix type");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1817 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1818
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1819 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1820 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1821
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1822 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1823 FloatComplexMatrix::fsolve (MatrixType &mattype, const FloatComplexMatrix& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1824 octave_idx_type& info, float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1825 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1826 bool calc_cond) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1827 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1828 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1829
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1830 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1831 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1832
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1833 if (nr != nc \|\| nr != b.rows ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1834 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1835 ("matrix dimension mismatch solution of linear equations");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1836
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	1837 if (nr == 0 \|\| b.cols () == 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1838 retval = FloatComplexMatrix (nc, b.cols (), FloatComplex (0.0, 0.0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1839 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1840 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1841 volatile int typ = mattype.type ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1842
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1843 // Calculate the norm of the matrix, for later use.
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1844 float anorm = -1.;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1845
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1846 if (typ == MatrixType::Hermitian)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1847 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1848 info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1849 char job = 'L';
15382 197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1850
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1851 FloatComplexMatrix atmp = *this;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1852 FloatComplex *tmp_data = atmp.fortran_vec ();
15382 197774b411ec rcond: use new copy of data for full factorization if positive definite cholesky factorization fails (bug #37336) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	1853
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1854 anorm = atmp.abs().sum().row(static_cast<octave_idx_type>(0)).max();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1855
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1856 F77_XFCN (cpotrf, CPOTRF, (F77_CONST_CHAR_ARG2 (&job, 1), nr,
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1857 F77_CMPLX_ARG (tmp_data), nr, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1858 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1859
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1860 // Throw-away extra info LAPACK gives so as to not change output.
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1861 rcon = 0.0;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1862 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1863 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1864 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1865
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1866 mattype.mark_as_unsymmetric ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1867 typ = MatrixType::Full;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1868 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1869 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1870 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1871 if (calc_cond)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1872 {
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1873 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1874 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1875 Array<float> rz (dim_vector (nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1876 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1877
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1878 F77_XFCN (cpocon, CPOCON, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1879 nr, F77_CMPLX_ARG (tmp_data), nr, anorm,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1880 rcon, F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1881 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1882
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1883 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1884 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1885
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1886 volatile float rcond_plus_one = rcon + 1.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1887
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	1888 if (rcond_plus_one == 1.0 \|\| octave::math::isnan (rcon))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1889 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1890 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1891
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1892 if (sing_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1893 sing_handler (rcon);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1894 else
21112 358aa7fcbd33 Rename errwarn_singular_matrix to warn_singular_matrix. Rik <rik@octave.org> parents: 21100 diff changeset	1895 warn_singular_matrix (rcon);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1896 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1897 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1898
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1899 if (info == 0)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1900 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1901 retval = b;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1902 FloatComplex *result = retval.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1903
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1904 octave_idx_type b_nc = b.cols ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1905
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1906 F77_XFCN (cpotrs, CPOTRS, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1907 nr, b_nc, F77_CMPLX_ARG (tmp_data), nr,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1908 F77_CMPLX_ARG (result), b.rows (), info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1909 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1910 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1911 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1912 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1913 mattype.mark_as_unsymmetric ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1914 typ = MatrixType::Full;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1915 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1916 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1917 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1918
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	1919 if (typ == MatrixType::Full)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1920 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1921 info = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1922
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1923 Array<octave_idx_type> ipvt (dim_vector (nr, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1924 octave_idx_type *pipvt = ipvt.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1925
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1926 FloatComplexMatrix atmp = *this;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1927 FloatComplex *tmp_data = atmp.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1928
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1929 Array<FloatComplex> z (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1930 FloatComplex *pz = z.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1931 Array<float> rz (dim_vector (2 * nc, 1));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1932 float *prz = rz.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1933
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1934 // Calculate the norm of the matrix, for later use.
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1935 if (anorm < 0.)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1936 anorm = atmp.abs ().sum ().row (static_cast<octave_idx_type>(0))
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1937 .max ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1938
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1939 // Work around bug #45577, LAPACK crashes Octave if norm is NaN
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1940 // and bug #46330, segfault with matrices containing Inf & NaN
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1941 if (octave::math::isnan (anorm) \|\| octave::math::isinf (anorm))
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1942 info = -2;
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	1943 else
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1944 F77_XFCN (cgetrf, CGETRF, (nr, nr, F77_CMPLX_ARG (tmp_data), nr, pipvt, info));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1945
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1946 // Throw-away extra info LAPACK gives so as to not change output.
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1947 rcon = 0.0;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1948 if (info != 0)
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1949 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1950 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1951
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1952 if (sing_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1953 sing_handler (rcon);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1954 else
21112 358aa7fcbd33 Rename errwarn_singular_matrix to warn_singular_matrix. Rik <rik@octave.org> parents: 21100 diff changeset	1955 warn_singular_matrix ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1956
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1957 mattype.mark_as_rectangular ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1958 }
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1959 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1960 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1961 if (calc_cond)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1962 {
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1963 // Now calculate the condition number for
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1964 // non-singular matrix.
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1965 char job = '1';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1966 F77_XFCN (cgecon, CGECON, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1967 nc, F77_CMPLX_ARG (tmp_data), nr, anorm,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1968 rcon, F77_CMPLX_ARG (pz), prz, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1969 F77_CHAR_ARG_LEN (1)));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1970
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1971 if (info != 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1972 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1973
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1974 volatile float rcond_plus_one = rcon + 1.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1975
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	1976 if (rcond_plus_one == 1.0 \|\| octave::math::isnan (rcon))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1977 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1978 info = -2;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1979
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1980 if (sing_handler)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1981 sing_handler (rcon);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1982 else
21112 358aa7fcbd33 Rename errwarn_singular_matrix to warn_singular_matrix. Rik <rik@octave.org> parents: 21100 diff changeset	1983 warn_singular_matrix (rcon);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1984 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1985 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1986
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1987 if (info == 0)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1988 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1989 retval = b;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1990 FloatComplex *result = retval.fortran_vec ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1991
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1992 octave_idx_type b_nc = b.cols ();
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1993
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1994 char job = 'N';
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1995 F77_XFCN (cgetrs, CGETRS, (F77_CONST_CHAR_ARG2 (&job, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1996 nr, b_nc, F77_CMPLX_ARG (tmp_data), nr,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	1997 pipvt, F77_CMPLX_ARG (result), b.rows (), info
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	1998 F77_CHAR_ARG_LEN (1)));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	1999 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2000 else
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2001 mattype.mark_as_rectangular ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2002 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2003 }
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	2004
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	2005 if (octave::math::isinf (anorm))
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	2006 {
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	2007 retval = FloatComplexMatrix (b.rows (), b.cols (),
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	2008 FloatComplex (0, 0));
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	2009 mattype.mark_as_full ();
bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	2010 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2011 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2012
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2013 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2014 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2015
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2016 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2017 FloatComplexMatrix::solve (MatrixType &typ, const FloatMatrix& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2018 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2019 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2020 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2021 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2022 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2023
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2024 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2025 FloatComplexMatrix::solve (MatrixType &typ, const FloatMatrix& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2026 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2027 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2028 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2029 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2030 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2031
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2032 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2033 FloatComplexMatrix::solve (MatrixType &typ, const FloatMatrix& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2034 octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2035 float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2036 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2037 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2038 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2039
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2040 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2041 FloatComplexMatrix::solve (MatrixType &typ, const FloatMatrix& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2042 octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2043 float& rcon, solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2044 bool singular_fallback, blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2045 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2046 FloatComplexMatrix tmp (b);
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9658 diff changeset	2047 return solve (typ, tmp, info, rcon, sing_handler, singular_fallback, transt);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2048 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2049
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2050 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2051 FloatComplexMatrix::solve (MatrixType &typ, const FloatComplexMatrix& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2052 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2053 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2054 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2055 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2056 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2057
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2058 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2059 FloatComplexMatrix::solve (MatrixType &typ, const FloatComplexMatrix& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2060 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2061 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2062 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2063 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2064 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2065
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2066 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2067 FloatComplexMatrix::solve (MatrixType &typ, const FloatComplexMatrix& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2068 octave_idx_type& info, float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2069 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2070 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2071 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2072
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2073 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2074 FloatComplexMatrix::solve (MatrixType &mattype, const FloatComplexMatrix& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2075 octave_idx_type& info, float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2076 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2077 bool singular_fallback, blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2078 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2079 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2080 int typ = mattype.type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2081
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2082 if (typ == MatrixType::Unknown)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2083 typ = mattype.type (*this);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2084
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2085 // Only calculate the condition number for LU/Cholesky
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2086 if (typ == MatrixType::Upper \|\| typ == MatrixType::Permuted_Upper)
19434 aee5fea8a03e compute condition number when solving triangular systems (bug #43875) John W. Eaton <jwe@octave.org> parents: 19408 diff changeset	2087 retval = utsolve (mattype, b, info, rcon, sing_handler, true, transt);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2088 else if (typ == MatrixType::Lower \|\| typ == MatrixType::Permuted_Lower)
19434 aee5fea8a03e compute condition number when solving triangular systems (bug #43875) John W. Eaton <jwe@octave.org> parents: 19408 diff changeset	2089 retval = ltsolve (mattype, b, info, rcon, sing_handler, true, transt);
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9658 diff changeset	2090 else if (transt == blas_trans)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2091 return transpose ().solve (mattype, b, info, rcon, sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2092 singular_fallback);
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9658 diff changeset	2093 else if (transt == blas_conj_trans)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2094 retval = hermitian ().solve (mattype, b, info, rcon, sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2095 singular_fallback);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2096 else if (typ == MatrixType::Full \|\| typ == MatrixType::Hermitian)
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2097 retval = fsolve (mattype, b, info, rcon, sing_handler, true);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2098 else if (typ != MatrixType::Rectangular)
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	2099 (*current_liboctave_error_handler) ("unknown matrix type");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2100
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2101 // Rectangular or one of the above solvers flags a singular matrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2102 if (singular_fallback && mattype.type () == MatrixType::Rectangular)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2103 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2104 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2105 retval = lssolve (b, info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2106 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2107
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2108 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2109 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2110
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2111 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2112 FloatComplexMatrix::solve (MatrixType &typ, const FloatColumnVector& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2113 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2114 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2115 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2116 return solve (typ, FloatComplexColumnVector (b), info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2117 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2118
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2119 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2120 FloatComplexMatrix::solve (MatrixType &typ, const FloatColumnVector& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2121 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2122 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2123 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2124 return solve (typ, FloatComplexColumnVector (b), info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2125 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2126
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2127 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2128 FloatComplexMatrix::solve (MatrixType &typ, const FloatColumnVector& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2129 octave_idx_type& info, float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2130 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2131 return solve (typ, FloatComplexColumnVector (b), info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2132 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2133
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2134 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2135 FloatComplexMatrix::solve (MatrixType &typ, const FloatColumnVector& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2136 octave_idx_type& info, float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2137 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2138 blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2139 {
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2140 return solve (typ, FloatComplexColumnVector (b), info, rcon, sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2141 transt);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2142 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2143
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2144 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2145 FloatComplexMatrix::solve (MatrixType &typ,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2146 const FloatComplexColumnVector& b) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2147 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2148 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2149 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2150 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2151 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2152
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2153 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2154 FloatComplexMatrix::solve (MatrixType &typ, const FloatComplexColumnVector& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2155 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2156 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2157 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2158 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2159 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2160
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2161 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2162 FloatComplexMatrix::solve (MatrixType &typ, const FloatComplexColumnVector& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2163 octave_idx_type& info, float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2164 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2165 return solve (typ, b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2166 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2167
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2168 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2169 FloatComplexMatrix::solve (MatrixType &typ, const FloatComplexColumnVector& b,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2170 octave_idx_type& info, float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2171 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2172 blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2173 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2174
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2175 FloatComplexMatrix tmp (b);
10352 a3635bc1ea19 remove Array2 Jaroslav Hajek <highegg@gmail.com> parents: 10350 diff changeset	2176 tmp = solve (typ, tmp, info, rcon, sing_handler, true, transt);
15018 3d8ace26c5b4 maint: Use Octave coding conventions for cuddled parentheses in liboctave/. Rik <rik@octave.org> parents: 14846 diff changeset	2177 return tmp.column (static_cast<octave_idx_type> (0));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2178 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2179
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2180 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2181 FloatComplexMatrix::solve (const FloatMatrix& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2182 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2183 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2184 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2185 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2186 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2187
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2188 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2189 FloatComplexMatrix::solve (const FloatMatrix& b, octave_idx_type& info) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2190 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2191 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2192 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2193 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2194
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2195 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2196 FloatComplexMatrix::solve (const FloatMatrix& b, octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2197 float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2198 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2199 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2200 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2201
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2202 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2203 FloatComplexMatrix::solve (const FloatMatrix& b, octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2204 float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2205 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2206 blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2207 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2208 FloatComplexMatrix tmp (b);
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9658 diff changeset	2209 return solve (tmp, info, rcon, sing_handler, transt);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2210 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2211
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2212 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2213 FloatComplexMatrix::solve (const FloatComplexMatrix& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2214 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2215 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2216 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2217 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2218 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2219
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2220 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2221 FloatComplexMatrix::solve (const FloatComplexMatrix& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2222 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2223 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2224 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2225 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2226 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2227
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2228 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2229 FloatComplexMatrix::solve (const FloatComplexMatrix& b, octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2230 float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2231 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2232 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2233 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2234
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2235 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2236 FloatComplexMatrix::solve (const FloatComplexMatrix& b, octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2237 float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2238 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2239 blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2240 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2241 MatrixType mattype (*this);
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9658 diff changeset	2242 return solve (mattype, b, info, rcon, sing_handler, true, transt);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2243 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2244
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2245 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2246 FloatComplexMatrix::solve (const FloatColumnVector& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2247 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2248 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2249 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2250 return solve (FloatComplexColumnVector (b), info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2251 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2252
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2253 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2254 FloatComplexMatrix::solve (const FloatColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2255 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2256 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2257 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2258 return solve (FloatComplexColumnVector (b), info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2259 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2260
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2261 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2262 FloatComplexMatrix::solve (const FloatColumnVector& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2263 float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2264 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2265 return solve (FloatComplexColumnVector (b), info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2266 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2267
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2268 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2269 FloatComplexMatrix::solve (const FloatColumnVector& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2270 float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2271 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2272 blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2273 {
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9658 diff changeset	2274 return solve (FloatComplexColumnVector (b), info, rcon, sing_handler, transt);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2275 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2276
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2277 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2278 FloatComplexMatrix::solve (const FloatComplexColumnVector& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2279 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2280 octave_idx_type info;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2281 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2282 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2283 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2284
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2285 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2286 FloatComplexMatrix::solve (const FloatComplexColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2287 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2288 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2289 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2290 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2291 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2292
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2293 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2294 FloatComplexMatrix::solve (const FloatComplexColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2295 octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2296 float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2297 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2298 return solve (b, info, rcon, 0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2299 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2300
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2301 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2302 FloatComplexMatrix::solve (const FloatComplexColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2303 octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2304 float& rcon,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2305 solve_singularity_handler sing_handler,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2306 blas_trans_type transt) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2307 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2308 MatrixType mattype (*this);
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9658 diff changeset	2309 return solve (mattype, b, info, rcon, sing_handler, transt);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2310 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2311
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2312 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2313 FloatComplexMatrix::lssolve (const FloatMatrix& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2314 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2315 octave_idx_type info;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2316 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2317 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2318 return lssolve (FloatComplexMatrix (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2319 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2320
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2321 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2322 FloatComplexMatrix::lssolve (const FloatMatrix& b, octave_idx_type& info) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2323 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2324 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2325 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2326 return lssolve (FloatComplexMatrix (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2327 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2328
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2329 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2330 FloatComplexMatrix::lssolve (const FloatMatrix& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2331 octave_idx_type& rank) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2332 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2333 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2334 return lssolve (FloatComplexMatrix (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2335 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2336
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2337 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2338 FloatComplexMatrix::lssolve (const FloatMatrix& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2339 octave_idx_type& rank, float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2340 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2341 return lssolve (FloatComplexMatrix (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2342 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2343
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2344 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2345 FloatComplexMatrix::lssolve (const FloatComplexMatrix& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2346 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2347 octave_idx_type info;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2348 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2349 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2350 return lssolve (b, info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2351 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2352
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2353 FloatComplexMatrix
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2354 FloatComplexMatrix::lssolve (const FloatComplexMatrix& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2355 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2356 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2357 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2358 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2359 return lssolve (b, info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2360 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2361
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2362 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2363 FloatComplexMatrix::lssolve (const FloatComplexMatrix& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2364 octave_idx_type& rank) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2365 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2366 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2367 return lssolve (b, info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2368 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2369
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2370 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2371 FloatComplexMatrix::lssolve (const FloatComplexMatrix& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2372 octave_idx_type& rank, float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2373 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2374 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2375
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2376 octave_idx_type nrhs = b.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2377
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2378 octave_idx_type m = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2379 octave_idx_type n = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2380
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2381 if (m != b.rows ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2382 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2383 ("matrix dimension mismatch solution of linear equations");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	2384
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	2385 if (m== 0 \|\| n == 0 \|\| b.cols () == 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2386 retval = FloatComplexMatrix (n, b.cols (), FloatComplex (0.0, 0.0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2387 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2388 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2389 volatile octave_idx_type minmn = (m < n ? m : n);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2390 octave_idx_type maxmn = m > n ? m : n;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2391 rcon = -1.0;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2392
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2393 if (m != n)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2394 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2395 retval = FloatComplexMatrix (maxmn, nrhs);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2396
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2397 for (octave_idx_type j = 0; j < nrhs; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2398 for (octave_idx_type i = 0; i < m; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2399 retval.elem (i, j) = b.elem (i, j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2400 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2401 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2402 retval = b;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2403
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2404 FloatComplexMatrix atmp = *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2405 FloatComplex *tmp_data = atmp.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2406
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2407 FloatComplex *pretval = retval.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2408 Array<float> s (dim_vector (minmn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2409 float *ps = s.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2410
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2411 // Ask ZGELSD what the dimension of WORK should be.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2412 octave_idx_type lwork = -1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2413
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2414 Array<FloatComplex> work (dim_vector (1, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2415
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2416 octave_idx_type smlsiz;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2417 F77_FUNC (xilaenv, XILAENV) (9, F77_CONST_CHAR_ARG2 ("CGELSD", 6),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2418 F77_CONST_CHAR_ARG2 (" ", 1),
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2419 0, 0, 0, 0, smlsiz
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2420 F77_CHAR_ARG_LEN (6)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2421 F77_CHAR_ARG_LEN (1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2422
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2423 octave_idx_type mnthr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2424 F77_FUNC (xilaenv, XILAENV) (6, F77_CONST_CHAR_ARG2 ("CGELSD", 6),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2425 F77_CONST_CHAR_ARG2 (" ", 1),
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2426 m, n, nrhs, -1, mnthr
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2427 F77_CHAR_ARG_LEN (6)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2428 F77_CHAR_ARG_LEN (1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2429
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2430 // We compute the size of rwork and iwork because ZGELSD in
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2431 // older versions of LAPACK does not return them on a query
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2432 // call.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2433 float dminmn = static_cast<float> (minmn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2434 float dsmlsizp1 = static_cast<float> (smlsiz+1);
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	2435 float tmp = octave::math::log2 (dminmn / dsmlsizp1);
18847 ff4da3c8ed16 use gnulib log2 modules (bug #42583) John W. Eaton <jwe@octave.org> parents: 18115 diff changeset	2436
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2437 octave_idx_type nlvl = static_cast<octave_idx_type> (tmp) + 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2438 if (nlvl < 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2439 nlvl = 0;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2440
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2441 octave_idx_type lrwork = minmn(10 + 2smlsiz + 8*nlvl)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2442 + 3smlsiznrhs
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2443 + std::max ((smlsiz+1)*(smlsiz+1),
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2444 n(1+nrhs) + 2nrhs);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2445 if (lrwork < 1)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2446 lrwork = 1;
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2447 Array<float> rwork (dim_vector (lrwork, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2448 float *prwork = rwork.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2449
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2450 octave_idx_type liwork = 3 * minmn * nlvl + 11 * minmn;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2451 if (liwork < 1)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2452 liwork = 1;
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2453 Array<octave_idx_type> iwork (dim_vector (liwork, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2454 octave_idx_type* piwork = iwork.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2455
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2456 F77_XFCN (cgelsd, CGELSD, (m, n, nrhs, F77_CMPLX_ARG (tmp_data), m, F77_CMPLX_ARG (pretval), maxmn,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2457 ps, rcon, rank, F77_CMPLX_ARG (work.fortran_vec ()),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2458 lwork, prwork, piwork, info));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2459
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2460 // The workspace query is broken in at least LAPACK 3.0.0
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2461 // through 3.1.1 when n >= mnthr. The obtuse formula below
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2462 // should provide sufficient workspace for ZGELSD to operate
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2463 // efficiently.
10813 2c2d4a2f1047 fix workspace bug workaround for xGELSD (since 7486:6a6d2abe51ff) Jaroslav Hajek <highegg@gmail.com> parents: 10806 diff changeset	2464 if (n > m && n >= mnthr)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2465 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2466 octave_idx_type addend = m;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2467
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2468 if (2*m-4 > addend)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2469 addend = 2*m-4;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2470
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2471 if (nrhs > addend)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2472 addend = nrhs;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2473
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2474 if (n-3*m > addend)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2475 addend = n-3*m;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2476
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2477 const octave_idx_type lworkaround = 4m + mm + addend;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2478
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	2479 if (octave::math::real (work(0)) < lworkaround)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2480 work(0) = lworkaround;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2481 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2482 else if (m >= n)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2483 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2484 octave_idx_type lworkaround = 2m + mnrhs;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2485
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	2486 if (octave::math::real (work(0)) < lworkaround)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2487 work(0) = lworkaround;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2488 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2489
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	2490 lwork = static_cast<octave_idx_type> (octave::math::real (work(0)));
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	2491 work.resize (dim_vector (lwork, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2492
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2493 F77_XFCN (cgelsd, CGELSD, (m, n, nrhs, F77_CMPLX_ARG (tmp_data), m, F77_CMPLX_ARG (pretval),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2494 maxmn, ps, rcon, rank,
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2495 F77_CMPLX_ARG (work.fortran_vec ()), lwork,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2496 prwork, piwork, info));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2497
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2498 if (s.elem (0) == 0.0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2499 rcon = 0.0;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2500 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2501 rcon = s.elem (minmn - 1) / s.elem (0);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2502
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2503 retval.resize (n, nrhs);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2504 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2505
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2506 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2507 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2508
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2509 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2510 FloatComplexMatrix::lssolve (const FloatColumnVector& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2511 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2512 octave_idx_type info;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2513 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2514 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2515 return lssolve (FloatComplexColumnVector (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2516 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2517
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2518 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2519 FloatComplexMatrix::lssolve (const FloatColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2520 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2521 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2522 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2523 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2524 return lssolve (FloatComplexColumnVector (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2525 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2526
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2527 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2528 FloatComplexMatrix::lssolve (const FloatColumnVector& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2529 octave_idx_type& rank) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2530 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2531 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2532 return lssolve (FloatComplexColumnVector (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2533 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2534
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2535 FloatComplexColumnVector
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2536 FloatComplexMatrix::lssolve (const FloatColumnVector& b, octave_idx_type& info,
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2537 octave_idx_type& rank, float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2538 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2539 return lssolve (FloatComplexColumnVector (b), info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2540 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2541
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2542 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2543 FloatComplexMatrix::lssolve (const FloatComplexColumnVector& b) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2544 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2545 octave_idx_type info;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2546 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2547 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2548 return lssolve (b, info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2549 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2550
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2551 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2552 FloatComplexMatrix::lssolve (const FloatComplexColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2553 octave_idx_type& info) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2554 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2555 octave_idx_type rank;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2556 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2557 return lssolve (b, info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2558 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2559
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2560 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2561 FloatComplexMatrix::lssolve (const FloatComplexColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2562 octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2563 octave_idx_type& rank) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2564 {
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2565 float rcon;
f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2566 return lssolve (b, info, rank, rcon);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2567
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2568 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2569
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2570 FloatComplexColumnVector
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2571 FloatComplexMatrix::lssolve (const FloatComplexColumnVector& b,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2572 octave_idx_type& info,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2573 octave_idx_type& rank, float& rcon) const
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2574 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2575 FloatComplexColumnVector retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2576
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2577 octave_idx_type nrhs = 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2578
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2579 octave_idx_type m = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2580 octave_idx_type n = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2581
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	2582 if (m != b.numel ())
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2583 (*current_liboctave_error_handler)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2584 ("matrix dimension mismatch solution of linear equations");
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	2585
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	2586 if (m == 0 \|\| n == 0 \|\| b.cols () == 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2587 retval = FloatComplexColumnVector (n, FloatComplex (0.0, 0.0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2588 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2589 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2590 volatile octave_idx_type minmn = (m < n ? m : n);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2591 octave_idx_type maxmn = m > n ? m : n;
7797 f42c6f8d6d8e Extend rcond function to single precision types David Bateman <dbateman@free.fr> parents: 7789 diff changeset	2592 rcon = -1.0;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2593
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2594 if (m != n)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2595 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2596 retval = FloatComplexColumnVector (maxmn);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2597
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2598 for (octave_idx_type i = 0; i < m; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2599 retval.elem (i) = b.elem (i);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2600 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2601 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2602 retval = b;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2603
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2604 FloatComplexMatrix atmp = *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2605 FloatComplex *tmp_data = atmp.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2606
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2607 FloatComplex *pretval = retval.fortran_vec ();
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2608 Array<float> s (dim_vector (minmn, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2609 float *ps = s.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2610
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2611 // Ask ZGELSD what the dimension of WORK should be.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2612 octave_idx_type lwork = -1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2613
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2614 Array<FloatComplex> work (dim_vector (1, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2615
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2616 octave_idx_type smlsiz;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2617 F77_FUNC (xilaenv, XILAENV) (9, F77_CONST_CHAR_ARG2 ("CGELSD", 6),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2618 F77_CONST_CHAR_ARG2 (" ", 1),
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2619 0, 0, 0, 0, smlsiz
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2620 F77_CHAR_ARG_LEN (6)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2621 F77_CHAR_ARG_LEN (1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2622
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2623 // We compute the size of rwork and iwork because ZGELSD in
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2624 // older versions of LAPACK does not return them on a query
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2625 // call.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2626 float dminmn = static_cast<float> (minmn);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2627 float dsmlsizp1 = static_cast<float> (smlsiz+1);
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	2628 float tmp = octave::math::log2 (dminmn / dsmlsizp1);
18847 ff4da3c8ed16 use gnulib log2 modules (bug #42583) John W. Eaton <jwe@octave.org> parents: 18115 diff changeset	2629
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2630 octave_idx_type nlvl = static_cast<octave_idx_type> (tmp) + 1;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2631 if (nlvl < 0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2632 nlvl = 0;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2633
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2634 octave_idx_type lrwork = minmn(10 + 2smlsiz + 8*nlvl)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2635 + 3smlsiznrhs + (smlsiz+1)*(smlsiz+1);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2636 if (lrwork < 1)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2637 lrwork = 1;
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2638 Array<float> rwork (dim_vector (lrwork, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2639 float *prwork = rwork.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2640
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2641 octave_idx_type liwork = 3 * minmn * nlvl + 11 * minmn;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2642 if (liwork < 1)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2643 liwork = 1;
11570 57632dea2446 attempt better backward compatibility for Array constructors John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	2644 Array<octave_idx_type> iwork (dim_vector (liwork, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2645 octave_idx_type* piwork = iwork.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2646
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2647 F77_XFCN (cgelsd, CGELSD, (m, n, nrhs, F77_CMPLX_ARG (tmp_data), m, F77_CMPLX_ARG (pretval), maxmn,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2648 ps, rcon, rank, F77_CMPLX_ARG (work.fortran_vec ()),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2649 lwork, prwork, piwork, info));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2650
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	2651 lwork = static_cast<octave_idx_type> (octave::math::real (work(0)));
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	2652 work.resize (dim_vector (lwork, 1));
a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	2653 rwork.resize (dim_vector (static_cast<octave_idx_type> (rwork(0)), 1));
a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	2654 iwork.resize (dim_vector (iwork(0), 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2655
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2656 F77_XFCN (cgelsd, CGELSD, (m, n, nrhs, F77_CMPLX_ARG (tmp_data), m, F77_CMPLX_ARG (pretval),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2657 maxmn, ps, rcon, rank,
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2658 F77_CMPLX_ARG (work.fortran_vec ()), lwork,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2659 prwork, piwork, info));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2660
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2661 if (rank < minmn)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2662 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2663 if (s.elem (0) == 0.0)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2664 rcon = 0.0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2665 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2666 rcon = s.elem (minmn - 1) / s.elem (0);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2667
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2668 retval.resize (n, nrhs);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2669 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2670 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2671
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2672 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2673 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2674
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2675 // column vector by row vector -> matrix operations
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2676
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2677 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2678 operator * (const FloatColumnVector& v, const FloatComplexRowVector& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2679 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2680 FloatComplexColumnVector tmp (v);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2681 return tmp * a;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2682 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2683
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2684 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2685 operator * (const FloatComplexColumnVector& a, const FloatRowVector& b)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2686 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2687 FloatComplexRowVector tmp (b);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2688 return a * tmp;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2689 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2690
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2691 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2692 operator * (const FloatComplexColumnVector& v, const FloatComplexRowVector& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2693 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2694 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2695
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	2696 octave_idx_type len = v.numel ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2697
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2698 if (len != 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2699 {
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	2700 octave_idx_type a_len = a.numel ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2701
9359 be6867ba8104 avoid useless zero initialization when doing matrix multiply Jaroslav Hajek <highegg@gmail.com> parents: 9227 diff changeset	2702 retval = FloatComplexMatrix (len, a_len);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2703 FloatComplex *c = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2704
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2705 F77_XFCN (cgemm, CGEMM, (F77_CONST_CHAR_ARG2 ("N", 1),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2706 F77_CONST_CHAR_ARG2 ("N", 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2707 len, a_len, 1, 1.0, F77_CONST_CMPLX_ARG (v.data ()), len,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	2708 F77_CONST_CMPLX_ARG (a.data ()), 1, 0.0, F77_CMPLX_ARG (c), len
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2709 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2710 F77_CHAR_ARG_LEN (1)));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2711 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2712
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2713 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2714 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2715
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2716 // matrix by diagonal matrix -> matrix operations
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2717
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2718 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2719 FloatComplexMatrix::operator += (const FloatDiagMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2720 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2721 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2722 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2723
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2724 octave_idx_type a_nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2725 octave_idx_type a_nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2726
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2727 if (nr != a_nr \|\| nc != a_nc)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21120 diff changeset	2728 err_nonconformant ("operator +=", nr, nc, a_nr, a_nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2729
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2730 for (octave_idx_type i = 0; i < a.length (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2731 elem (i, i) += a.elem (i, i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2732
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2733 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2734 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2735
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2736 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2737 FloatComplexMatrix::operator -= (const FloatDiagMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2738 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2739 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2740 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2741
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2742 octave_idx_type a_nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2743 octave_idx_type a_nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2744
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2745 if (nr != a_nr \|\| nc != a_nc)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21120 diff changeset	2746 err_nonconformant ("operator -=", nr, nc, a_nr, a_nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2747
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2748 for (octave_idx_type i = 0; i < a.length (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2749 elem (i, i) -= a.elem (i, i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2750
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2751 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2752 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2753
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2754 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2755 FloatComplexMatrix::operator += (const FloatComplexDiagMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2756 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2757 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2758 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2759
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2760 octave_idx_type a_nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2761 octave_idx_type a_nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2762
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2763 if (nr != a_nr \|\| nc != a_nc)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21120 diff changeset	2764 err_nonconformant ("operator +=", nr, nc, a_nr, a_nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2765
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2766 for (octave_idx_type i = 0; i < a.length (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2767 elem (i, i) += a.elem (i, i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2768
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2769 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2770 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2771
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2772 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2773 FloatComplexMatrix::operator -= (const FloatComplexDiagMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2774 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2775 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2776 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2777
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2778 octave_idx_type a_nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2779 octave_idx_type a_nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2780
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2781 if (nr != a_nr \|\| nc != a_nc)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21120 diff changeset	2782 err_nonconformant ("operator -=", nr, nc, a_nr, a_nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2783
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2784 for (octave_idx_type i = 0; i < a.length (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2785 elem (i, i) -= a.elem (i, i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2786
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2787 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2788 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2789
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2790 // matrix by matrix -> matrix operations
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2791
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2792 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2793 FloatComplexMatrix::operator += (const FloatMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2794 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2795 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2796 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2797
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2798 octave_idx_type a_nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2799 octave_idx_type a_nc = a.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2800
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2801 if (nr != a_nr \|\| nc != a_nc)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21120 diff changeset	2802 err_nonconformant ("operator +=", nr, nc, a_nr, a_nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2803
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2804 if (nr == 0 \|\| nc == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2805 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2806
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2807 FloatComplex *d = fortran_vec (); // Ensures only 1 reference to my privates!
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2808
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	2809 mx_inline_add2 (numel (), d, a.data ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2810 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2811 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2812
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2813 FloatComplexMatrix&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2814 FloatComplexMatrix::operator -= (const FloatMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2815 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2816 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2817 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2818
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2819 octave_idx_type a_nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2820 octave_idx_type a_nc = a.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2821
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2822 if (nr != a_nr \|\| nc != a_nc)
21129 228b65504557 maint: Eliminate useless statements after err_XXX. Rik <rik@octave.org> parents: 21120 diff changeset	2823 err_nonconformant ("operator -=", nr, nc, a_nr, a_nc);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2824
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2825 if (nr == 0 \|\| nc == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2826 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2827
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2828 FloatComplex *d = fortran_vec (); // Ensures only 1 reference to my privates!
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2829
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	2830 mx_inline_sub2 (numel (), d, a.data ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2831 return *this;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2832 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2833
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2834 // unary operations
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2835
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2836 boolMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2837 FloatComplexMatrix::all (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2838 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2839 return FloatComplexNDArray::all (dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2840 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2841
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2842 boolMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2843 FloatComplexMatrix::any (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2844 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2845 return FloatComplexNDArray::any (dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2846 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2847
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2848 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2849 FloatComplexMatrix::cumprod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2850 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2851 return FloatComplexNDArray::cumprod (dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2852 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2853
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2854 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2855 FloatComplexMatrix::cumsum (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2856 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2857 return FloatComplexNDArray::cumsum (dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2858 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2859
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2860 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2861 FloatComplexMatrix::prod (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2862 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2863 return FloatComplexNDArray::prod (dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2864 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2865
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2866 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2867 FloatComplexMatrix::sum (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2868 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2869 return FloatComplexNDArray::sum (dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2870 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2871
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2872 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2873 FloatComplexMatrix::sumsq (int dim) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2874 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2875 return FloatComplexNDArray::sumsq (dim);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2876 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2877
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2878 FloatMatrix FloatComplexMatrix::abs (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2879 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2880 return FloatComplexNDArray::abs ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2881 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2882
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2883 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2884 FloatComplexMatrix::diag (octave_idx_type k) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2885 {
19321 3746b92739f7 Replace some duplicated code and count on methods implemented on base classes. Carnë Draug <carandraug@octave.org> parents: 19320 diff changeset	2886 return FloatComplexNDArray::diag (k);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2887 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2888
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2889 FloatComplexDiagMatrix
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2890 FloatComplexMatrix::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: 14427 diff changeset	2891 {
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2892 FloatComplexDiagMatrix retval;
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2893
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2894 octave_idx_type nr = rows ();
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2895 octave_idx_type nc = cols ();
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2896
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2897 if (nr == 1 \|\| nc == 1)
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2898 retval = FloatComplexDiagMatrix (*this, m, n);
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2899 else
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	2900 (*current_liboctave_error_handler) ("diag: expecting vector argument");
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2901
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2902 return retval;
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2903 }
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14427 diff changeset	2904
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2905 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2906 FloatComplexMatrix::row_is_real_only (octave_idx_type i) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2907 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2908 bool retval = true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2909
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2910 octave_idx_type nc = columns ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2911
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2912 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2913 {
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	2914 if (octave::math::imag (elem (i, j)) != 0.0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2915 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2916 retval = false;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2917 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2918 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2919 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2920
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2921 return retval;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2922 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2923
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2924 bool
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2925 FloatComplexMatrix::column_is_real_only (octave_idx_type j) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2926 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2927 bool retval = true;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2928
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2929 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2930
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2931 for (octave_idx_type i = 0; i < nr; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2932 {
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	2933 if (octave::math::imag (elem (i, j)) != 0.0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2934 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2935 retval = false;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2936 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2937 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2938 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2939
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	2940 return retval;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2941 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2942
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2943 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2944 FloatComplexMatrix::row_min (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2945 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2946 Array<octave_idx_type> dummy_idx;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2947 return row_min (dummy_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2948 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2949
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2950 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2951 FloatComplexMatrix::row_min (Array<octave_idx_type>& idx_arg) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2952 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2953 FloatComplexColumnVector result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2954
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2955 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2956 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2957
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2958 if (nr > 0 && nc > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2959 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2960 result.resize (nr);
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	2961 idx_arg.resize (dim_vector (nr, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2962
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2963 for (octave_idx_type i = 0; i < nr; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	2964 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2965 bool real_only = row_is_real_only (i);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2966
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2967 octave_idx_type idx_j;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2968
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2969 FloatComplex tmp_min;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2970
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	2971 float abs_min = octave::numeric_limits<float>::NaN ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2972
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2973 for (idx_j = 0; idx_j < nc; idx_j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2974 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2975 tmp_min = elem (i, idx_j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2976
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	2977 if (! octave::math::isnan (tmp_min))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2978 {
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	2979 abs_min = real_only ? tmp_min.real ()
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	2980 : std::abs (tmp_min);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2981 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2982 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2983 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2984
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2985 for (octave_idx_type j = idx_j+1; j < nc; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2986 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2987 FloatComplex tmp = elem (i, j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2988
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	2989 if (octave::math::isnan (tmp))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2990 continue;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2991
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	2992 float abs_tmp = real_only ? tmp.real () : std::abs (tmp);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2993
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2994 if (abs_tmp < abs_min)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2995 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2996 idx_j = j;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2997 tmp_min = tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2998 abs_min = abs_tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	2999 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3000 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3001
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3002 if (octave::math::isnan (tmp_min))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3003 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3004 result.elem (i) = FloatComplex_NaN_result;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3005 idx_arg.elem (i) = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3006 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3007 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3008 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3009 result.elem (i) = tmp_min;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3010 idx_arg.elem (i) = idx_j;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3011 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3012 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3013 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3014
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3015 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3016 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3017
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3018 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3019 FloatComplexMatrix::row_max (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3020 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3021 Array<octave_idx_type> dummy_idx;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3022 return row_max (dummy_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3023 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3024
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3025 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3026 FloatComplexMatrix::row_max (Array<octave_idx_type>& idx_arg) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3027 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3028 FloatComplexColumnVector result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3029
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3030 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3031 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3032
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3033 if (nr > 0 && nc > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3034 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3035 result.resize (nr);
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	3036 idx_arg.resize (dim_vector (nr, 1));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3037
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3038 for (octave_idx_type i = 0; i < nr; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3039 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3040 bool real_only = row_is_real_only (i);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3041
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3042 octave_idx_type idx_j;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3043
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3044 FloatComplex tmp_max;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3045
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	3046 float abs_max = octave::numeric_limits<float>::NaN ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3047
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3048 for (idx_j = 0; idx_j < nc; idx_j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3049 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3050 tmp_max = elem (i, idx_j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3051
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3052 if (! octave::math::isnan (tmp_max))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3053 {
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	3054 abs_max = real_only ? tmp_max.real ()
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3055 : std::abs (tmp_max);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3056 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3057 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3058 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3059
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3060 for (octave_idx_type j = idx_j+1; j < nc; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3061 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3062 FloatComplex tmp = elem (i, j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3063
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3064 if (octave::math::isnan (tmp))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3065 continue;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3066
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	3067 float abs_tmp = real_only ? tmp.real () : std::abs (tmp);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3068
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3069 if (abs_tmp > abs_max)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3070 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3071 idx_j = j;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3072 tmp_max = tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3073 abs_max = abs_tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3074 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3075 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3076
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3077 if (octave::math::isnan (tmp_max))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3078 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3079 result.elem (i) = FloatComplex_NaN_result;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3080 idx_arg.elem (i) = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3081 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3082 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3083 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3084 result.elem (i) = tmp_max;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3085 idx_arg.elem (i) = idx_j;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3086 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3087 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3088 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3089
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3090 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3091 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3092
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3093 FloatComplexRowVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3094 FloatComplexMatrix::column_min (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3095 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3096 Array<octave_idx_type> dummy_idx;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3097 return column_min (dummy_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3098 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3099
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3100 FloatComplexRowVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3101 FloatComplexMatrix::column_min (Array<octave_idx_type>& idx_arg) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3102 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3103 FloatComplexRowVector result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3104
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3105 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3106 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3107
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3108 if (nr > 0 && nc > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3109 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3110 result.resize (nc);
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	3111 idx_arg.resize (dim_vector (1, nc));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3112
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3113 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3114 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3115 bool real_only = column_is_real_only (j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3116
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3117 octave_idx_type idx_i;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3118
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3119 FloatComplex tmp_min;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3120
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	3121 float abs_min = octave::numeric_limits<float>::NaN ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3122
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3123 for (idx_i = 0; idx_i < nr; idx_i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3124 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3125 tmp_min = elem (idx_i, j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3126
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3127 if (! octave::math::isnan (tmp_min))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3128 {
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	3129 abs_min = real_only ? tmp_min.real ()
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3130 : std::abs (tmp_min);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3131 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3132 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3133 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3134
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3135 for (octave_idx_type i = idx_i+1; i < nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3136 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3137 FloatComplex tmp = elem (i, j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3138
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3139 if (octave::math::isnan (tmp))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3140 continue;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3141
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	3142 float abs_tmp = real_only ? tmp.real () : std::abs (tmp);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3143
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3144 if (abs_tmp < abs_min)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3145 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3146 idx_i = i;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3147 tmp_min = tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3148 abs_min = abs_tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3149 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3150 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3151
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3152 if (octave::math::isnan (tmp_min))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3153 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3154 result.elem (j) = FloatComplex_NaN_result;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3155 idx_arg.elem (j) = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3156 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3157 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3158 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3159 result.elem (j) = tmp_min;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3160 idx_arg.elem (j) = idx_i;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3161 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3162 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3163 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3164
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3165 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3166 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3167
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3168 FloatComplexRowVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3169 FloatComplexMatrix::column_max (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3170 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3171 Array<octave_idx_type> dummy_idx;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3172 return column_max (dummy_idx);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3173 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3174
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3175 FloatComplexRowVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3176 FloatComplexMatrix::column_max (Array<octave_idx_type>& idx_arg) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3177 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3178 FloatComplexRowVector result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3179
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3180 octave_idx_type nr = rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3181 octave_idx_type nc = cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3182
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3183 if (nr > 0 && nc > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3184 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3185 result.resize (nc);
11574 a83bad07f7e3 attempt better backward compatibility for Array resize functions John W. Eaton <jwe@octave.org> parents: 11570 diff changeset	3186 idx_arg.resize (dim_vector (1, nc));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3187
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3188 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3189 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3190 bool real_only = column_is_real_only (j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3191
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3192 octave_idx_type idx_i;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3193
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3194 FloatComplex tmp_max;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3195
21723 bae585228161 use namespace for numeric_limits John W. Eaton <jwe@octave.org> parents: 21721 diff changeset	3196 float abs_max = octave::numeric_limits<float>::NaN ();
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3197
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3198 for (idx_i = 0; idx_i < nr; idx_i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3199 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3200 tmp_max = elem (idx_i, j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3201
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3202 if (! octave::math::isnan (tmp_max))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3203 {
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	3204 abs_max = real_only ? tmp_max.real ()
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3205 : std::abs (tmp_max);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3206 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3207 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3208 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3209
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3210 for (octave_idx_type i = idx_i+1; i < nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3211 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3212 FloatComplex tmp = elem (i, j);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3213
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3214 if (octave::math::isnan (tmp))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3215 continue;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3216
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	3217 float abs_tmp = real_only ? tmp.real () : std::abs (tmp);
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3218
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3219 if (abs_tmp > abs_max)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3220 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3221 idx_i = i;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3222 tmp_max = tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3223 abs_max = abs_tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3224 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3225 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3226
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3227 if (octave::math::isnan (tmp_max))
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3228 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3229 result.elem (j) = FloatComplex_NaN_result;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3230 idx_arg.elem (j) = 0;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3231 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3232 else
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3233 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3234 result.elem (j) = tmp_max;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3235 idx_arg.elem (j) = idx_i;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3236 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3237 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3238 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3239
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3240 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3241 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3242
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3243 // i/o
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3244
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3245 std::ostream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3246 operator << (std::ostream& os, const FloatComplexMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3247 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3248 for (octave_idx_type i = 0; i < a.rows (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3249 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3250 for (octave_idx_type j = 0; j < a.cols (); j++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3251 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3252 os << " ";
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3253 octave_write_complex (os, a.elem (i, j));
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3254 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3255 os << "\n";
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3256 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3257 return os;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3258 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3259
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3260 std::istream&
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3261 operator >> (std::istream& is, FloatComplexMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3262 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3263 octave_idx_type nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3264 octave_idx_type nc = a.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3265
8999 dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8956 diff changeset	3266 if (nr > 0 && nc > 0)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3267 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3268 FloatComplex tmp;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3269 for (octave_idx_type i = 0; i < nr; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3270 for (octave_idx_type j = 0; j < nc; j++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3271 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3272 tmp = octave_read_value<FloatComplex> (is);
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3273 if (is)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3274 a.elem (i, j) = tmp;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3275 else
21169 40051830f89b maint: Replace more instances of goto in liboctave with other constructs. Rik <rik@octave.org> parents: 21136 diff changeset	3276 return is;
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3277 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3278 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3279
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3280 return is;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3281 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3282
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3283 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3284 Givens (const FloatComplex& x, const FloatComplex& y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3285 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3286 float cc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3287 FloatComplex cs, temp_r;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3288
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3289 F77_FUNC (clartg, CLARTG) (F77_CONST_CMPLX_ARG (&x), F77_CONST_CMPLX_ARG (&y), cc, F77_CMPLX_ARG (&cs), F77_CMPLX_ARG (&temp_r));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3290
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3291 FloatComplexMatrix g (2, 2);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3292
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3293 g.elem (0, 0) = cc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3294 g.elem (1, 1) = cc;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3295 g.elem (0, 1) = cs;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3296 g.elem (1, 0) = -conj (cs);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3297
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3298 return g;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3299 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3300
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3301 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3302 Sylvester (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3303 const FloatComplexMatrix& c)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3304 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3305 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3306
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3307 // FIXME: need to check that a, b, and c are all the same
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3308 // size.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3309
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3310 // Compute Schur decompositions
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3311
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 22274 diff changeset	3312 octave::math::schur<FloatComplexMatrix> as (a, "U");
6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 22274 diff changeset	3313 octave::math::schur<FloatComplexMatrix> bs (b, "U");
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3314
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3315 // Transform c to new coordinates.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3316
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3317 FloatComplexMatrix ua = as.unitary_matrix ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3318 FloatComplexMatrix sch_a = as.schur_matrix ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3319
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3320 FloatComplexMatrix ub = bs.unitary_matrix ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3321 FloatComplexMatrix sch_b = bs.schur_matrix ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3322
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3323 FloatComplexMatrix cx = ua.hermitian () * c * ub;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3324
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3325 // Solve the sylvester equation, back-transform, and return the
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3326 // solution.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3327
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3328 octave_idx_type a_nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3329 octave_idx_type b_nr = b.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3330
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3331 float scale;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3332 octave_idx_type info;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3333
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3334 FloatComplex *pa = sch_a.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3335 FloatComplex *pb = sch_b.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3336 FloatComplex *px = cx.fortran_vec ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3337
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3338 F77_XFCN (ctrsyl, CTRSYL, (F77_CONST_CHAR_ARG2 ("N", 1),
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3339 F77_CONST_CHAR_ARG2 ("N", 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3340 1, a_nr, b_nr, F77_CMPLX_ARG (pa), a_nr, F77_CMPLX_ARG (pb),
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3341 b_nr, F77_CMPLX_ARG (px), a_nr, scale, info
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3342 F77_CHAR_ARG_LEN (1)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3343 F77_CHAR_ARG_LEN (1)));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3344
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3345 // FIXME: check info?
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3346
19065 d20c81d3cd21 Deprecate syl, add new function sylvester. Rik <rik@octave.org> parents: 18850 diff changeset	3347 retval = ua * cx * ub.hermitian ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3348
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3349 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3350 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3351
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3352 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3353 operator * (const FloatComplexMatrix& m, const FloatMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3354 {
9663 7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	3355 if (m.columns () > std::min (m.rows (), a.columns ()) / 10)
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	3356 return FloatComplexMatrix (real (m) * a, imag (m) * a);
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	3357 else
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	3358 return m * FloatComplexMatrix (a);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3359 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3360
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3361 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3362 operator * (const FloatMatrix& m, const FloatComplexMatrix& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3363 {
9663 7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	3364 if (a.rows () > std::min (m.rows (), a.columns ()) / 10)
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	3365 return FloatComplexMatrix (m * real (a), m * imag (a));
7e5b4de5fbfe improve mixed real x complex ops Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	3366 else
18115 0fa235a252a5 fix cut and paste error in Matrix by ComplexMatrix multiplication operator John W. Eaton <jwe@octave.org> parents: 17769 diff changeset	3367 return FloatComplexMatrix (m) * a;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3368 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3369
14427 d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3370 /*
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3371
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3372 ## Simple Dot Product, Matrix-Vector, and Matrix-Matrix Unit tests
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3373 %!assert (single ([1+i 2+i 3+i]) * single ([ 4+i ; 5+i ; 6+i]), single (29+21i), 5e-7)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3374 %!assert (single ([1+i 2+i ; 3+i 4+i]) * single ([5+i ; 6+i]), single ([15 + 14i ; 37 + 18i]), 5e-7)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3375 %!assert (single ([1+i 2+i ; 3+i 4+i ]) * single ([5+i 6+i ; 7+i 8+i]), single ([17 + 15i 20 + 17i; 41 + 19i 48 + 21i]), 5e-7)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3376 %!assert (single ([1 i])*single ([i 0])', single (-i))
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3377
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3378 ## Test some simple identities
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3379 %!shared M, cv, rv
14427 d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3380 %! M = single (randn (10,10))+ i*single (rand (10,10));
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3381 %! cv = single (randn (10,1))+ i*single (rand (10,1));
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3382 %! rv = single (randn (1,10))+ i*single (rand (1,10));
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3383 %!assert ([Mcv,Mcv], M*[cv,cv], 5e-6)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3384 %!assert ([M.'cv,M.'cv], M.'*[cv,cv], 5e-6)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3385 %!assert ([M'cv,M'cv], M'*[cv,cv], 5e-6)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3386 %!assert ([rvM;rvM], [rv;rv]*M, 5e-6)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3387 %!assert ([rvM.';rvM.'], [rv;rv]*M.', 5e-6)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3388 %!assert ([rvM';rvM'], [rv;rv]*M', 5e-6)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3389 %!assert (2rvcv, [rv,rv]*[cv;cv], 5e-6)
d07e989686b0 Use Octave coding conventions in liboctave %!test blocks Rik <octave@nomad.inbox5.com> parents: 14138 diff changeset	3390
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3391 */
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3392
11516 53edbf95fbb6 avoid GCC warnings John W. Eaton <jwe@octave.org> parents: 11130 diff changeset	3393 static char
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3394 get_blas_trans_arg (bool trans, bool conj)
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3395 {
11516 53edbf95fbb6 avoid GCC warnings John W. Eaton <jwe@octave.org> parents: 11130 diff changeset	3396 return trans ? (conj ? 'C' : 'T') : 'N';
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3397 }
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3398
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3399 // the general GEMM operation
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3400
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3401 FloatComplexMatrix
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3402 xgemm (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
9665 1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3403 blas_trans_type transa, blas_trans_type transb)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3404 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3405 FloatComplexMatrix retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3406
18084 8e056300994b Follow coding convention of defining and initializing only 1 variable per line in liboctave. Rik <rik@octave.org> parents: 18083 diff changeset	3407 bool tra = transa != blas_no_trans;
8e056300994b Follow coding convention of defining and initializing only 1 variable per line in liboctave. Rik <rik@octave.org> parents: 18083 diff changeset	3408 bool trb = transb != blas_no_trans;
8e056300994b Follow coding convention of defining and initializing only 1 variable per line in liboctave. Rik <rik@octave.org> parents: 18083 diff changeset	3409 bool cja = transa == blas_conj_trans;
8e056300994b Follow coding convention of defining and initializing only 1 variable per line in liboctave. Rik <rik@octave.org> parents: 18083 diff changeset	3410 bool cjb = transb == blas_conj_trans;
9665 1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3411
1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3412 octave_idx_type a_nr = tra ? a.cols () : a.rows ();
1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3413 octave_idx_type a_nc = tra ? a.rows () : a.cols ();
1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3414
1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3415 octave_idx_type b_nr = trb ? b.cols () : b.rows ();
1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3416 octave_idx_type b_nc = trb ? b.rows () : b.cols ();
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3417
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3418 if (a_nc != b_nr)
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 20955 diff changeset	3419 err_nonconformant ("operator *", a_nr, a_nc, b_nr, b_nc);
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3420
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3421 if (a_nr == 0 \|\| a_nc == 0 \|\| b_nc == 0)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3422 retval = FloatComplexMatrix (a_nr, b_nc, 0.0);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3423 else if (a.data () == b.data () && a_nr == b_nc && tra != trb)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3424 {
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3425 octave_idx_type lda = a.rows ();
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3426
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3427 // FIXME: looking at the reference BLAS, it appears that it
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3428 // should not be necessary to initialize the output matrix if
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3429 // BETA is 0 in the call to CHERK, but ATLAS appears to
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3430 // use the result matrix before zeroing the elements.
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3431
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3432 retval = FloatComplexMatrix (a_nr, b_nc, 0.0);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3433 FloatComplex *c = retval.fortran_vec ();
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3434
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3435 const char ctra = get_blas_trans_arg (tra, cja);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3436 if (cja \|\| cjb)
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3437 {
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3438 F77_XFCN (cherk, CHERK, (F77_CONST_CHAR_ARG2 ("U", 1),
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3439 F77_CONST_CHAR_ARG2 (&ctra, 1),
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3440 a_nr, a_nc, 1.0,
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3441 F77_CONST_CMPLX_ARG (a.data ()), lda, 0.0, F77_CMPLX_ARG (c), a_nr
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3442 F77_CHAR_ARG_LEN (1)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3443 F77_CHAR_ARG_LEN (1)));
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3444 for (octave_idx_type j = 0; j < a_nr; j++)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3445 for (octave_idx_type i = 0; i < j; i++)
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	3446 retval.xelem (j,i) = octave::math::conj (retval.xelem (i,j));
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3447 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3448 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3449 {
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3450 F77_XFCN (csyrk, CSYRK, (F77_CONST_CHAR_ARG2 ("U", 1),
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3451 F77_CONST_CHAR_ARG2 (&ctra, 1),
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3452 a_nr, a_nc, 1.0,
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3453 F77_CONST_CMPLX_ARG (a.data ()), lda, 0.0, F77_CMPLX_ARG (c), a_nr
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3454 F77_CHAR_ARG_LEN (1)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3455 F77_CHAR_ARG_LEN (1)));
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3456 for (octave_idx_type j = 0; j < a_nr; j++)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3457 for (octave_idx_type i = 0; i < j; i++)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3458 retval.xelem (j,i) = retval.xelem (i,j);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3459
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3460 }
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3461
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3462 }
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3463 else
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3464 {
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3465 octave_idx_type lda = a.rows ();
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3466 octave_idx_type tda = a.cols ();
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3467 octave_idx_type ldb = b.rows ();
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3468 octave_idx_type tdb = b.cols ();
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3469
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3470 retval = FloatComplexMatrix (a_nr, b_nc, 0.0);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3471 FloatComplex *c = retval.fortran_vec ();
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3472
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3473 if (b_nc == 1 && a_nr == 1)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3474 {
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3475 if (cja == cjb)
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3476 {
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3477 F77_FUNC (xcdotu, XCDOTU) (a_nc, F77_CONST_CMPLX_ARG (a.data ()), 1, F77_CONST_CMPLX_ARG (b.data ()), 1,
22145 cf5145769e37 * fCMatrix.cc (xgemm): Fix thinko in cset 407c66ae1e20. John W. Eaton <jwe@octave.org> parents: 22135 diff changeset	3478 F77_CMPLX_ARG (c));
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	3479 if (cja) c = octave::math::conj (c);
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3480 }
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3481 else if (cja)
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3482 F77_FUNC (xcdotc, XCDOTC) (a_nc, F77_CONST_CMPLX_ARG (a.data ()), 1, F77_CONST_CMPLX_ARG (b.data ()), 1,
22145 cf5145769e37 * fCMatrix.cc (xgemm): Fix thinko in cset 407c66ae1e20. John W. Eaton <jwe@octave.org> parents: 22135 diff changeset	3483 F77_CMPLX_ARG (c));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3484 else
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3485 F77_FUNC (xcdotc, XCDOTC) (a_nc, F77_CONST_CMPLX_ARG (b.data ()), 1, F77_CONST_CMPLX_ARG (a.data ()), 1,
22145 cf5145769e37 * fCMatrix.cc (xgemm): Fix thinko in cset 407c66ae1e20. John W. Eaton <jwe@octave.org> parents: 22135 diff changeset	3486 F77_CMPLX_ARG (c));
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3487 }
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3488 else if (b_nc == 1 && ! cjb)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3489 {
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3490 const char ctra = get_blas_trans_arg (tra, cja);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3491 F77_XFCN (cgemv, CGEMV, (F77_CONST_CHAR_ARG2 (&ctra, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3492 lda, tda, 1.0, F77_CONST_CMPLX_ARG (a.data ()), lda,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3493 F77_CONST_CMPLX_ARG (b.data ()), 1, 0.0, F77_CMPLX_ARG (c), 1
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3494 F77_CHAR_ARG_LEN (1)));
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3495 }
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3496 else if (a_nr == 1 && ! cja && ! cjb)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3497 {
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3498 const char crevtrb = get_blas_trans_arg (! trb, cjb);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3499 F77_XFCN (cgemv, CGEMV, (F77_CONST_CHAR_ARG2 (&crevtrb, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3500 ldb, tdb, 1.0, F77_CONST_CMPLX_ARG (b.data ()), ldb,
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3501 F77_CONST_CMPLX_ARG (a.data ()), 1, 0.0, F77_CMPLX_ARG (c), 1
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3502 F77_CHAR_ARG_LEN (1)));
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3503 }
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3504 else
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3505 {
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3506 const char ctra = get_blas_trans_arg (tra, cja);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3507 const char ctrb = get_blas_trans_arg (trb, cjb);
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3508 F77_XFCN (cgemm, CGEMM, (F77_CONST_CHAR_ARG2 (&ctra, 1),
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3509 F77_CONST_CHAR_ARG2 (&ctrb, 1),
22135 407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3510 a_nr, b_nc, a_nc, 1.0, F77_CONST_CMPLX_ARG (a.data ()),
407c66ae1e20 reduce warnings from GCC's link-time optimization feature (bug #48531) John W. Eaton <jwe@octave.org> parents: 22133 diff changeset	3511 lda, F77_CONST_CMPLX_ARG (b.data ()), ldb, 0.0, F77_CMPLX_ARG (c), a_nr
21120 499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3512 F77_CHAR_ARG_LEN (1)
499b851fbfae Replace pattern if/err_XXX/else/code with if/err_XXX/ code. Rik <rik@octave.org> parents: 21112 diff changeset	3513 F77_CHAR_ARG_LEN (1)));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3514 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3515 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3516
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3517 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3518 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3519
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3520 FloatComplexMatrix
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3521 operator * (const FloatComplexMatrix& a, const FloatComplexMatrix& b)
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3522 {
9665 1dba57e9d08d use blas_trans_type for xgemm Jaroslav Hajek <highegg@gmail.com> parents: 9663 diff changeset	3523 return xgemm (a, b);
7804 a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3524 }
a0c550b22e61 compound ops for float matrices Jaroslav Hajek <highegg@gmail.com> parents: 7797 diff changeset	3525
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3526 // FIXME: it would be nice to share code among the min/max
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3527 // functions below.
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3528
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22145 diff changeset	3529 #define EMPTY_RETURN_CHECK(T) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22145 diff changeset	3530 if (nr == 0 \|\| nc == 0) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3531 return T (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3532
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3533 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3534 min (const FloatComplex& c, const FloatComplexMatrix& m)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3535 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3536 octave_idx_type nr = m.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3537 octave_idx_type nc = m.columns ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3538
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3539 EMPTY_RETURN_CHECK (FloatComplexMatrix);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3540
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3541 FloatComplexMatrix result (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3542
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3543 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3544 for (octave_idx_type i = 0; i < nr; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3545 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3546 octave_quit ();
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3547 result(i, j) = octave::math::min (c, m(i, j));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3548 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3549
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3550 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3551 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3552
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3553 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3554 min (const FloatComplexMatrix& m, const FloatComplex& c)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3555 {
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	3556 return min (c, m);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3557 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3558
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3559 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3560 min (const FloatComplexMatrix& a, const FloatComplexMatrix& b)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3561 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3562 octave_idx_type nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3563 octave_idx_type nc = a.columns ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3564
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3565 if (nr != b.rows () \|\| nc != b.columns ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	3566 (*current_liboctave_error_handler)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	3567 ("two-arg min requires same size arguments");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3568
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3569 EMPTY_RETURN_CHECK (FloatComplexMatrix);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3570
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3571 FloatComplexMatrix result (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3572
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3573 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3574 {
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	3575 bool columns_are_real_only = true;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3576 for (octave_idx_type i = 0; i < nr; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3577 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3578 octave_quit ();
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	3579 if (octave::math::imag (a(i, j)) != 0.0 \|\| octave::math::imag (b(i, j)) != 0.0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3580 {
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	3581 columns_are_real_only = false;
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3582 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3583 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3584 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3585
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3586 if (columns_are_real_only)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3587 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3588 for (octave_idx_type i = 0; i < nr; i++)
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	3589 result(i, j) = octave::math::min (octave::math::real (a(i, j)), octave::math::real (b(i, j)));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3590 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3591 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3592 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3593 for (octave_idx_type i = 0; i < nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3594 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3595 octave_quit ();
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3596 result(i, j) = octave::math::min (a(i, j), b(i, j));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3597 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3598 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3599 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3600
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3601 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3602 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3603
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3604 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3605 max (const FloatComplex& c, const FloatComplexMatrix& m)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3606 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3607 octave_idx_type nr = m.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3608 octave_idx_type nc = m.columns ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3609
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3610 EMPTY_RETURN_CHECK (FloatComplexMatrix);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3611
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3612 FloatComplexMatrix result (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3613
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3614 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3615 for (octave_idx_type i = 0; i < nr; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3616 {
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3617 octave_quit ();
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3618 result(i, j) = octave::math::max (c, m(i, j));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3619 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3620
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3621 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3622 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3623
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3624 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3625 max (const FloatComplexMatrix& m, const FloatComplex& c)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3626 {
22085 bf5fbf347aaf Avoid segfault with complex matrices using LAPACK (bug #46330). Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 22022 diff changeset	3627 return max (c, m);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3628 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3629
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3630 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3631 max (const FloatComplexMatrix& a, const FloatComplexMatrix& b)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3632 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3633 octave_idx_type nr = a.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3634 octave_idx_type nc = a.columns ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3635
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3636 if (nr != b.rows () \|\| nc != b.columns ())
21136 7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	3637 (*current_liboctave_error_handler)
7cac4e7458f2 maint: clean up code around calls to current_liboctave_error_handler. Rik <rik@octave.org> parents: 21129 diff changeset	3638 ("two-arg max requires same size arguments");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3639
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3640 EMPTY_RETURN_CHECK (FloatComplexMatrix);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3641
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3642 FloatComplexMatrix result (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3643
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3644 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3645 {
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	3646 bool columns_are_real_only = true;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3647 for (octave_idx_type i = 0; i < nr; i++)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3648 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3649 octave_quit ();
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	3650 if (octave::math::imag (a(i, j)) != 0.0 \|\| octave::math::imag (b(i, j)) != 0.0)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3651 {
21719 ff054947d132 use bool instead of int for some logical flags John W. Eaton <jwe@octave.org> parents: 21301 diff changeset	3652 columns_are_real_only = false;
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3653 break;
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3654 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3655 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3656
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3657 if (columns_are_real_only)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3658 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3659 for (octave_idx_type i = 0; i < nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3660 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3661 octave_quit ();
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	3662 result(i, j) = octave::math::max (octave::math::real (a(i, j)), octave::math::real (b(i, j)));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3663 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3664 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3665 else
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3666 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3667 for (octave_idx_type i = 0; i < nr; i++)
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3668 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3669 octave_quit ();
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	3670 result(i, j) = octave::math::max (a(i, j), b(i, j));
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3671 }
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10213 diff changeset	3672 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3673 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3674
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3675 return result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3676 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3677
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3678 FloatComplexMatrix linspace (const FloatComplexColumnVector& x1,
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3679 const FloatComplexColumnVector& x2,
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3680 octave_idx_type n)
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3681
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3682 {
20232 a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	3683 octave_idx_type m = x1.numel ();
a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	3684
a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	3685 if (x2.numel () != m)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3686 (*current_liboctave_error_handler)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	3687 ("linspace: vectors must be of equal length");
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3688
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3689 NoAlias<FloatComplexMatrix> retval;
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3690
20466 16b9ec39ff46 Return empty matrix when linspace called with 0 points (bug #45820) Rik <rik@octave.org> parents: 20232 diff changeset	3691 if (n < 1)
16b9ec39ff46 Return empty matrix when linspace called with 0 points (bug #45820) Rik <rik@octave.org> parents: 20232 diff changeset	3692 {
16b9ec39ff46 Return empty matrix when linspace called with 0 points (bug #45820) Rik <rik@octave.org> parents: 20232 diff changeset	3693 retval.clear (m, 0);
16b9ec39ff46 Return empty matrix when linspace called with 0 points (bug #45820) Rik <rik@octave.org> parents: 20232 diff changeset	3694 return retval;
16b9ec39ff46 Return empty matrix when linspace called with 0 points (bug #45820) Rik <rik@octave.org> parents: 20232 diff changeset	3695 }
16b9ec39ff46 Return empty matrix when linspace called with 0 points (bug #45820) Rik <rik@octave.org> parents: 20232 diff changeset	3696
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3697 retval.clear (m, n);
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3698 for (octave_idx_type i = 0; i < m; i++)
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3699 retval(i, 0) = x1(i);
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3700
20466 16b9ec39ff46 Return empty matrix when linspace called with 0 points (bug #45820) Rik <rik@octave.org> parents: 20232 diff changeset	3701 // The last column is unused so temporarily store delta there
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	3702 FloatComplex *delta = &retval(0, n-1);
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3703 for (octave_idx_type i = 0; i < m; i++)
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3704 delta[i] = (x2(i) - x1(i)) / (n - 1.0f);
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3705
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3706 for (octave_idx_type j = 1; j < n-1; j++)
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3707 for (octave_idx_type i = 0; i < m; i++)
9658 3429c956de6f extend linspace & fix up liboctave rewrite Jaroslav Hajek <highegg@gmail.com> parents: 9653 diff changeset	3708 retval(i, j) = x1(i) + static_cast<float> (j)*delta[i];
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3709
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3710 for (octave_idx_type i = 0; i < m; i++)
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3711 retval(i, n-1) = x2(i);
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3712
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3713 return retval;
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3714 }
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9601 diff changeset	3715
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	3716 MS_CMP_OPS (FloatComplexMatrix, FloatComplex)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9528 diff changeset	3717 MS_BOOL_OPS (FloatComplexMatrix, FloatComplex)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3718
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	3719 SM_CMP_OPS (FloatComplex, FloatComplexMatrix)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9528 diff changeset	3720 SM_BOOL_OPS (FloatComplex, FloatComplexMatrix)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: diff changeset	3721
9578 7dafdb8b062f refactor comparison ops implementations Jaroslav Hajek <highegg@gmail.com> parents: 9553 diff changeset	3722 MM_CMP_OPS (FloatComplexMatrix, FloatComplexMatrix)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9528 diff changeset	3723 MM_BOOL_OPS (FloatComplexMatrix, FloatComplexMatrix)

Mercurial > octave

annotate liboctave/array/fCMatrix.cc @ 22323:bac0d6f07a3e