Mercurial > octave-nkf
annotate liboctave/dDiagMatrix.cc @ 10158:4c0cdbe0acca
remove Emacs local-variable settings from liboctave source files
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Wed, 20 Jan 2010 19:04:35 -0500 |
| parents | f80c566bc751 |
| children | 07ebe522dac2 |
| rev | line source |
|---|---|
| 1993 | 1 // DiagMatrix manipulations. |
| 458 | 2 /* |
| 3 | |
| 7017 | 4 Copyright (C) 1994, 1995, 1996, 1997, 2000, 2001, 2002, 2003, 2004, |
| 8920 | 5 2005, 2007, 2008, 2009 John W. Eaton |
|
9601
a9b37bae1802
add a couple of missing copyright statements
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
6 Copyright (C) 2009 VZLU Prague |
| 458 | 7 |
| 8 This file is part of Octave. | |
| 9 | |
| 10 Octave is free software; you can redistribute it and/or modify it | |
| 11 under the terms of the GNU General Public License as published by the | |
| 7016 | 12 Free Software Foundation; either version 3 of the License, or (at your |
| 13 option) any later version. | |
| 458 | 14 |
| 15 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 18 for more details. | |
| 19 | |
| 20 You should have received a copy of the GNU General Public License | |
| 7016 | 21 along with Octave; see the file COPYING. If not, see |
| 22 <http://www.gnu.org/licenses/>. | |
| 458 | 23 |
| 24 */ | |
| 25 | |
| 26 #ifdef HAVE_CONFIG_H | |
| 1192 | 27 #include <config.h> |
| 458 | 28 #endif |
| 29 | |
| 3503 | 30 #include <iostream> |
| 458 | 31 |
| 4669 | 32 #include "Array-util.h" |
| 1368 | 33 #include "lo-error.h" |
| 458 | 34 #include "mx-base.h" |
| 35 #include "mx-inlines.cc" | |
| 1650 | 36 #include "oct-cmplx.h" |
| 458 | 37 |
| 1360 | 38 // Diagonal Matrix class. |
| 458 | 39 |
| 2385 | 40 bool |
| 458 | 41 DiagMatrix::operator == (const DiagMatrix& a) const |
| 42 { | |
| 43 if (rows () != a.rows () || cols () != a.cols ()) | |
| 44 return 0; | |
| 45 | |
|
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
46 return mx_inline_equal (length (), data (), a.data ()); |
| 458 | 47 } |
| 48 | |
| 2385 | 49 bool |
| 458 | 50 DiagMatrix::operator != (const DiagMatrix& a) const |
| 51 { | |
| 52 return !(*this == a); | |
| 53 } | |
| 54 | |
| 55 DiagMatrix& | |
| 56 DiagMatrix::fill (double val) | |
| 57 { | |
| 5275 | 58 for (octave_idx_type i = 0; i < length (); i++) |
| 458 | 59 elem (i, i) = val; |
| 60 return *this; | |
| 61 } | |
| 62 | |
| 63 DiagMatrix& | |
| 5275 | 64 DiagMatrix::fill (double val, octave_idx_type beg, octave_idx_type end) |
| 458 | 65 { |
| 66 if (beg < 0 || end >= length () || end < beg) | |
| 67 { | |
| 68 (*current_liboctave_error_handler) ("range error for fill"); | |
| 69 return *this; | |
| 70 } | |
| 71 | |
| 5275 | 72 for (octave_idx_type i = beg; i <= end; i++) |
| 458 | 73 elem (i, i) = val; |
| 74 | |
| 75 return *this; | |
| 76 } | |
| 77 | |
| 78 DiagMatrix& | |
| 79 DiagMatrix::fill (const ColumnVector& a) | |
| 80 { | |
| 5275 | 81 octave_idx_type len = length (); |
| 458 | 82 if (a.length () != len) |
| 83 { | |
| 84 (*current_liboctave_error_handler) ("range error for fill"); | |
| 85 return *this; | |
| 86 } | |
| 87 | |
| 5275 | 88 for (octave_idx_type i = 0; i < len; i++) |
| 458 | 89 elem (i, i) = a.elem (i); |
| 90 | |
| 91 return *this; | |
| 92 } | |
| 93 | |
| 94 DiagMatrix& | |
| 95 DiagMatrix::fill (const RowVector& a) | |
| 96 { | |
| 5275 | 97 octave_idx_type len = length (); |
| 458 | 98 if (a.length () != len) |
| 99 { | |
| 100 (*current_liboctave_error_handler) ("range error for fill"); | |
| 101 return *this; | |
| 102 } | |
| 103 | |
| 5275 | 104 for (octave_idx_type i = 0; i < len; i++) |
| 458 | 105 elem (i, i) = a.elem (i); |
| 106 | |
| 107 return *this; | |
| 108 } | |
| 109 | |
| 110 DiagMatrix& | |
| 5275 | 111 DiagMatrix::fill (const ColumnVector& a, octave_idx_type beg) |
| 458 | 112 { |
| 5275 | 113 octave_idx_type a_len = a.length (); |
| 458 | 114 if (beg < 0 || beg + a_len >= length ()) |
| 115 { | |
| 116 (*current_liboctave_error_handler) ("range error for fill"); | |
| 117 return *this; | |
| 118 } | |
| 119 | |
| 5275 | 120 for (octave_idx_type i = 0; i < a_len; i++) |
| 458 | 121 elem (i+beg, i+beg) = a.elem (i); |
| 122 | |
| 123 return *this; | |
| 124 } | |
| 125 | |
| 126 DiagMatrix& | |
| 5275 | 127 DiagMatrix::fill (const RowVector& a, octave_idx_type beg) |
| 458 | 128 { |
| 5275 | 129 octave_idx_type a_len = a.length (); |
| 458 | 130 if (beg < 0 || beg + a_len >= length ()) |
| 131 { | |
| 132 (*current_liboctave_error_handler) ("range error for fill"); | |
| 133 return *this; | |
| 134 } | |
| 135 | |
| 5275 | 136 for (octave_idx_type i = 0; i < a_len; i++) |
| 458 | 137 elem (i+beg, i+beg) = a.elem (i); |
| 138 | |
| 139 return *this; | |
| 140 } | |
| 141 | |
| 142 DiagMatrix | |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
143 DiagMatrix::abs (void) const |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
144 { |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
145 DiagMatrix retval (rows (), cols ()); |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
146 for (octave_idx_type i = 0; i < rows (); i++) |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
147 retval(i, i) = std::abs (elem (i, i)); |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
148 return retval; |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
149 } |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
150 |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
7924
diff
changeset
|
151 DiagMatrix |
| 1205 | 152 real (const ComplexDiagMatrix& a) |
| 153 { | |
| 154 DiagMatrix retval; | |
| 5275 | 155 octave_idx_type a_len = a.length (); |
| 1205 | 156 if (a_len > 0) |
| 3769 | 157 retval = DiagMatrix (mx_inline_real_dup (a.data (), a_len), a.rows (), |
| 1205 | 158 a.cols ()); |
| 159 return retval; | |
| 160 } | |
| 161 | |
| 162 DiagMatrix | |
| 163 imag (const ComplexDiagMatrix& a) | |
| 164 { | |
| 165 DiagMatrix retval; | |
| 5275 | 166 octave_idx_type a_len = a.length (); |
| 1205 | 167 if (a_len > 0) |
| 3769 | 168 retval = DiagMatrix (mx_inline_imag_dup (a.data (), a_len), a.rows (), |
| 1205 | 169 a.cols ()); |
| 170 return retval; | |
| 171 } | |
| 172 | |
| 458 | 173 Matrix |
| 5275 | 174 DiagMatrix::extract (octave_idx_type r1, octave_idx_type c1, octave_idx_type r2, octave_idx_type c2) const |
| 458 | 175 { |
| 5275 | 176 if (r1 > r2) { octave_idx_type tmp = r1; r1 = r2; r2 = tmp; } |
| 177 if (c1 > c2) { octave_idx_type tmp = c1; c1 = c2; c2 = tmp; } | |
| 458 | 178 |
| 5275 | 179 octave_idx_type new_r = r2 - r1 + 1; |
| 180 octave_idx_type new_c = c2 - c1 + 1; | |
| 458 | 181 |
| 182 Matrix result (new_r, new_c); | |
| 183 | |
| 5275 | 184 for (octave_idx_type j = 0; j < new_c; j++) |
| 185 for (octave_idx_type i = 0; i < new_r; i++) | |
| 458 | 186 result.elem (i, j) = elem (r1+i, c1+j); |
| 187 | |
| 188 return result; | |
| 189 } | |
| 190 | |
| 191 // extract row or column i. | |
| 192 | |
| 193 RowVector | |
| 5275 | 194 DiagMatrix::row (octave_idx_type i) const |
| 458 | 195 { |
| 5275 | 196 octave_idx_type r = rows (); |
| 197 octave_idx_type c = cols (); | |
| 3504 | 198 if (i < 0 || i >= r) |
| 458 | 199 { |
| 200 (*current_liboctave_error_handler) ("invalid row selection"); | |
| 201 return RowVector (); | |
| 202 } | |
| 203 | |
| 3504 | 204 RowVector retval (c, 0.0); |
| 205 if (r <= c || (r > c && i < c)) | |
| 458 | 206 retval.elem (i) = elem (i, i); |
| 207 | |
| 208 return retval; | |
| 209 } | |
| 210 | |
| 211 RowVector | |
| 212 DiagMatrix::row (char *s) const | |
| 213 { | |
| 533 | 214 if (! s) |
| 458 | 215 { |
| 216 (*current_liboctave_error_handler) ("invalid row selection"); | |
| 217 return RowVector (); | |
| 218 } | |
| 219 | |
| 220 char c = *s; | |
| 221 if (c == 'f' || c == 'F') | |
| 5275 | 222 return row (static_cast<octave_idx_type>(0)); |
| 458 | 223 else if (c == 'l' || c == 'L') |
| 224 return row (rows () - 1); | |
| 225 else | |
| 226 { | |
| 227 (*current_liboctave_error_handler) ("invalid row selection"); | |
| 228 return RowVector (); | |
| 229 } | |
| 230 } | |
| 231 | |
| 232 ColumnVector | |
| 5275 | 233 DiagMatrix::column (octave_idx_type i) const |
| 458 | 234 { |
| 5275 | 235 octave_idx_type r = rows (); |
| 236 octave_idx_type c = cols (); | |
| 3504 | 237 if (i < 0 || i >= c) |
| 458 | 238 { |
| 239 (*current_liboctave_error_handler) ("invalid column selection"); | |
| 240 return ColumnVector (); | |
| 241 } | |
| 242 | |
| 3504 | 243 ColumnVector retval (r, 0.0); |
| 244 if (r >= c || (r < c && i < r)) | |
| 458 | 245 retval.elem (i) = elem (i, i); |
| 246 | |
| 247 return retval; | |
| 248 } | |
| 249 | |
| 250 ColumnVector | |
| 251 DiagMatrix::column (char *s) const | |
| 252 { | |
| 533 | 253 if (! s) |
| 458 | 254 { |
| 255 (*current_liboctave_error_handler) ("invalid column selection"); | |
| 256 return ColumnVector (); | |
| 257 } | |
| 258 | |
| 259 char c = *s; | |
| 260 if (c == 'f' || c == 'F') | |
| 5275 | 261 return column (static_cast<octave_idx_type>(0)); |
| 458 | 262 else if (c == 'l' || c == 'L') |
| 263 return column (cols () - 1); | |
| 264 else | |
| 265 { | |
| 266 (*current_liboctave_error_handler) ("invalid column selection"); | |
| 267 return ColumnVector (); | |
| 268 } | |
| 269 } | |
| 270 | |
| 271 DiagMatrix | |
| 272 DiagMatrix::inverse (void) const | |
| 273 { | |
| 8811 | 274 octave_idx_type info; |
| 458 | 275 return inverse (info); |
| 276 } | |
| 277 | |
| 278 DiagMatrix | |
| 8811 | 279 DiagMatrix::inverse (octave_idx_type &info) const |
| 458 | 280 { |
| 5275 | 281 octave_idx_type r = rows (); |
| 282 octave_idx_type c = cols (); | |
| 283 octave_idx_type len = length (); | |
| 3504 | 284 if (r != c) |
| 458 | 285 { |
| 286 (*current_liboctave_error_handler) ("inverse requires square matrix"); | |
| 287 return DiagMatrix (); | |
| 288 } | |
| 289 | |
| 3504 | 290 DiagMatrix retval (r, c); |
| 1627 | 291 |
| 458 | 292 info = 0; |
| 5275 | 293 for (octave_idx_type i = 0; i < len; i++) |
| 458 | 294 { |
| 295 if (elem (i, i) == 0.0) | |
| 296 { | |
| 297 info = -1; | |
| 1627 | 298 return *this; |
| 458 | 299 } |
| 300 else | |
| 1627 | 301 retval.elem (i, i) = 1.0 / elem (i, i); |
| 458 | 302 } |
| 303 | |
| 1627 | 304 return retval; |
| 458 | 305 } |
| 306 | |
|
8840
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
307 DiagMatrix |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
308 DiagMatrix::pseudo_inverse (void) const |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
309 { |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
310 octave_idx_type r = rows (); |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
311 octave_idx_type c = cols (); |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
312 octave_idx_type len = length (); |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
313 |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
314 DiagMatrix retval (c, r); |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
315 |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
316 for (octave_idx_type i = 0; i < len; i++) |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
317 { |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
318 if (elem (i, i) != 0.0) |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
319 retval.elem (i, i) = 1.0 / elem (i, i); |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
320 else |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
321 retval.elem (i, i) = 0.0; |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
322 } |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
323 |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
324 return retval; |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
325 } |
|
c690e3772583
support diagonal matrices in pinv
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
326 |
| 458 | 327 // diagonal matrix by diagonal matrix -> diagonal matrix operations |
| 328 | |
| 329 // diagonal matrix by diagonal matrix -> diagonal matrix operations | |
| 330 | |
| 331 DiagMatrix | |
| 332 operator * (const DiagMatrix& a, const DiagMatrix& b) | |
| 333 { | |
| 5275 | 334 octave_idx_type a_nr = a.rows (); |
| 335 octave_idx_type a_nc = a.cols (); | |
| 2385 | 336 |
| 5275 | 337 octave_idx_type b_nr = b.rows (); |
| 338 octave_idx_type b_nc = b.cols (); | |
| 2385 | 339 |
| 3504 | 340 if (a_nc != b_nr) |
|
9698
7c6d5d8c8d37
fix diag*diag multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
9601
diff
changeset
|
341 gripe_nonconformant ("operator *", a_nr, a_nc, b_nr, b_nc); |
| 458 | 342 |
| 3504 | 343 DiagMatrix c (a_nr, b_nc); |
| 458 | 344 |
|
9698
7c6d5d8c8d37
fix diag*diag multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
9601
diff
changeset
|
345 octave_idx_type len = c.length (), lenm = len < a_nc ? len : a_nc; |
| 458 | 346 |
|
9698
7c6d5d8c8d37
fix diag*diag multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
9601
diff
changeset
|
347 for (octave_idx_type i = 0; i < lenm; i++) |
|
7c6d5d8c8d37
fix diag*diag multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
9601
diff
changeset
|
348 c.dgxelem (i) = a.dgelem (i) * b.dgelem (i); |
|
7c6d5d8c8d37
fix diag*diag multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
9601
diff
changeset
|
349 for (octave_idx_type i = lenm; i < len; i++) |
|
7c6d5d8c8d37
fix diag*diag multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
9601
diff
changeset
|
350 c.dgxelem (i) = 0.0; |
| 458 | 351 |
| 352 return c; | |
| 353 } | |
| 354 | |
| 355 // other operations | |
| 356 | |
|
8371
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
357 DET |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
358 DiagMatrix::determinant (void) const |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
359 { |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
360 DET det (1.0); |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
361 if (rows () != cols ()) |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
362 { |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
363 (*current_liboctave_error_handler) ("determinant requires square matrix"); |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
364 det = 0.0; |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
365 } |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
366 else |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
367 { |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
368 octave_idx_type len = length (); |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
369 for (octave_idx_type i = 0; i < len; i++) |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
370 det *= elem (i, i); |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
371 } |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
372 |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
373 return det; |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
374 } |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
375 |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
376 double |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
377 DiagMatrix::rcond (void) const |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
378 { |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9698
diff
changeset
|
379 ColumnVector av = diag (0).map<double> (fabs); |
|
8371
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
380 double amx = av.max (), amn = av.min (); |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
381 return amx == 0 ? 0.0 : amn / amx; |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
382 } |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
383 |
| 3504 | 384 std::ostream& |
| 385 operator << (std::ostream& os, const DiagMatrix& a) | |
| 458 | 386 { |
| 387 // int field_width = os.precision () + 7; | |
| 1360 | 388 |
| 5275 | 389 for (octave_idx_type i = 0; i < a.rows (); i++) |
| 458 | 390 { |
| 5275 | 391 for (octave_idx_type j = 0; j < a.cols (); j++) |
| 458 | 392 { |
| 393 if (i == j) | |
| 394 os << " " /* setw (field_width) */ << a.elem (i, i); | |
| 395 else | |
| 396 os << " " /* setw (field_width) */ << 0.0; | |
| 397 } | |
| 398 os << "\n"; | |
| 399 } | |
| 400 return os; | |
| 401 } |