GNU Octave 10.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 
Loading...
Searching...
No Matches
pr-output.h
Go to the documentation of this file.
1////////////////////////////////////////////////////////////////////////
2//
3// Copyright (C) 1993-2025 The Octave Project Developers
4//
5// See the file COPYRIGHT.md in the top-level directory of this
6// distribution or <https://octave.org/copyright/>.
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
12// the Free Software Foundation, either version 3 of the License, or
13// (at your option) any later version.
14//
15// Octave is distributed in the hope that it will be useful, but
16// WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18// GNU General Public License for more details.
19//
20// You should have received a copy of the GNU General Public License
21// along with Octave; see the file COPYING. If not, see
22// <https://www.gnu.org/licenses/>.
23//
24////////////////////////////////////////////////////////////////////////
25
26#if ! defined (octave_pr_output_h)
27#define octave_pr_output_h 1
28
29#include "octave-config.h"
30
31#include <iosfwd>
32
33#include "Array-fwd.h"
34#include "intNDArray-fwd.h"
35#include "oct-cmplx.h"
36#include "oct-inttypes-fwd.h"
37#include "range-fwd.h"
38
39#include "pr-flt-fmt.h"
40
41class ComplexMatrix;
42class FloatComplexMatrix;
43class ComplexDiagMatrix;
44class FloatComplexDiagMatrix;
45class ComplexNDArray;
46class FloatComplexNDArray;
47class Matrix;
48class FloatMatrix;
49class DiagMatrix;
50class FloatDiagMatrix;
51class NDArray;
52class FloatNDArray;
53class boolMatrix;
54class boolNDArray;
55class charMatrix;
56class charNDArray;
57class PermMatrix;
58class Cell;
59class octave_value;
60
61template <typename T>
62float_display_format
63make_format (const std::complex<T>&)
64{
65 return float_display_format ();
66}
67
68template <>
69float_display_format
70make_format (const std::complex<double>& c);
71
72template <>
73float_display_format
74make_format (const std::complex<float>& fc);
75
76template <typename T>
77float_display_format
78make_format (const T&)
79{
80 return float_display_format ();
81}
82
83template <>
84float_display_format
85make_format (const double& d);
86
87template <>
88float_display_format
89make_format (const float& f);
90
91template <>
92float_display_format
93make_format (const octave::range<double>& r);
94
95template <>
96float_display_format
97make_format (const Matrix& m);
98
99template <>
100float_display_format
101make_format (const FloatMatrix& m);
102
103template <>
104float_display_format
105make_format (const ComplexMatrix& m);
106
107template <>
108float_display_format
109make_format (const FloatComplexMatrix& m);
110
111template <>
112float_display_format
113make_format (const boolNDArray& nda);
114
115template <>
116float_display_format
117make_format (const intNDArray<octave_int8>& nda);
118
119template <>
120float_display_format
121make_format (const intNDArray<octave_int16>& nda);
122
123template <>
124float_display_format
125make_format (const intNDArray<octave_int32>& nda);
126
127template <>
128float_display_format
129make_format (const intNDArray<octave_int64>& nda);
130
131template <>
132float_display_format
133make_format (const intNDArray<octave_uint8>& nda);
134
135template <>
136float_display_format
137make_format (const intNDArray<octave_uint16>& nda);
138
139template <>
140float_display_format
141make_format (const intNDArray<octave_uint32>& nda);
142
143template <>
144float_display_format
145make_format (const intNDArray<octave_uint64>& nda);
146
147template <>
148float_display_format
149make_format (const octave_int8& nda);
150
151template <>
152float_display_format
153make_format (const octave_int16& nda);
154
155template <>
156float_display_format
157make_format (const octave_int32& nda);
158
159template <>
160float_display_format
161make_format (const octave_int64& nda);
162
163template <>
164float_display_format
165make_format (const octave_uint8& nda);
166
167template <>
168float_display_format
169make_format (const octave_uint16& nda);
170
171template <>
172float_display_format
173make_format (const octave_uint32& nda);
174
175template <>
176float_display_format
177make_format (const octave_uint64& nda);
178
179// FIXME: templates plus specializations might help here.
180
181extern OCTINTERP_API void
182octave_print_internal (std::ostream& os, const float_display_format& fmt,
183 bool d, bool pr_as_read_syntax = false);
184
185extern OCTINTERP_API void
186octave_print_internal (std::ostream& os, bool d,
187 bool pr_as_read_syntax = false);
188
189extern OCTINTERP_API void
190octave_print_internal (std::ostream& os, const float_display_format& fmt,
191 char c, bool pr_as_read_syntax = false);
192
193inline void
194octave_print_internal (std::ostream& os, char c,
195 bool pr_as_read_syntax = false)
196{
197 float_display_format fmt (float_format (0, 0));
198 octave_print_internal (os, fmt, c, pr_as_read_syntax);
199}
200
201extern OCTINTERP_API void
202octave_print_internal (std::ostream& os, const float_display_format& fmt,
203 double d, bool pr_as_read_syntax = false);
204
205inline void
206octave_print_internal (std::ostream& os, double d,
207 bool pr_as_read_syntax = false)
208{
209 octave_print_internal (os, make_format (d), d, pr_as_read_syntax);
210}
211
212extern OCTINTERP_API void
213octave_print_internal (std::ostream& os, const float_display_format& fmt,
214 float d, bool pr_as_read_syntax = false);
215
216inline void
217octave_print_internal (std::ostream& os, float d,
218 bool pr_as_read_syntax = false)
219{
220 octave_print_internal (os, make_format (d), d, pr_as_read_syntax);
221}
222
223extern OCTINTERP_API void
224octave_print_internal (std::ostream& os, const Matrix& m,
225 bool pr_as_read_syntax = false,
226 int extra_indent = 0);
227
228extern OCTINTERP_API void
229octave_print_internal (std::ostream& os, const FloatMatrix& m,
230 bool pr_as_read_syntax = false,
231 int extra_indent = 0);
232
233extern OCTINTERP_API void
234octave_print_internal (std::ostream& os, const DiagMatrix& m,
235 bool pr_as_read_syntax = false,
236 int extra_indent = 0);
237
238extern OCTINTERP_API void
239octave_print_internal (std::ostream& os, const FloatDiagMatrix& m,
240 bool pr_as_read_syntax = false,
241 int extra_indent = 0);
242
243extern OCTINTERP_API void
244octave_print_internal (std::ostream& os, const NDArray& nda,
245 bool pr_as_read_syntax = false,
246 int extra_indent = 0);
247
248extern OCTINTERP_API void
249octave_print_internal (std::ostream& os, const FloatNDArray& nda,
250 bool pr_as_read_syntax = false,
251 int extra_indent = 0);
252
253extern OCTINTERP_API void
254octave_print_internal (std::ostream& os, const float_display_format& fmt,
255 const Complex& c, bool pr_as_read_syntax = false);
256
257inline void
258octave_print_internal (std::ostream& os, const Complex& c,
259 bool pr_as_read_syntax = false)
260{
261 octave_print_internal (os, make_format (c), c, pr_as_read_syntax);
262}
263
264extern OCTINTERP_API void
265octave_print_internal (std::ostream& os, const float_display_format& fmt,
266 const FloatComplex& c, bool pr_as_read_syntax = false);
267
268inline void
269octave_print_internal (std::ostream& os, const FloatComplex& c,
270 bool pr_as_read_syntax = false)
271{
272 octave_print_internal (os, make_format (c), c, pr_as_read_syntax);
273}
274
275extern OCTINTERP_API void
276octave_print_internal (std::ostream& os, const ComplexMatrix& cm,
277 bool pr_as_read_syntax = false,
278 int extra_indent = 0);
279
280extern OCTINTERP_API void
281octave_print_internal (std::ostream& os, const ComplexDiagMatrix& cm,
282 bool pr_as_read_syntax = false,
283 int extra_indent = 0);
284
285extern OCTINTERP_API void
286octave_print_internal (std::ostream& os, const FloatComplexMatrix& cm,
287 bool pr_as_read_syntax = false,
288 int extra_indent = 0);
289
290extern OCTINTERP_API void
291octave_print_internal (std::ostream& os, const FloatComplexDiagMatrix& cm,
292 bool pr_as_read_syntax = false,
293 int extra_indent = 0);
294
295extern OCTINTERP_API void
296octave_print_internal (std::ostream& os, const ComplexNDArray& nda,
297 bool pr_as_read_syntax = false,
298 int extra_indent = 0);
299
300extern OCTINTERP_API void
301octave_print_internal (std::ostream& os, const FloatComplexNDArray& nda,
302 bool pr_as_read_syntax = false,
303 int extra_indent = 0);
304
305extern OCTINTERP_API void
306octave_print_internal (std::ostream& os, const PermMatrix& m,
307 bool pr_as_read_syntax = false,
308 int extra_indent = 0);
309
310extern OCTINTERP_API void
311octave_print_internal (std::ostream& os, const octave::range<double>& r,
312 bool pr_as_read_syntax = false,
313 int extra_indent = 0);
314
315extern OCTINTERP_API void
316octave_print_internal (std::ostream& os, const boolMatrix& m,
317 bool pr_as_read_syntax = false,
318 int extra_indent = 0);
319
320extern OCTINTERP_API void
321octave_print_internal (std::ostream& os, const boolNDArray& m,
322 bool pr_as_read_syntax = false,
323 int extra_indent = 0);
324
325extern OCTINTERP_API void
326octave_print_internal (std::ostream& os, const charMatrix& chm,
327 bool pr_as_read_syntax = false,
328 int extra_indent = 0,
329 bool pr_as_string = false);
330
331extern OCTINTERP_API void
332octave_print_internal (std::ostream& os, const charNDArray& nda,
333 bool pr_as_read_syntax = false,
334 int extra_indent = 0,
335 bool pr_as_string = false);
336
337extern OCTINTERP_API void
338octave_print_internal (std::ostream& os, const std::string& s,
339 bool pr_as_read_syntax = false,
340 int extra_indent = 0);
341
342extern OCTINTERP_API void
343octave_print_internal (std::ostream& os, const Array<std::string>& sa,
344 bool pr_as_read_syntax = false,
345 int extra_indent = 0);
346
347extern OCTINTERP_API void
348octave_print_internal (std::ostream& os, const intNDArray<octave_int8>& sa,
349 bool pr_as_read_syntax = false,
350 int extra_indent = 0);
351
352extern OCTINTERP_API void
353octave_print_internal (std::ostream& os, const intNDArray<octave_uint8>& sa,
354 bool pr_as_read_syntax = false,
355 int extra_indent = 0);
356
357extern OCTINTERP_API void
358octave_print_internal (std::ostream& os, const intNDArray<octave_int16>& sa,
359 bool pr_as_read_syntax = false,
360 int extra_indent = 0);
361
362extern OCTINTERP_API void
363octave_print_internal (std::ostream& os, const intNDArray<octave_uint16>& sa,
364 bool pr_as_read_syntax = false,
365 int extra_indent = 0);
366
367extern OCTINTERP_API void
368octave_print_internal (std::ostream& os, const intNDArray<octave_int32>& sa,
369 bool pr_as_read_syntax = false,
370 int extra_indent = 0);
371
372extern OCTINTERP_API void
373octave_print_internal (std::ostream& os, const intNDArray<octave_uint32>& sa,
374 bool pr_as_read_syntax = false,
375 int extra_indent = 0);
376
377extern OCTINTERP_API void
378octave_print_internal (std::ostream& os, const intNDArray<octave_int64>& sa,
379 bool pr_as_read_syntax = false,
380 int extra_indent = 0);
381
382extern OCTINTERP_API void
383octave_print_internal (std::ostream& os, const intNDArray<octave_uint64>& sa,
384 bool pr_as_read_syntax = false,
385 int extra_indent = 0);
386
387extern OCTINTERP_API void
388octave_print_internal (std::ostream& os, const float_display_format&,
389 const octave_int<int8_t>& sa,
390 bool pr_as_read_syntax = false);
391
392inline void
393octave_print_internal (std::ostream& os, const octave_int<int8_t>& sa,
394 bool pr_as_read_syntax = false)
395{
396 float_display_format fmt (float_format (0, 0));
397 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
398}
399
400extern OCTINTERP_API void
401octave_print_internal (std::ostream& os, const float_display_format&,
402 const octave_int<uint8_t>& sa,
403 bool pr_as_read_syntax = false);
404
405inline void
406octave_print_internal (std::ostream& os, const octave_int<uint8_t>& sa,
407 bool pr_as_read_syntax = false)
408{
409 float_display_format fmt (float_format (0, 0));
410 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
411}
412
413extern OCTINTERP_API void
414octave_print_internal (std::ostream& os, const float_display_format&,
415 const octave_int<int16_t>& sa,
416 bool pr_as_read_syntax = false);
417
418inline void
419octave_print_internal (std::ostream& os, const octave_int<int16_t>& sa,
420 bool pr_as_read_syntax = false)
421{
422 float_display_format fmt (float_format (0, 0));
423 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
424}
425
426extern OCTINTERP_API void
427octave_print_internal (std::ostream& os, const float_display_format&,
428 const octave_int<uint16_t>& sa,
429 bool pr_as_read_syntax = false);
430
431inline void
432octave_print_internal (std::ostream& os, const octave_int<uint16_t>& sa,
433 bool pr_as_read_syntax = false)
434{
435 float_display_format fmt (float_format (0, 0));
436 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
437}
438
439extern OCTINTERP_API void
440octave_print_internal (std::ostream& os, const float_display_format&,
441 const octave_int<int32_t>& sa,
442 bool pr_as_read_syntax = false);
443
444inline void
445octave_print_internal (std::ostream& os, const octave_int<int32_t>& sa,
446 bool pr_as_read_syntax = false)
447{
448 float_display_format fmt (float_format (0, 0));
449 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
450}
451
452extern OCTINTERP_API void
453octave_print_internal (std::ostream& os, const float_display_format&,
454 const octave_int<uint32_t>& sa,
455 bool pr_as_read_syntax = false);
456
457inline void
458octave_print_internal (std::ostream& os, const octave_int<uint32_t>& sa,
459 bool pr_as_read_syntax = false)
460{
461 float_display_format fmt (float_format (0, 0));
462 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
463}
464
465extern OCTINTERP_API void
466octave_print_internal (std::ostream& os, const float_display_format&,
467 const octave_int<int64_t>& sa,
468 bool pr_as_read_syntax = false);
469
470inline void
471octave_print_internal (std::ostream& os, const octave_int<int64_t>& sa,
472 bool pr_as_read_syntax = false)
473{
474 float_display_format fmt (float_format (0, 0));
475 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
476}
477
478extern OCTINTERP_API void
479octave_print_internal (std::ostream& os, const float_display_format&,
480 const octave_int<uint64_t>& sa,
481 bool pr_as_read_syntax = false);
482
483inline void
484octave_print_internal (std::ostream& os, const octave_int<uint64_t>& sa,
485 bool pr_as_read_syntax = false)
486{
487 float_display_format fmt (float_format (0, 0));
488 octave_print_internal (os, fmt, sa, pr_as_read_syntax);
489}
490
491extern OCTINTERP_API void
492octave_print_internal (std::ostream& os, const Cell& cell,
493 bool pr_as_read_syntax = false,
494 int extra_indent = 0,
495 bool pr_as_string = false);
496
497inline void
498octave_print_internal (std::ostream& os, const float_display_format&,
499 const Cell& cell, bool pr_as_read_syntax = false,
500 int extra_indent = 0, bool pr_as_string = false)
501{
502 octave_print_internal (os, cell, pr_as_read_syntax, extra_indent,
503 pr_as_string);
504}
505
506extern OCTINTERP_API void
507octave_print_internal (std::ostream& os, const octave_value& ov,
508 bool pr_as_read_syntax = false);
509
510template <typename T>
511class pr_engineering_float
512{
513public:
514
515 const float_format m_ff;
516
517 T m_val;
518
519 int exponent () const;
520
521 T mantissa () const;
522
523 pr_engineering_float (const float_format& ff, T val)
524 : m_ff (ff), m_val (val) { }
525
526 pr_engineering_float (const float_display_format& fdf, T val)
527 : m_ff (fdf.real_format ()), m_val (val) { }
528};
529
530template <typename T>
531class pr_formatted_float
532{
533public:
534
535 const float_format m_ff;
536
537 T m_val;
538
539 pr_formatted_float (const float_format& ff, T val)
540 : m_ff (ff), m_val (val) { }
541
542 pr_formatted_float (const float_display_format& fdf, T val)
543 : m_ff (fdf.real_format ()), m_val (val) { }
544};
545
546template <typename T>
547class pr_rational_float
548{
549public:
550
551 const float_format m_ff;
552
553 T m_val;
554
555 pr_rational_float (const float_format& ff, T val)
556 : m_ff (ff), m_val (val) { }
557
558 pr_rational_float (const float_display_format& fdf, T val)
559 : m_ff (fdf.real_format ()), m_val (val) { }
560};
561
562template <typename T>
563extern std::ostream&
564operator << (std::ostream& os, const pr_engineering_float<T>& pef);
565
566template <typename T>
567extern std::ostream&
568operator << (std::ostream& os, const pr_formatted_float<T>& pff);
569
570template <typename T>
571extern std::ostream&
572operator << (std::ostream& os, const pr_rational_float<T>& prf);
573
574// TRUE means that the dimensions of empty objects should be printed
575// like this: x = [](2x0).
576extern bool Vprint_empty_dimensions;
577
578// TRUE means don't put empty lines in output
579extern bool Vcompact_format;
580
581#endif
Array
N Dimensional Array with copy-on-write semantics.
Definition Array.h:130
Cell
Definition Cell.h:41
float_display_format
Definition pr-flt-fmt.h:207
float_format
Definition pr-flt-fmt.h:48
octave_int
Definition oct-inttypes.h:783
octave_value
Definition ov.h:75
pr_engineering_float
Definition pr-output.h:512
pr_engineering_float::pr_engineering_float
pr_engineering_float(const float_format &ff, T val)
Definition pr-output.h:523
pr_engineering_float::m_val
T m_val
Definition pr-output.h:517
pr_engineering_float::mantissa
T mantissa() const
Definition pr-output.cc:180
pr_engineering_float::pr_engineering_float
pr_engineering_float(const float_display_format &fdf, T val)
Definition pr-output.h:526
pr_engineering_float::m_ff
const float_format m_ff
Definition pr-output.h:515
pr_engineering_float::exponent
int exponent() const
Definition pr-output.cc:173
pr_formatted_float
Definition pr-output.h:532
pr_formatted_float::pr_formatted_float
pr_formatted_float(const float_display_format &fdf, T val)
Definition pr-output.h:542
pr_formatted_float::m_val
T m_val
Definition pr-output.h:537
pr_formatted_float::pr_formatted_float
pr_formatted_float(const float_format &ff, T val)
Definition pr-output.h:539
pr_formatted_float::m_ff
const float_format m_ff
Definition pr-output.h:535
pr_rational_float
Definition pr-output.h:548
pr_rational_float::m_val
T m_val
Definition pr-output.h:553
pr_rational_float::m_ff
const float_format m_ff
Definition pr-output.h:551
pr_rational_float::pr_rational_float
pr_rational_float(const float_format &ff, T val)
Definition pr-output.h:555
pr_rational_float::pr_rational_float
pr_rational_float(const float_display_format &fdf, T val)
Definition pr-output.h:558
d
F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE * d
Definition lo-slatec-proto.h:39
f
F77_RET_T const F77_DBLE const F77_DBLE * f
Definition lo-slatec-proto.h:39
Complex
std::complex< double > Complex
Definition oct-cmplx.h:33
FloatComplex
std::complex< float > FloatComplex
Definition oct-cmplx.h:34
operator<<
std::ostream & operator<<(std::ostream &os, const pr_engineering_float< T > &pef)
Definition pr-output.cc:187
make_format
float_display_format make_format(const std::complex< T > &)
Definition pr-output.h:63
octave_print_internal
void octave_print_internal(std::ostream &os, const float_display_format &fmt, bool d, bool pr_as_read_syntax=false)
Definition pr-output.cc:1774
Vprint_empty_dimensions
bool Vprint_empty_dimensions
Definition pr-output.cc:71
Vcompact_format
bool Vcompact_format
Definition pr-output.cc:102