Mercurial > octave
annotate src/xdiv.cc @ 7789:82be108cc558
First attempt at single precision tyeps
* * *
corrections to qrupdate single precision routines
* * *
prefer demotion to single over promotion to double
* * *
Add single precision support to log2 function
* * *
Trivial PROJECT file update
* * *
Cache optimized hermitian/transpose methods
* * *
Add tests for tranpose/hermitian and ChangeLog entry for new transpose code
| author | David Bateman <dbateman@free.fr> |
|---|---|
| date | Sun, 27 Apr 2008 22:34:17 +0200 |
| parents | a1dbe9d80eee |
| children | 8b1a2555c4e2 |
| rev | line source |
|---|---|
| 1 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2002, 2003, |
| 4 2005, 2006, 2007 John W. Eaton | |
| 1 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 1 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 1 | 21 |
| 22 */ | |
| 23 | |
| 240 | 24 #ifdef HAVE_CONFIG_H |
| 1192 | 25 #include <config.h> |
| 1 | 26 #endif |
| 27 | |
| 1343 | 28 #include <cassert> |
| 29 | |
| 4669 | 30 #include "Array-util.h" |
| 1352 | 31 #include "CMatrix.h" |
| 453 | 32 #include "dMatrix.h" |
| 4543 | 33 #include "CNDArray.h" |
| 34 #include "dNDArray.h" | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
35 #include "fCMatrix.h" |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
36 #include "fMatrix.h" |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
37 #include "fCNDArray.h" |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
38 #include "fNDArray.h" |
| 1651 | 39 #include "oct-cmplx.h" |
| 4153 | 40 #include "quit.h" |
| 1352 | 41 |
| 42 #include "error.h" | |
| 43 #include "xdiv.h" | |
| 1 | 44 |
| 3480 | 45 static inline bool |
| 5275 | 46 result_ok (octave_idx_type info) |
| 1 | 47 { |
| 48 assert (info != -1); | |
| 49 | |
| 3480 | 50 return (info != -2); |
| 51 } | |
| 932 | 52 |
| 3480 | 53 static void |
| 54 solve_singularity_warning (double rcond) | |
| 55 { | |
| 56 warning ("matrix singular to machine precision, rcond = %g", rcond); | |
| 3719 | 57 warning ("attempting to find minimum norm solution"); |
| 1 | 58 } |
| 59 | |
| 2364 | 60 template <class T1, class T2> |
| 61 bool | |
| 3195 | 62 mx_leftdiv_conform (const T1& a, const T2& b) |
| 1 | 63 { |
| 5275 | 64 octave_idx_type a_nr = a.rows (); |
| 65 octave_idx_type b_nr = b.rows (); | |
| 2364 | 66 |
| 1 | 67 if (a_nr != b_nr) |
| 68 { | |
| 5275 | 69 octave_idx_type a_nc = a.cols (); |
| 70 octave_idx_type b_nc = b.cols (); | |
| 2364 | 71 |
| 72 gripe_nonconformant ("operator \\", a_nr, a_nc, b_nr, b_nc); | |
| 73 return false; | |
| 1 | 74 } |
| 75 | |
| 2364 | 76 return true; |
| 1 | 77 } |
| 78 | |
| 3195 | 79 #define INSTANTIATE_MX_LEFTDIV_CONFORM(T1, T2) \ |
| 80 template bool mx_leftdiv_conform (const T1&, const T2&) | |
| 81 | |
| 82 INSTANTIATE_MX_LEFTDIV_CONFORM (Matrix, Matrix); | |
| 83 INSTANTIATE_MX_LEFTDIV_CONFORM (Matrix, ComplexMatrix); | |
| 84 INSTANTIATE_MX_LEFTDIV_CONFORM (ComplexMatrix, Matrix); | |
| 85 INSTANTIATE_MX_LEFTDIV_CONFORM (ComplexMatrix, ComplexMatrix); | |
| 2364 | 86 |
| 87 template <class T1, class T2> | |
| 88 bool | |
| 3195 | 89 mx_div_conform (const T1& a, const T2& b) |
| 1 | 90 { |
| 5275 | 91 octave_idx_type a_nc = a.cols (); |
| 92 octave_idx_type b_nc = b.cols (); | |
| 2364 | 93 |
| 1 | 94 if (a_nc != b_nc) |
| 95 { | |
| 5275 | 96 octave_idx_type a_nr = a.rows (); |
| 97 octave_idx_type b_nr = b.rows (); | |
| 2364 | 98 |
| 99 gripe_nonconformant ("operator /", a_nr, a_nc, b_nr, b_nc); | |
| 100 return false; | |
| 1 | 101 } |
| 102 | |
| 2364 | 103 return true; |
| 1 | 104 } |
| 105 | |
| 3195 | 106 #define INSTANTIATE_MX_DIV_CONFORM(T1, T2) \ |
| 107 template bool mx_div_conform (const T1&, const T2&) | |
| 108 | |
| 109 INSTANTIATE_MX_DIV_CONFORM (Matrix, Matrix); | |
| 110 INSTANTIATE_MX_DIV_CONFORM (Matrix, ComplexMatrix); | |
| 111 INSTANTIATE_MX_DIV_CONFORM (ComplexMatrix, Matrix); | |
| 112 INSTANTIATE_MX_DIV_CONFORM (ComplexMatrix, ComplexMatrix); | |
| 2364 | 113 |
| 767 | 114 // Right division functions. |
| 115 // | |
| 116 // op2 / op1: m cm | |
| 117 // +-- +---+----+ | |
| 118 // matrix | 1 | 3 | | |
| 119 // +---+----+ | |
| 120 // complex_matrix | 2 | 4 | | |
| 121 // +---+----+ | |
| 1 | 122 |
| 767 | 123 // -*- 1 -*- |
| 1800 | 124 Matrix |
| 5785 | 125 xdiv (const Matrix& a, const Matrix& b, MatrixType &typ) |
| 1 | 126 { |
| 2364 | 127 if (! mx_div_conform (a, b)) |
| 1800 | 128 return Matrix (); |
| 1 | 129 |
| 130 Matrix atmp = a.transpose (); | |
| 131 Matrix btmp = b.transpose (); | |
| 5785 | 132 MatrixType btyp = typ.transpose (); |
| 1 | 133 |
| 5275 | 134 octave_idx_type info; |
| 5785 | 135 double rcond = 0.0; |
| 3480 | 136 |
| 5785 | 137 Matrix result |
| 138 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); | |
| 1 | 139 |
| 5785 | 140 typ = btyp.transpose (); |
| 1800 | 141 return result.transpose (); |
| 1 | 142 } |
| 143 | |
| 767 | 144 // -*- 2 -*- |
| 1800 | 145 ComplexMatrix |
| 5785 | 146 xdiv (const Matrix& a, const ComplexMatrix& b, MatrixType &typ) |
| 1 | 147 { |
| 2364 | 148 if (! mx_div_conform (a, b)) |
| 1800 | 149 return ComplexMatrix (); |
| 1 | 150 |
| 151 Matrix atmp = a.transpose (); | |
| 152 ComplexMatrix btmp = b.hermitian (); | |
| 5785 | 153 MatrixType btyp = typ.transpose (); |
| 1 | 154 |
| 5275 | 155 octave_idx_type info; |
| 5785 | 156 double rcond = 0.0; |
| 3480 | 157 |
| 5785 | 158 ComplexMatrix result |
| 159 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); | |
| 1 | 160 |
| 5785 | 161 typ = btyp.transpose (); |
| 1800 | 162 return result.hermitian (); |
| 1 | 163 } |
| 164 | |
| 767 | 165 // -*- 3 -*- |
| 1800 | 166 ComplexMatrix |
| 5785 | 167 xdiv (const ComplexMatrix& a, const Matrix& b, MatrixType &typ) |
| 1 | 168 { |
| 2364 | 169 if (! mx_div_conform (a, b)) |
| 1800 | 170 return ComplexMatrix (); |
| 1 | 171 |
| 172 ComplexMatrix atmp = a.hermitian (); | |
| 173 Matrix btmp = b.transpose (); | |
| 5785 | 174 MatrixType btyp = typ.transpose (); |
| 1 | 175 |
| 5275 | 176 octave_idx_type info; |
| 5785 | 177 double rcond = 0.0; |
| 3480 | 178 |
| 5785 | 179 ComplexMatrix result |
| 180 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); | |
| 1 | 181 |
| 5785 | 182 typ = btyp.transpose (); |
| 1800 | 183 return result.hermitian (); |
| 1 | 184 } |
| 185 | |
| 767 | 186 // -*- 4 -*- |
| 1800 | 187 ComplexMatrix |
| 5785 | 188 xdiv (const ComplexMatrix& a, const ComplexMatrix& b, MatrixType &typ) |
| 1 | 189 { |
| 2364 | 190 if (! mx_div_conform (a, b)) |
| 1800 | 191 return ComplexMatrix (); |
| 1 | 192 |
| 193 ComplexMatrix atmp = a.hermitian (); | |
| 194 ComplexMatrix btmp = b.hermitian (); | |
| 5785 | 195 MatrixType btyp = typ.transpose (); |
| 1 | 196 |
| 5275 | 197 octave_idx_type info; |
| 5785 | 198 double rcond = 0.0; |
| 3480 | 199 |
| 5785 | 200 ComplexMatrix result |
| 201 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); | |
| 1 | 202 |
| 5785 | 203 typ = btyp.transpose (); |
| 1800 | 204 return result.hermitian (); |
| 1 | 205 } |
| 206 | |
| 767 | 207 // Funny element by element division operations. |
| 208 // | |
| 209 // op2 \ op1: s cs | |
| 210 // +-- +---+----+ | |
| 211 // matrix | 1 | 3 | | |
| 212 // +---+----+ | |
| 213 // complex_matrix | 2 | 4 | | |
| 214 // +---+----+ | |
| 1 | 215 |
| 1800 | 216 Matrix |
| 164 | 217 x_el_div (double a, const Matrix& b) |
| 1 | 218 { |
| 5275 | 219 octave_idx_type nr = b.rows (); |
| 220 octave_idx_type nc = b.columns (); | |
| 1 | 221 |
| 222 Matrix result (nr, nc); | |
| 223 | |
| 5275 | 224 for (octave_idx_type j = 0; j < nc; j++) |
| 225 for (octave_idx_type i = 0; i < nr; i++) | |
| 4153 | 226 { |
| 227 OCTAVE_QUIT; | |
| 228 result (i, j) = a / b (i, j); | |
| 229 } | |
| 1 | 230 |
| 1800 | 231 return result; |
| 1 | 232 } |
| 233 | |
| 1800 | 234 ComplexMatrix |
| 164 | 235 x_el_div (double a, const ComplexMatrix& b) |
| 1 | 236 { |
| 5275 | 237 octave_idx_type nr = b.rows (); |
| 238 octave_idx_type nc = b.columns (); | |
| 1 | 239 |
| 240 ComplexMatrix result (nr, nc); | |
| 241 | |
| 5275 | 242 for (octave_idx_type j = 0; j < nc; j++) |
| 243 for (octave_idx_type i = 0; i < nr; i++) | |
| 4153 | 244 { |
| 245 OCTAVE_QUIT; | |
| 246 result (i, j) = a / b (i, j); | |
| 247 } | |
| 1 | 248 |
| 1800 | 249 return result; |
| 1 | 250 } |
| 251 | |
| 1800 | 252 ComplexMatrix |
| 164 | 253 x_el_div (const Complex a, const Matrix& b) |
| 1 | 254 { |
| 5275 | 255 octave_idx_type nr = b.rows (); |
| 256 octave_idx_type nc = b.columns (); | |
| 1 | 257 |
| 258 ComplexMatrix result (nr, nc); | |
| 259 | |
| 5275 | 260 for (octave_idx_type j = 0; j < nc; j++) |
| 261 for (octave_idx_type i = 0; i < nr; i++) | |
| 4153 | 262 { |
| 263 OCTAVE_QUIT; | |
| 264 result (i, j) = a / b (i, j); | |
| 265 } | |
| 1 | 266 |
| 1800 | 267 return result; |
| 1 | 268 } |
| 269 | |
| 1800 | 270 ComplexMatrix |
| 164 | 271 x_el_div (const Complex a, const ComplexMatrix& b) |
| 1 | 272 { |
| 5275 | 273 octave_idx_type nr = b.rows (); |
| 274 octave_idx_type nc = b.columns (); | |
| 1 | 275 |
| 276 ComplexMatrix result (nr, nc); | |
| 277 | |
| 5275 | 278 for (octave_idx_type j = 0; j < nc; j++) |
| 279 for (octave_idx_type i = 0; i < nr; i++) | |
| 4153 | 280 { |
| 281 OCTAVE_QUIT; | |
| 282 result (i, j) = a / b (i, j); | |
| 283 } | |
| 1 | 284 |
| 1800 | 285 return result; |
| 1 | 286 } |
| 287 | |
| 4543 | 288 // Funny element by element division operations. |
| 289 // | |
| 290 // op2 \ op1: s cs | |
| 291 // +-- +---+----+ | |
| 292 // N-d array | 1 | 3 | | |
| 293 // +---+----+ | |
| 294 // complex N-d array | 2 | 4 | | |
| 295 // +---+----+ | |
| 296 | |
| 297 NDArray | |
| 298 x_el_div (double a, const NDArray& b) | |
| 299 { | |
| 300 NDArray result (b.dims ()); | |
| 301 | |
| 5275 | 302 for (octave_idx_type i = 0; i < b.length (); i++) |
| 4543 | 303 { |
| 304 OCTAVE_QUIT; | |
| 305 result (i) = a / b (i); | |
| 306 } | |
| 307 | |
| 308 return result; | |
| 309 } | |
| 310 | |
| 311 ComplexNDArray | |
| 312 x_el_div (double a, const ComplexNDArray& b) | |
| 313 { | |
| 314 ComplexNDArray result (b.dims ()); | |
| 315 | |
| 5275 | 316 for (octave_idx_type i = 0; i < b.length (); i++) |
| 4543 | 317 { |
| 318 OCTAVE_QUIT; | |
| 319 result (i) = a / b (i); | |
| 320 } | |
| 321 | |
| 322 return result; | |
| 323 } | |
| 324 | |
| 325 ComplexNDArray | |
| 326 x_el_div (const Complex a, const NDArray& b) | |
| 327 { | |
| 328 ComplexNDArray result (b.dims ()); | |
| 329 | |
| 5275 | 330 for (octave_idx_type i = 0; i < b.length (); i++) |
| 4543 | 331 { |
| 332 OCTAVE_QUIT; | |
| 333 result (i) = a / b (i); | |
| 334 } | |
| 335 | |
| 336 return result; | |
| 337 } | |
| 338 | |
| 339 ComplexNDArray | |
| 340 x_el_div (const Complex a, const ComplexNDArray& b) | |
| 341 { | |
| 342 ComplexNDArray result (b.dims ()); | |
| 343 | |
| 5275 | 344 for (octave_idx_type i = 0; i < b.length (); i++) |
| 4543 | 345 { |
| 346 OCTAVE_QUIT; | |
| 347 result (i) = a / b (i); | |
| 348 } | |
| 349 | |
| 350 return result; | |
| 351 } | |
| 352 | |
| 767 | 353 // Left division functions. |
| 354 // | |
| 355 // op2 \ op1: m cm | |
| 356 // +-- +---+----+ | |
| 357 // matrix | 1 | 3 | | |
| 358 // +---+----+ | |
| 359 // complex_matrix | 2 | 4 | | |
| 360 // +---+----+ | |
| 1 | 361 |
| 767 | 362 // -*- 1 -*- |
| 1800 | 363 Matrix |
| 5785 | 364 xleftdiv (const Matrix& a, const Matrix& b, MatrixType &typ) |
| 1 | 365 { |
| 2364 | 366 if (! mx_leftdiv_conform (a, b)) |
| 1800 | 367 return Matrix (); |
| 1 | 368 |
| 5275 | 369 octave_idx_type info; |
| 5785 | 370 double rcond = 0.0; |
| 371 return a.solve (typ, b, info, rcond, solve_singularity_warning); | |
| 1 | 372 } |
| 373 | |
| 767 | 374 // -*- 2 -*- |
| 1800 | 375 ComplexMatrix |
| 5785 | 376 xleftdiv (const Matrix& a, const ComplexMatrix& b, MatrixType &typ) |
| 1 | 377 { |
| 2364 | 378 if (! mx_leftdiv_conform (a, b)) |
| 1800 | 379 return ComplexMatrix (); |
| 1 | 380 |
| 5275 | 381 octave_idx_type info; |
| 5785 | 382 double rcond = 0.0; |
| 3480 | 383 |
| 5785 | 384 return a.solve (typ, b, info, rcond, solve_singularity_warning); |
| 1 | 385 } |
| 386 | |
| 767 | 387 // -*- 3 -*- |
| 1800 | 388 ComplexMatrix |
| 5785 | 389 xleftdiv (const ComplexMatrix& a, const Matrix& b, MatrixType &typ) |
| 1 | 390 { |
| 2364 | 391 if (! mx_leftdiv_conform (a, b)) |
| 1800 | 392 return ComplexMatrix (); |
| 1 | 393 |
| 5275 | 394 octave_idx_type info; |
| 5785 | 395 double rcond = 0.0; |
| 396 return a.solve (typ, b, info, rcond, solve_singularity_warning); | |
| 1 | 397 } |
| 398 | |
| 767 | 399 // -*- 4 -*- |
| 1800 | 400 ComplexMatrix |
| 5785 | 401 xleftdiv (const ComplexMatrix& a, const ComplexMatrix& b, MatrixType &typ) |
| 1 | 402 { |
| 2364 | 403 if (! mx_leftdiv_conform (a, b)) |
| 1800 | 404 return ComplexMatrix (); |
| 1 | 405 |
| 5275 | 406 octave_idx_type info; |
| 5785 | 407 double rcond = 0.0; |
| 408 return a.solve (typ, b, info, rcond, solve_singularity_warning); | |
| 1 | 409 } |
| 410 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
411 static void |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
412 solve_singularity_warning (float rcond) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
413 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
414 warning ("matrix singular to machine precision, rcond = %g", rcond); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
415 warning ("attempting to find minimum norm solution"); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
416 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
417 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
418 INSTANTIATE_MX_LEFTDIV_CONFORM (FloatMatrix, FloatMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
419 INSTANTIATE_MX_LEFTDIV_CONFORM (FloatMatrix, FloatComplexMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
420 INSTANTIATE_MX_LEFTDIV_CONFORM (FloatComplexMatrix, FloatMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
421 INSTANTIATE_MX_LEFTDIV_CONFORM (FloatComplexMatrix, FloatComplexMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
422 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
423 INSTANTIATE_MX_DIV_CONFORM (FloatMatrix, FloatMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
424 INSTANTIATE_MX_DIV_CONFORM (FloatMatrix, FloatComplexMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
425 INSTANTIATE_MX_DIV_CONFORM (FloatComplexMatrix, FloatMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
426 INSTANTIATE_MX_DIV_CONFORM (FloatComplexMatrix, FloatComplexMatrix); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
427 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
428 // Right division functions. |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
429 // |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
430 // op2 / op1: m cm |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
431 // +-- +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
432 // matrix | 1 | 3 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
433 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
434 // complex_matrix | 2 | 4 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
435 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
436 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
437 // -*- 1 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
438 FloatMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
439 xdiv (const FloatMatrix& a, const FloatMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
440 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
441 if (! mx_div_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
442 return FloatMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
443 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
444 FloatMatrix atmp = a.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
445 FloatMatrix btmp = b.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
446 MatrixType btyp = typ.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
447 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
448 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
449 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
450 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
451 FloatMatrix result |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
452 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
453 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
454 typ = btyp.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
455 return result.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
456 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
457 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
458 // -*- 2 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
459 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
460 xdiv (const FloatMatrix& a, const FloatComplexMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
461 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
462 if (! mx_div_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
463 return FloatComplexMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
464 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
465 FloatMatrix atmp = a.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
466 FloatComplexMatrix btmp = b.hermitian (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
467 MatrixType btyp = typ.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
468 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
469 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
470 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
471 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
472 FloatComplexMatrix result |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
473 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
474 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
475 typ = btyp.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
476 return result.hermitian (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
477 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
478 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
479 // -*- 3 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
480 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
481 xdiv (const FloatComplexMatrix& a, const FloatMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
482 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
483 if (! mx_div_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
484 return FloatComplexMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
485 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
486 FloatComplexMatrix atmp = a.hermitian (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
487 FloatMatrix btmp = b.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
488 MatrixType btyp = typ.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
489 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
490 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
491 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
492 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
493 FloatComplexMatrix result |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
494 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
495 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
496 typ = btyp.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
497 return result.hermitian (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
498 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
499 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
500 // -*- 4 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
501 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
502 xdiv (const FloatComplexMatrix& a, const FloatComplexMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
503 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
504 if (! mx_div_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
505 return FloatComplexMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
506 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
507 FloatComplexMatrix atmp = a.hermitian (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
508 FloatComplexMatrix btmp = b.hermitian (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
509 MatrixType btyp = typ.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
510 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
511 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
512 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
513 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
514 FloatComplexMatrix result |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
515 = btmp.solve (btyp, atmp, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
516 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
517 typ = btyp.transpose (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
518 return result.hermitian (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
519 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
520 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
521 // Funny element by element division operations. |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
522 // |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
523 // op2 \ op1: s cs |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
524 // +-- +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
525 // matrix | 1 | 3 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
526 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
527 // complex_matrix | 2 | 4 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
528 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
529 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
530 FloatMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
531 x_el_div (float a, const FloatMatrix& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
532 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
533 octave_idx_type nr = b.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
534 octave_idx_type nc = b.columns (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
535 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
536 FloatMatrix result (nr, nc); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
537 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
538 for (octave_idx_type j = 0; j < nc; j++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
539 for (octave_idx_type i = 0; i < nr; i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
540 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
541 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
542 result (i, j) = a / b (i, j); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
543 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
544 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
545 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
546 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
547 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
548 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
549 x_el_div (float a, const FloatComplexMatrix& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
550 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
551 octave_idx_type nr = b.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
552 octave_idx_type nc = b.columns (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
553 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
554 FloatComplexMatrix result (nr, nc); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
555 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
556 for (octave_idx_type j = 0; j < nc; j++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
557 for (octave_idx_type i = 0; i < nr; i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
558 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
559 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
560 result (i, j) = a / b (i, j); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
561 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
562 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
563 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
564 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
565 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
566 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
567 x_el_div (const FloatComplex a, const FloatMatrix& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
568 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
569 octave_idx_type nr = b.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
570 octave_idx_type nc = b.columns (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
571 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
572 FloatComplexMatrix result (nr, nc); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
573 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
574 for (octave_idx_type j = 0; j < nc; j++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
575 for (octave_idx_type i = 0; i < nr; i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
576 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
577 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
578 result (i, j) = a / b (i, j); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
579 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
580 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
581 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
582 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
583 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
584 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
585 x_el_div (const FloatComplex a, const FloatComplexMatrix& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
586 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
587 octave_idx_type nr = b.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
588 octave_idx_type nc = b.columns (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
589 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
590 FloatComplexMatrix result (nr, nc); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
591 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
592 for (octave_idx_type j = 0; j < nc; j++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
593 for (octave_idx_type i = 0; i < nr; i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
594 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
595 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
596 result (i, j) = a / b (i, j); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
597 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
598 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
599 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
600 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
601 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
602 // Funny element by element division operations. |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
603 // |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
604 // op2 \ op1: s cs |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
605 // +-- +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
606 // N-d array | 1 | 3 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
607 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
608 // complex N-d array | 2 | 4 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
609 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
610 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
611 FloatNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
612 x_el_div (float a, const FloatNDArray& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
613 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
614 FloatNDArray result (b.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
615 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
616 for (octave_idx_type i = 0; i < b.length (); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
617 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
618 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
619 result (i) = a / b (i); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
620 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
621 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
622 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
623 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
624 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
625 FloatComplexNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
626 x_el_div (float a, const FloatComplexNDArray& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
627 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
628 FloatComplexNDArray result (b.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
629 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
630 for (octave_idx_type i = 0; i < b.length (); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
631 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
632 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
633 result (i) = a / b (i); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
634 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
635 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
636 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
637 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
638 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
639 FloatComplexNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
640 x_el_div (const FloatComplex a, const FloatNDArray& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
641 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
642 FloatComplexNDArray result (b.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
643 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
644 for (octave_idx_type i = 0; i < b.length (); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
645 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
646 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
647 result (i) = a / b (i); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
648 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
649 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
650 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
651 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
652 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
653 FloatComplexNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
654 x_el_div (const FloatComplex a, const FloatComplexNDArray& b) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
655 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
656 FloatComplexNDArray result (b.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
657 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
658 for (octave_idx_type i = 0; i < b.length (); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
659 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
660 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
661 result (i) = a / b (i); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
662 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
663 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
664 return result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
665 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
666 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
667 // Left division functions. |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
668 // |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
669 // op2 \ op1: m cm |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
670 // +-- +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
671 // matrix | 1 | 3 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
672 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
673 // complex_matrix | 2 | 4 | |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
674 // +---+----+ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
675 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
676 // -*- 1 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
677 FloatMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
678 xleftdiv (const FloatMatrix& a, const FloatMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
679 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
680 if (! mx_leftdiv_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
681 return FloatMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
682 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
683 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
684 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
685 return a.solve (typ, b, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
686 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
687 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
688 // -*- 2 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
689 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
690 xleftdiv (const FloatMatrix& a, const FloatComplexMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
691 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
692 if (! mx_leftdiv_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
693 return FloatComplexMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
694 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
695 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
696 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
697 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
698 return a.solve (typ, b, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
699 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
700 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
701 // -*- 3 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
702 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
703 xleftdiv (const FloatComplexMatrix& a, const FloatMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
704 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
705 if (! mx_leftdiv_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
706 return FloatComplexMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
707 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
708 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
709 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
710 return a.solve (typ, b, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
711 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
712 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
713 // -*- 4 -*- |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
714 FloatComplexMatrix |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
715 xleftdiv (const FloatComplexMatrix& a, const FloatComplexMatrix& b, MatrixType &typ) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
716 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
717 if (! mx_leftdiv_conform (a, b)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
718 return FloatComplexMatrix (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
719 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
720 octave_idx_type info; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
721 float rcond = 0.0; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
722 return a.solve (typ, b, info, rcond, solve_singularity_warning); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
723 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
724 |
| 1 | 725 /* |
| 726 ;;; Local Variables: *** | |
| 727 ;;; mode: C++ *** | |
| 728 ;;; End: *** | |
| 729 */ |