GNU Octave  4.2.1
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
ls-mat4.cc
Go to the documentation of this file.
1 /*
2 
3 Copyright (C) 1996-2017 John W. Eaton
4 
5 This file is part of Octave.
6 
7 Octave is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3 of the License, or (at your
10 option) any later version.
11 
12 Octave is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16 
17 You should have received a copy of the GNU General Public License
18 along with Octave; see the file COPYING. If not, see
19 <http://www.gnu.org/licenses/>.
20 
21 */
22 
23 #if defined (HAVE_CONFIG_H)
24 # include "config.h"
25 #endif
26 
27 #include <cfloat>
28 #include <cstring>
29 #include <cctype>
30 
31 #include <fstream>
32 #include <iomanip>
33 #include <iostream>
34 #include <string>
35 #include <vector>
36 
37 #include "byte-swap.h"
38 #include "data-conv.h"
39 #include "file-ops.h"
40 #include "glob-match.h"
41 #include "lo-mappers.h"
42 #include "mach-info.h"
43 #include "oct-env.h"
44 #include "oct-time.h"
45 #include "quit.h"
46 #include "str-vec.h"
47 #include "oct-locbuf.h"
48 
49 #include "Cell.h"
50 #include "defun.h"
51 #include "error.h"
52 #include "errwarn.h"
53 #include "load-save.h"
54 #include "ovl.h"
55 #include "oct-map.h"
56 #include "ov-cell.h"
57 #include "pager.h"
58 #include "pt-exp.h"
59 #include "sysdep.h"
60 #include "unwind-prot.h"
61 #include "utils.h"
62 #include "variables.h"
63 #include "version.h"
64 #include "dMatrix.h"
65 #include "dSparse.h"
66 
67 #include "ls-mat4.h"
68 
69 // Read LEN elements of data from IS in the format specified by
70 // PRECISION, placing the result in DATA. If SWAP is TRUE, swap
71 // the bytes of each element before copying to DATA. FLT_FMT
72 // specifies the format of the data if we are reading floating point
73 // numbers.
74 
75 static void
76 read_mat_binary_data (std::istream& is, double *data, int precision,
77  int len, bool swap,
79 {
80  switch (precision)
81  {
82  case 0:
83  read_doubles (is, data, LS_DOUBLE, len, swap, flt_fmt);
84  break;
85 
86  case 1:
87  read_doubles (is, data, LS_FLOAT, len, swap, flt_fmt);
88  break;
89 
90  case 2:
91  read_doubles (is, data, LS_INT, len, swap, flt_fmt);
92  break;
93 
94  case 3:
95  read_doubles (is, data, LS_SHORT, len, swap, flt_fmt);
96  break;
97 
98  case 4:
99  read_doubles (is, data, LS_U_SHORT, len, swap, flt_fmt);
100  break;
101 
102  case 5:
103  read_doubles (is, data, LS_U_CHAR, len, swap, flt_fmt);
104  break;
105 
106  default:
107  break;
108  }
109 }
110 
111 int
112 read_mat_file_header (std::istream& is, bool& swap, int32_t& mopt,
113  int32_t& nr, int32_t& nc,
114  int32_t& imag, int32_t& len,
115  int quiet)
116 {
117  swap = false;
118 
119  // We expect to fail here, at the beginning of a record, so not
120  // being able to read another mopt value should not result in an
121  // error.
122 
123  is.read (reinterpret_cast<char *> (&mopt), 4);
124  if (! is)
125  return 1;
126 
127  if (! is.read (reinterpret_cast<char *> (&nr), 4))
128  return -1;
129 
130  if (! is.read (reinterpret_cast<char *> (&nc), 4))
131  return -1;
132 
133  if (! is.read (reinterpret_cast<char *> (&imag), 4))
134  return -1;
135 
136  if (! is.read (reinterpret_cast<char *> (&len), 4))
137  return -1;
138 
139 // If mopt is nonzero and the byte order is swapped, mopt will be
140 // bigger than we expect, so we swap bytes.
141 //
142 // If mopt is zero, it means the file was written on a little endian
143 // machine, and we only need to swap if we are running on a big endian
144 // machine.
145 //
146 // Gag me.
147 
148  if (octave::mach_info::words_big_endian () && mopt == 0)
149  swap = true;
150 
151  // mopt is signed, therefore byte swap may result in negative value.
152 
153  if (mopt > 9999 || mopt < 0)
154  swap = true;
155 
156  if (swap)
157  {
158  swap_bytes<4> (&mopt);
159  swap_bytes<4> (&nr);
160  swap_bytes<4> (&nc);
161  swap_bytes<4> (&imag);
162  swap_bytes<4> (&len);
163  }
164 
165  if (mopt > 9999 || mopt < 0 || imag > 1 || imag < 0)
166  {
167  if (! quiet)
168  error ("load: can't read binary file");
169 
170  return -1;
171  }
172 
173  return 0;
174 }
175 
176 // We don't just use a cast here, because we need to be able to detect
177 // possible errors.
178 
181 {
183 
184  switch (mach)
185  {
186  case 0:
188  break;
189 
190  case 1:
192  break;
193 
194  case 2:
195  case 3:
196  case 4:
197  default:
199  break;
200  }
201 
202  return flt_fmt;
203 }
204 
205 int
207 {
208  int retval = -1;
209 
210  switch (flt_fmt)
211  {
213  retval = 0;
214  break;
215 
217  retval = 1;
218  break;
219 
220  default:
221  break;
222  }
223 
224  return retval;
225 }
226 
227 // Extract one value (scalar, matrix, string, etc.) from stream IS and
228 // place it in TC, returning the name of the variable.
229 //
230 // The data is expected to be in Matlab version 4 .mat format, though
231 // not all the features of that format are supported.
232 //
233 // FILENAME is used for error messages.
234 //
235 // This format provides no way to tag the data as global.
236 
239  octave_value& tc)
240 {
242 
243  bool swap = false;
244  int32_t mopt, nr, nc, imag, len;
245 
246  int err = read_mat_file_header (is, swap, mopt, nr, nc, imag, len);
247  if (err)
248  {
249  if (err < 0)
250  error ("load: trouble reading binary file '%s'", filename.c_str ());
251 
252  return retval;
253  }
254 
255  int type = 0;
256  int prec = 0;
257  int order = 0;
258  int mach = 0;
259 
260  type = mopt % 10; // Full, sparse, etc.
261  mopt /= 10; // Eliminate first digit.
262  prec = mopt % 10; // double, float, int, etc.
263  mopt /= 10; // Eliminate second digit.
264  order = mopt % 10; // Row or column major ordering.
265  mopt /= 10; // Eliminate third digit.
266  mach = mopt % 10; // IEEE, VAX, etc.
267 
269  flt_fmt = mopt_digit_to_float_format (mach);
270 
271  if (flt_fmt == octave::mach_info::flt_fmt_unknown)
272  error ("load: unrecognized binary format!");
273 
274  if (imag && type == 1)
275  error ("load: encountered complex matrix with string flag set!");
276 
277  int dlen = 0;
278 
279  // LEN includes the terminating character, and the file is also
280  // supposed to include it, but apparently not all files do. Either
281  // way, I think this should work.
282 
283  {
284  OCTAVE_LOCAL_BUFFER (char, name, len+1);
285  name[len] = '\0';
286  if (! is.read (name, len))
287  error ("load: trouble reading binary file '%s'", filename.c_str ());
288  retval = name;
289 
290  dlen = nr * nc;
291  if (dlen < 0)
292  error ("load: trouble reading binary file '%s'", filename.c_str ());
293 
294  if (order)
295  {
296  octave_idx_type tmp = nr;
297  nr = nc;
298  nc = tmp;
299  }
300 
301  if (type == 2)
302  {
303  if (nc == 4)
304  {
305  octave_idx_type nr_new, nc_new;
306  Array<Complex> data (dim_vector (1, nr - 1));
307  Array<octave_idx_type> c (dim_vector (1, nr - 1));
308  Array<octave_idx_type> r (dim_vector (1, nr - 1));
309  OCTAVE_LOCAL_BUFFER (double, dtmp, nr);
310  OCTAVE_LOCAL_BUFFER (double, ctmp, nr);
311 
312  read_mat_binary_data (is, dtmp, prec, nr, swap, flt_fmt);
313  for (octave_idx_type i = 0; i < nr - 1; i++)
314  r.xelem (i) = dtmp[i] - 1;
315  nr_new = dtmp[nr - 1];
316  read_mat_binary_data (is, dtmp, prec, nr, swap, flt_fmt);
317  for (octave_idx_type i = 0; i < nr - 1; i++)
318  c.xelem (i) = dtmp[i] - 1;
319  nc_new = dtmp[nr - 1];
320  read_mat_binary_data (is, dtmp, prec, nr - 1, swap, flt_fmt);
321  read_mat_binary_data (is, ctmp, prec, 1, swap, flt_fmt);
322  read_mat_binary_data (is, ctmp, prec, nr - 1, swap, flt_fmt);
323 
324  for (octave_idx_type i = 0; i < nr - 1; i++)
325  data.xelem (i) = Complex (dtmp[i], ctmp[i]);
326  read_mat_binary_data (is, ctmp, prec, 1, swap, flt_fmt);
327 
328  SparseComplexMatrix smc = SparseComplexMatrix (data, r, c,
329  nr_new, nc_new);
330 
331  tc = order ? smc.transpose () : smc;
332  }
333  else
334  {
335  octave_idx_type nr_new, nc_new;
336  Array<double> data (dim_vector (1, nr - 1));
337  Array<octave_idx_type> c (dim_vector (1, nr - 1));
338  Array<octave_idx_type> r (dim_vector (1, nr - 1));
339  OCTAVE_LOCAL_BUFFER (double, dtmp, nr);
340 
341  read_mat_binary_data (is, dtmp, prec, nr, swap, flt_fmt);
342  for (octave_idx_type i = 0; i < nr - 1; i++)
343  r.xelem (i) = dtmp[i] - 1;
344  nr_new = dtmp[nr - 1];
345  read_mat_binary_data (is, dtmp, prec, nr, swap, flt_fmt);
346  for (octave_idx_type i = 0; i < nr - 1; i++)
347  c.xelem (i) = dtmp[i] - 1;
348  nc_new = dtmp[nr - 1];
349  read_mat_binary_data (is, data.fortran_vec (), prec, nr - 1,
350  swap, flt_fmt);
351  read_mat_binary_data (is, dtmp, prec, 1, swap, flt_fmt);
352 
353  SparseMatrix sm = SparseMatrix (data, r, c, nr_new, nc_new);
354 
355  tc = order ? sm.transpose () : sm;
356  }
357  }
358  else
359  {
360  Matrix re (nr, nc);
361 
362  read_mat_binary_data (is, re.fortran_vec (), prec, dlen, swap, flt_fmt);
363 
364  if (! is)
365  error ("load: reading matrix data for '%s'", name);
366 
367  if (imag)
368  {
369  Matrix im (nr, nc);
370 
371  read_mat_binary_data (is, im.fortran_vec (), prec, dlen, swap,
372  flt_fmt);
373 
374  if (! is)
375  error ("load: reading imaginary matrix data for '%s'", name);
376 
377  ComplexMatrix ctmp (nr, nc);
378 
379  for (octave_idx_type j = 0; j < nc; j++)
380  for (octave_idx_type i = 0; i < nr; i++)
381  ctmp (i,j) = Complex (re(i,j), im(i,j));
382 
383  tc = order ? ctmp.transpose () : ctmp;
384  }
385  else
386  tc = order ? re.transpose () : re;
387 
388  if (type == 1)
389  tc = tc.convert_to_str (false, true, '\'');
390  }
391 
392  return retval;
393  }
394 }
395 
396 // Save the data from TC along with the corresponding NAME on stream OS
397 // in the MatLab version 4 binary format.
398 
399 bool
400 save_mat_binary_data (std::ostream& os, const octave_value& tc,
401  const std::string& name)
402 {
403  int32_t mopt = 0;
404 
405  mopt += tc.is_sparse_type () ? 2 : tc.is_string () ? 1 : 0;
406 
409 
410  mopt += 1000 * float_format_to_mopt_digit (flt_fmt);
411 
412  os.write (reinterpret_cast<char *> (&mopt), 4);
413 
414  octave_idx_type len;
415  int32_t nr = tc.rows ();
416 
417  int32_t nc = tc.columns ();
418 
419  if (tc.is_sparse_type ())
420  {
421  len = tc.nnz ();
422  uint32_t nnz = len + 1;
423  os.write (reinterpret_cast<char *> (&nnz), 4);
424 
425  uint32_t iscmplx = tc.is_complex_type () ? 4 : 3;
426  os.write (reinterpret_cast<char *> (&iscmplx), 4);
427 
428  uint32_t tmp = 0;
429  os.write (reinterpret_cast<char *> (&tmp), 4);
430  }
431  else
432  {
433  os.write (reinterpret_cast<char *> (&nr), 4);
434  os.write (reinterpret_cast<char *> (&nc), 4);
435 
436  int32_t imag = tc.is_complex_type () ? 1 : 0;
437  os.write (reinterpret_cast<char *> (&imag), 4);
438 
439  len = nr * nc;
440  }
441 
442  // LEN includes the terminating character, and the file is also
443  // supposed to include it.
444 
445  int32_t name_len = name.length () + 1;
446 
447  os.write (reinterpret_cast<char *> (&name_len), 4);
448  os << name << '\0';
449 
450  if (tc.is_string ())
451  {
453 
454  charMatrix chm = tc.char_matrix_value ();
455 
456  octave_idx_type nrow = chm.rows ();
457  octave_idx_type ncol = chm.cols ();
458 
459  OCTAVE_LOCAL_BUFFER (double, buf, ncol*nrow);
460 
461  for (octave_idx_type i = 0; i < nrow; i++)
462  {
463  std::string tstr = chm.row_as_string (i);
464  const char *s = tstr.data ();
465 
466  for (octave_idx_type j = 0; j < ncol; j++)
467  buf[j*nrow+i] = static_cast<double> (*s++ & 0x00FF);
468  }
469  std::streamsize n_bytes = static_cast<std::streamsize> (nrow) *
470  static_cast<std::streamsize> (ncol) *
471  sizeof (double);
472  os.write (reinterpret_cast<char *> (buf), n_bytes);
473  }
474  else if (tc.is_range ())
475  {
476  Range r = tc.range_value ();
477  double base = r.base ();
478  double inc = r.inc ();
479  octave_idx_type nel = r.numel ();
480  for (octave_idx_type i = 0; i < nel; i++)
481  {
482  double x = base + i * inc;
483  os.write (reinterpret_cast<char *> (&x), 8);
484  }
485  }
486  else if (tc.is_real_scalar ())
487  {
488  double tmp = tc.double_value ();
489  os.write (reinterpret_cast<char *> (&tmp), 8);
490  }
491  else if (tc.is_sparse_type ())
492  {
493  double ds;
494  OCTAVE_LOCAL_BUFFER (double, dtmp, len);
495  if (tc.is_complex_matrix ())
496  {
498 
499  for (octave_idx_type i = 0; i < len; i++)
500  dtmp[i] = m.ridx (i) + 1;
501  std::streamsize n_bytes = 8 * static_cast<std::streamsize> (len);
502  os.write (reinterpret_cast<const char *> (dtmp), n_bytes);
503  ds = nr;
504  os.write (reinterpret_cast<const char *> (&ds), 8);
505 
506  octave_idx_type ii = 0;
507  for (octave_idx_type j = 0; j < nc; j++)
508  for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++)
509  dtmp[ii++] = j + 1;
510  os.write (reinterpret_cast<const char *> (dtmp), n_bytes);
511  ds = nc;
512  os.write (reinterpret_cast<const char *> (&ds), 8);
513 
514  for (octave_idx_type i = 0; i < len; i++)
515  dtmp[i] = octave::math::real (m.data (i));
516  os.write (reinterpret_cast<const char *> (dtmp), n_bytes);
517  ds = 0.;
518  os.write (reinterpret_cast<const char *> (&ds), 8);
519 
520  for (octave_idx_type i = 0; i < len; i++)
521  dtmp[i] = octave::math::imag (m.data (i));
522  os.write (reinterpret_cast<const char *> (dtmp), n_bytes);
523  os.write (reinterpret_cast<const char *> (&ds), 8);
524  }
525  else
526  {
528 
529  for (octave_idx_type i = 0; i < len; i++)
530  dtmp[i] = m.ridx (i) + 1;
531  std::streamsize n_bytes = 8 * static_cast<std::streamsize> (len);
532  os.write (reinterpret_cast<const char *> (dtmp), n_bytes);
533  ds = nr;
534  os.write (reinterpret_cast<const char *> (&ds), 8);
535 
536  octave_idx_type ii = 0;
537  for (octave_idx_type j = 0; j < nc; j++)
538  for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++)
539  dtmp[ii++] = j + 1;
540  os.write (reinterpret_cast<const char *> (dtmp), n_bytes);
541  ds = nc;
542  os.write (reinterpret_cast<const char *> (&ds), 8);
543 
544  os.write (reinterpret_cast<const char *> (m.data ()), n_bytes);
545  ds = 0.;
546  os.write (reinterpret_cast<const char *> (&ds), 8);
547  }
548  }
549  else if (tc.is_real_matrix ())
550  {
551  Matrix m = tc.matrix_value ();
552  std::streamsize n_bytes = 8 * static_cast<std::streamsize> (len);
553  os.write (reinterpret_cast<const char *> (m.data ()), n_bytes);
554  }
555  else if (tc.is_complex_scalar ())
556  {
557  Complex tmp = tc.complex_value ();
558  os.write (reinterpret_cast<char *> (&tmp), 16);
559  }
560  else if (tc.is_complex_matrix ())
561  {
562  ComplexMatrix m_cmplx = tc.complex_matrix_value ();
563  Matrix m = ::real (m_cmplx);
564  std::streamsize n_bytes = 8 * static_cast<std::streamsize> (len);
565  os.write (reinterpret_cast<const char *> (m.data ()), n_bytes);
566  m = ::imag (m_cmplx);
567  os.write (reinterpret_cast<const char *> (m.data ()), n_bytes);
568  }
569  else
570  // FIXME: Should this just error out rather than warn?
571  warn_wrong_type_arg ("save", tc);
572 
573  return ! os.fail ();
574 }
octave_idx_type nnz(void) const
Definition: ov.h:509
bool is_range(void) const
Definition: ov.h:587
T * data(void)
Definition: Sparse.h:521
octave_idx_type rows(void) const
Definition: ov.h:489
SparseMatrix transpose(void) const
Definition: dSparse.h:141
bool is_complex_scalar(void) const
Definition: ov.h:557
Definition: Range.h:33
void error(const char *fmt,...)
Definition: error.cc:570
std::string filename
Definition: urlwrite.cc:340
octave::mach_info::float_format flt_fmt
Definition: load-save.cc:723
octave_idx_type * cidx(void)
Definition: Sparse.h:543
s
Definition: file-io.cc:2682
std::string row_as_string(octave_idx_type, bool strip_ws=false) const
Definition: chMatrix.cc:81
double real(double x)
Definition: lo-mappers.h:113
octave_idx_type rows(void) const
Definition: Array.h:401
SparseComplexMatrix transpose(void) const
Definition: CSparse.h:141
bool swap
Definition: load-save.cc:725
int read_mat_file_header(std::istream &is, bool &swap, int32_t &mopt, int32_t &nr, int32_t &nc, int32_t &imag, int32_t &len, int quiet)
Definition: ls-mat4.cc:112
octave_idx_type columns(void) const
Definition: ov.h:491
OCTAVE_EXPORT octave_value_list any number nd example oindent prints the prompt xample Pick a any number!nd example oindent and waits for the user to enter a value The string entered by the user is evaluated as an so it may be a literal a variable name
Definition: input.cc:871
void swap_bytes< 4 >(void *ptr)
Definition: byte-swap.h:60
static bool words_big_endian(void)
Definition: mach-info.cc:169
octave_value convert_to_str(bool pad=false, bool force=false, char type= '\'') const
Definition: ov.h:1202
bool is_complex_matrix(void) const
Definition: ov.h:560
bool is_sparse_type(void) const
Definition: ov.h:682
int float_format_to_mopt_digit(octave::mach_info::float_format flt_fmt)
Definition: ls-mat4.cc:206
bool is_real_scalar(void) const
Definition: ov.h:551
void read_doubles(std::istream &is, double *data, save_type type, octave_idx_type len, bool swap, octave::mach_info::float_format fmt)
Definition: data-conv.cc:771
nd deftypefn *octave_map m
Definition: ov-struct.cc:2058
Range range_value(void) const
Definition: ov.h:923
bool is_string(void) const
Definition: ov.h:578
double inc(void) const
Definition: Range.h:80
octave_idx_type numel(void) const
Definition: Range.h:85
const T * data(void) const
Definition: Array.h:582
bool is_complex_type(void) const
Definition: ov.h:670
double tmp
Definition: data.cc:6300
octave_value retval
Definition: data.cc:6294
Matrix transpose(void) const
Definition: dMatrix.h:129
double imag(double)
Definition: lo-mappers.h:103
idx type
Definition: ov.cc:3129
Definition: dMatrix.h:37
ComplexMatrix transpose(void) const
Definition: CMatrix.h:165
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
Definition: lu.cc:138
SparseComplexMatrix sparse_complex_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:838
Matrix matrix_value(bool frc_str_conv=false) const
Definition: ov.h:787
charMatrix char_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:828
T & xelem(octave_idx_type n)
Definition: Array.h:455
octave::mach_info::float_format mopt_digit_to_float_format(int mach)
Definition: ls-mat4.cc:180
static float_format native_float_format(void)
Definition: mach-info.cc:162
octave::unwind_protect frame
Definition: graphics.cc:11584
octave_idx_type * ridx(void)
Definition: Sparse.h:530
=val(i)}if ode{val(i)}occurs in table i
Definition: lookup.cc:239
ComplexMatrix complex_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:805
bool save_mat_binary_data(std::ostream &os, const octave_value &tc, const std::string &name)
Definition: ls-mat4.cc:400
Complex complex_value(bool frc_str_conv=false) const
Definition: ov.h:799
issues an error eealso double
Definition: ov-bool-mat.cc:594
void warn_wrong_type_arg(const char *name, const octave_value &tc)
Definition: errwarn.cc:360
static void read_mat_binary_data(std::istream &is, double *data, int precision, int len, bool swap, octave::mach_info::float_format flt_fmt)
Definition: ls-mat4.cc:76
#define OCTAVE_LOCAL_BUFFER(T, buf, size)
Definition: oct-locbuf.h:200
double base(void) const
Definition: Range.h:78
ColumnVector imag(const ComplexColumnVector &a)
Definition: dColVector.cc:142
OCTAVE_EXPORT octave_value_list error nd deftypefn *const octave_scalar_map err
Definition: error.cc:1036
SparseMatrix sparse_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:834
std::complex< double > Complex
Definition: oct-cmplx.h:31
const T * fortran_vec(void) const
Definition: Array.h:584
ColumnVector real(const ComplexColumnVector &a)
Definition: dColVector.cc:136
double double_value(bool frc_str_conv=false) const
Definition: ov.h:775
octave_idx_type cols(void) const
Definition: Array.h:409
write the output to stdout if nargout is
Definition: load-save.cc:1576
Vector representing the dimensions (size) of an Array.
Definition: dim-vector.h:87
If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string
Definition: utils.cc:854
F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T F77_REAL F77_REAL &F77_RET_T F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE * x
bool is_real_matrix(void) const
Definition: ov.h:554