Mercurial > octave

annotate libinterp/corefcn/bitfcns.cc @ 33658:b1d6e40ac737 stable tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
NEWS.9.md: Fix typo and minor formatting changes. * etc/NEWS.9.md: Fix typo. Adjust whitespace. Use markdown syntax for code snippets.
author Markus Mützel <markus.muetzel@gmx.de>
date Wed, 05 Jun 2024 11:27:35 +0200
parents 2e484f9f1f18
children 4b601ca024d5
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
27923
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
2 //
32632
2e484f9f1f18 maint: update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents: 31706
diff changeset
3 // Copyright (C) 2004-2024 The Octave Project Developers
27923
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
4 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
7 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
9 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
14 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
19 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
23 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
24 ////////////////////////////////////////////////////////////////////////
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
25
21724
aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents: 21568
diff changeset
26 #if defined (HAVE_CONFIG_H)
21301
40de9f8f23a6 Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents: 21200
diff changeset
27 # include "config.h"
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
28 #endif
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
29
17396
0b644adf4f31 speak CHAR_BIT in C++-ese
John W. Eaton <jwe@octave.org>
parents: 17392
diff changeset
30 #include <limits>
0b644adf4f31 speak CHAR_BIT in C++-ese
John W. Eaton <jwe@octave.org>
parents: 17392
diff changeset
31
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
32 #include "str-vec.h"
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
33 #include "quit.h"
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
34
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
35 #include "defun.h"
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
36 #include "error.h"
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
37 #include "ov.h"
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
38 #include "ov-uint64.h"
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
39 #include "ov-uint32.h"
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
40 #include "ov-uint16.h"
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
41 #include "ov-uint8.h"
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
42 #include "ov-int64.h"
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
43 #include "ov-int32.h"
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
44 #include "ov-int16.h"
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
45 #include "ov-int8.h"
17392
e09cd91168d1 Support arguments of class single in bit manipulation functions (bug #34502)
Mike Miller <mtmiller@ieee.org>
parents: 17390
diff changeset
46 #include "ov-float.h"
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
47 #include "ov-scalar.h"
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
48 #include "ov-re-mat.h"
7763
0c6b4c7d7117 Treat bool as a scalar in the bit functions
David Bateman <dbateman@free.fr>
parents: 7097
diff changeset
49 #include "ov-bool.h"
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
50
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
51 #include <functional>
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
52
20791
f7084eae3318 maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents: 20711
diff changeset
53 #if ! defined (HAVE_CXX_BITWISE_OP_TEMPLATES)
31605
e88a07dec498 maint: Use macros to begin/end C++ namespaces.
Rik <rik@octave.org>
parents: 30888
diff changeset
54 OCTAVE_BEGIN_NAMESPACE(std)
e88a07dec498 maint: Use macros to begin/end C++ namespaces.
Rik <rik@octave.org>
parents: 30888
diff changeset
55
31607
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
56 template <typename T>
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
57 struct bit_and
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
58 {
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
59 public:
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
60 T operator() (const T& op1, const T& op2) const { return (op1 & op2); }
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
61 };
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
62
31607
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
63 template <typename T>
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
64 struct bit_or
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
65 {
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
66 public:
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
67 T operator() (const T& op1, const T& op2) const { return (op1 | op2); }
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
68 };
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
69
31607
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
70 template <typename T>
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
71 struct bit_xor
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
72 {
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
73 public:
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
74 T operator() (const T& op1, const T& op2) const { return (op1 ^ op2); }
aac27ad79be6 maint: Re-indent code after switch to using namespace macros.
Rik <rik@octave.org>
parents: 31605
diff changeset
75 };
31605
e88a07dec498 maint: Use macros to begin/end C++ namespaces.
Rik <rik@octave.org>
parents: 30888
diff changeset
76
e88a07dec498 maint: Use macros to begin/end C++ namespaces.
Rik <rik@octave.org>
parents: 30888
diff changeset
77 OCTAVE_END_NAMESPACE(std)
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
78 #endif
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
79
31605
e88a07dec498 maint: Use macros to begin/end C++ namespaces.
Rik <rik@octave.org>
parents: 30888
diff changeset
80 OCTAVE_BEGIN_NAMESPACE(octave)
29958
32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
81
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
82 template <typename OP, typename T>
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
83 octave_value
14861
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
84 bitopxx (const OP& op, const std::string& fname,
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
85 const Array<T>& x, const Array<T>& y)
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
86 {
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
87 int nelx = x.numel ();
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
88 int nely = y.numel ();
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
89
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
90 bool is_scalar_op = (nelx == 1 || nely == 1);
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
91
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
92 dim_vector dvx = x.dims ();
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
93 dim_vector dvy = y.dims ();
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
94
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
95 bool is_array_op = (dvx == dvy);
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
96
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
97 if (! is_array_op && ! is_scalar_op)
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
98 error ("%s: size of X and Y must match, or one operand must be a scalar",
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14725
diff changeset
99 fname.c_str ());
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
100
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
101 Array<T> result;
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
102
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
103 if (nelx != 1)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
104 result.resize (dvx);
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
105 else
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
106 result.resize (dvy);
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
107
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
108 for (int i = 0; i < nelx; i++)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
109 if (is_scalar_op)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
110 for (int k = 0; k < nely; k++)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
111 result(i+k) = op (x(i), y(k));
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
112 else
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
113 result(i) = op (x(i), y(i));
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
114
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
115 return result;
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
116 }
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
117
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
118 // Trampoline function, instantiates the proper template above, with
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
119 // reflective information hardwired. We can't hardwire this information
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
120 // in Fbitxxx DEFUNs below, because at that moment, we still don't have
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
121 // information about which integer types we need to instantiate.
21139
538b57866b90 consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents: 20980
diff changeset
122 template <typename T>
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
123 octave_value
14861
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
124 bitopx (const std::string& fname, const Array<T>& x, const Array<T>& y)
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
125 {
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
126 if (fname == "bitand")
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
127 return bitopxx (std::bit_and<T>(), fname, x, y);
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
128 if (fname == "bitor")
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
129 return bitopxx (std::bit_or<T>(), fname, x, y);
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
130
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
131 //else (fname == "bitxor")
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
132 return bitopxx (std::bit_xor<T>(), fname, x, y);
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
133 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
134
19864
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
135 static inline int
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
136 bitop_arg_is_int (const octave_value& arg)
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
137 {
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
138 return (arg.class_name () != octave_scalar::static_class_name ()
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
139 && arg.class_name () != octave_float_scalar::static_class_name ()
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
140 && arg.class_name () != octave_bool::static_class_name ());
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
141 }
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
142
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
143 static inline int
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
144 bitop_arg_is_bool (const octave_value& arg)
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
145 {
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
146 return arg.class_name () == octave_bool::static_class_name ();
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
147 }
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
148
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
149 static inline int
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
150 bitop_arg_is_float (const octave_value& arg)
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
151 {
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
152 return arg.class_name () == octave_float_scalar::static_class_name ();
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
153 }
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
154
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
155 octave_value
14861
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
156 bitop (const std::string& fname, const octave_value_list& args)
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
157 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
158 if (args.length () != 2)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
159 print_usage ();
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
160
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
161 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
162
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
163 if (args(0).class_name () == octave_scalar::static_class_name ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
164 || args(0).class_name () == octave_float_scalar::static_class_name ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
165 || args(0).class_name () == octave_bool::static_class_name ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
166 || args(1).class_name () == octave_scalar::static_class_name ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
167 || args(1).class_name () == octave_float_scalar::static_class_name ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
168 || args(1).class_name () == octave_bool::static_class_name ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
169 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
170 bool arg0_is_int = bitop_arg_is_int (args(0));
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
171 bool arg1_is_int = bitop_arg_is_int (args(1));
19864
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
172
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
173 bool arg0_is_bool = bitop_arg_is_bool (args(0));
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
174 bool arg1_is_bool = bitop_arg_is_bool (args(1));
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
175
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
176 bool arg0_is_float = bitop_arg_is_float (args(0));
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
177 bool arg1_is_float = bitop_arg_is_float (args(1));
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
178
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
179 if (! (arg0_is_int || arg1_is_int))
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
180 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
181 if (arg0_is_bool && arg1_is_bool)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
182 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
183 boolNDArray x (args(0).bool_array_value ());
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
184 boolNDArray y (args(1).bool_array_value ());
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
185
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
186 retval = bitopx (fname, x, y).bool_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
187 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
188 else if (arg0_is_float && arg1_is_float)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
189 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
190 uint64NDArray x (args(0).float_array_value ());
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
191 uint64NDArray y (args(1).float_array_value ());
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
192
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
193 retval = bitopx (fname, x, y).float_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
194 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
195 else if (! (arg0_is_float || arg1_is_float))
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
196 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
197 uint64NDArray x (args(0).array_value ());
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
198 uint64NDArray y (args(1).array_value ());
17392
e09cd91168d1 Support arguments of class single in bit manipulation functions (bug #34502)
Mike Miller <mtmiller@ieee.org>
parents: 17390
diff changeset
199
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
200 retval = bitopx (fname, x, y).array_value ();
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
201 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
202 else
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
203 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
204 int p = (arg0_is_float ? 1 : 0);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
205 int q = (arg0_is_float ? 0 : 1);
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
206
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
207 uint64NDArray x (args(p).array_value ());
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
208 uint64NDArray y (args(q).float_array_value ());
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
209
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
210 retval = bitopx (fname, x, y).float_array_value ();
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
211 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
212 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
213 else
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
214 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
215 int p = (arg0_is_int ? 1 : 0);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
216 int q = (arg0_is_int ? 0 : 1);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
217
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
218 NDArray dx = args(p).array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
219
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
220 if (args(q).type_id () == octave_uint64_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
221 || args(q).type_id () == octave_uint64_scalar::static_type_id ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
222 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
223 uint64NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
224 uint64NDArray y = args(q).uint64_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
225
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
226 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
227 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
228 else if (args(q).type_id () == octave_uint32_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
229 || args(q).type_id () == octave_uint32_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
230 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
231 uint32NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
232 uint32NDArray y = args(q).uint32_array_value ();
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
233
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
234 retval = bitopx (fname, x, y);
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
235 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
236 else if (args(q).type_id () == octave_uint16_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
237 || args(q).type_id () == octave_uint16_scalar::static_type_id ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
238 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
239 uint16NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
240 uint16NDArray y = args(q).uint16_array_value ();
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
241
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
242 retval = bitopx (fname, x, y);
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
243 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
244 else if (args(q).type_id () == octave_uint8_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
245 || args(q).type_id () == octave_uint8_scalar::static_type_id ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
246 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
247 uint8NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
248 uint8NDArray y = args(q).uint8_array_value ();
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
249
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
250 retval = bitopx (fname, x, y);
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
251 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
252 else if (args(q).type_id () == octave_int64_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
253 || args(q).type_id () == octave_int64_scalar::static_type_id ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
254 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
255 int64NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
256 int64NDArray y = args(q).int64_array_value ();
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
257
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
258 retval = bitopx (fname, x, y);
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
259 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
260 else if (args(q).type_id () == octave_int32_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
261 || args(q).type_id () == octave_int32_scalar::static_type_id ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
262 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
263 int32NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
264 int32NDArray y = args(q).int32_array_value ();
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
265
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
266 retval = bitopx (fname, x, y);
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
267 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
268 else if (args(q).type_id () == octave_int16_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
269 || args(q).type_id () == octave_int16_scalar::static_type_id ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
270 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
271 int16NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
272 int16NDArray y = args(q).int16_array_value ();
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
273
21568
3d60ed163b70 maint: Eliminate bad spacing around '='.
Rik <rik@octave.org>
parents: 21547
diff changeset
274 retval = bitopx (fname, x, y);
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
275 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
276 else if (args(q).type_id () == octave_int8_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
277 || args(q).type_id () == octave_int8_scalar::static_type_id ())
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
278 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
279 int8NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
280 int8NDArray y = args(q).int8_array_value ();
20559
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
281
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
282 retval = bitopx (fname, x, y);
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
283 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
284 else
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14725
diff changeset
285 error ("%s: invalid operand type", fname.c_str ());
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
286 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
287 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
288 else if (args(0).class_name () == args(1).class_name ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
289 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
290 if (args(0).type_id () == octave_uint64_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
291 || args(0).type_id () == octave_uint64_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
292 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
293 uint64NDArray x = args(0).uint64_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
294 uint64NDArray y = args(1).uint64_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
295
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
296 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
297 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
298 else if (args(0).type_id () == octave_uint32_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
299 || args(0).type_id () == octave_uint32_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
300 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
301 uint32NDArray x = args(0).uint32_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
302 uint32NDArray y = args(1).uint32_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
303
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
304 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
305 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
306 else if (args(0).type_id () == octave_uint16_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
307 || args(0).type_id () == octave_uint16_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
308 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
309 uint16NDArray x = args(0).uint16_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
310 uint16NDArray y = args(1).uint16_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
311
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
312 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
313 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
314 else if (args(0).type_id () == octave_uint8_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
315 || args(0).type_id () == octave_uint8_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
316 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
317 uint8NDArray x = args(0).uint8_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
318 uint8NDArray y = args(1).uint8_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
319
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
320 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
321 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
322 else if (args(0).type_id () == octave_int64_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
323 || args(0).type_id () == octave_int64_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
324 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
325 int64NDArray x = args(0).int64_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
326 int64NDArray y = args(1).int64_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
327
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
328 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
329 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
330 else if (args(0).type_id () == octave_int32_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
331 || args(0).type_id () == octave_int32_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
332 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
333 int32NDArray x = args(0).int32_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
334 int32NDArray y = args(1).int32_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
335
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
336 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
337 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
338 else if (args(0).type_id () == octave_int16_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
339 || args(0).type_id () == octave_int16_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
340 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
341 int16NDArray x = args(0).int16_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
342 int16NDArray y = args(1).int16_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
343
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
344 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
345 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
346 else if (args(0).type_id () == octave_int8_matrix::static_type_id ()
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
347 || args(0).type_id () == octave_int8_scalar::static_type_id ())
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
348 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
349 int8NDArray x = args(0).int8_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
350 int8NDArray y = args(1).int8_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
351
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
352 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
353 }
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
354 else
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
355 error ("%s: invalid operand type", fname.c_str ());
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
356 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
357 else
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
358 error ("%s: must have matching operand types", fname.c_str ());
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
359
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
360 return retval;
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
361 }
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
362
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
363 DEFUN (bitand, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
364 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
365 @deftypefn {} {@var{z} =} bitand (@var{x}, @var{y})
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
366 Return the bitwise AND of non-negative integers.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
367
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
368 @var{x}, @var{y} must be in the range [0,intmax]
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
369 @seealso{bitor, bitxor, bitset, bitget, bitcmp, bitshift, intmax, flintmax}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
370 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
371 {
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
372 return bitop ("bitand", args);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
373 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
374
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
375 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
376 %!# Function bitand is tested as part of bitxor BIST tests
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
377 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
378
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
379 DEFUN (bitor, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
380 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
381 @deftypefn {} {@var{z} =} bitor (@var{x}, @var{y})
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
382 Return the bitwise OR of non-negative integers @var{x} and @var{y}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
383
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
384 @seealso{bitor, bitxor, bitset, bitget, bitcmp, bitshift, intmax, flintmax}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
385 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
386 {
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
387 return bitop ("bitor", args);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
388 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
389
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
390 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
391 %!# Function bitor is tested as part of bitxor BIST tests
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
392 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
393
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
394 DEFUN (bitxor, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
395 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
396 @deftypefn {} {@var{z} =} bitxor (@var{x}, @var{y})
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
397 Return the bitwise XOR of non-negative integers @var{x} and @var{y}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
398
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
399 @seealso{bitand, bitor, bitset, bitget, bitcmp, bitshift, intmax, flintmax}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
400 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
401 {
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
402 return bitop ("bitxor", args);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
403 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
404
19146
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
405 /*
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
406 %!assert (bitand (true, false), false)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
407 %!assert (bitor (true, false), true)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
408 %!assert (bitxor (true, false), true)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
409
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
410 %!assert (bitand (true, true), true)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
411 %!assert (bitor (true, true), true)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
412 %!assert (bitxor (true, true), false)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
413
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
414 %!assert (bitand (true, 5), 1)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
415
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
416 %!assert (bitand (true, false), false)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
417 %!assert (bitand (true, true), true)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
418 %!assert (bitand (true, false), false)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
419 %!assert (bitand (true, false), false)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
420
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
421 ## Test idx_arg.length () == 0
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
422 %!error <size of X and Y must match> bitand ([0 0 0], [1 0])
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
423 %!error <size of X and Y must match> bitand ([0; 0; 0], [0 0 0])
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
424 */
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
425
17389
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
426 template <typename T>
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
427 static int64_t
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
428 max_mantissa_value ()
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
429 {
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
430 return (static_cast<int64_t> (1) << std::numeric_limits<T>::digits) - 1;
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
431 }
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
432
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
433 static int64_t
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
434 bitshift (double a, int n, int64_t mask)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
435 {
6108
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
436 // In the name of bug-for-bug compatibility.
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
437 if (a < 0)
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
438 return -bitshift (-a, n, mask);
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
439
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
440 if (n > 0)
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
441 return (static_cast<int64_t> (a) << n) & mask;
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
442 else if (n < 0)
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
443 return (static_cast<int64_t> (a) >> -n) & mask;
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
444 else
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
445 return static_cast<int64_t> (a) & mask;
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
446 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
447
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
448 static int64_t
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
449 bitshift (float a, int n, int64_t mask)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
450 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
451 // In the name of bug-for-bug compatibility.
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
452 if (a < 0)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
453 return -bitshift (-a, n, mask);
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
454
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
455 if (n > 0)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
456 return (static_cast<int64_t> (a) << n) & mask;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
457 else if (n < 0)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
458 return (static_cast<int64_t> (a) >> -n) & mask;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
459 else
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
460 return static_cast<int64_t> (a) & mask;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
461 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
462
4919
a1073eef650c [project @ 2004-07-27 15:22:50 by jwe]
jwe
parents: 4915
diff changeset
463 // Note that the bitshift operators are undefined if shifted by more
a1073eef650c [project @ 2004-07-27 15:22:50 by jwe]
jwe
parents: 4915
diff changeset
464 // bits than in the type, so we need to test for the size of the
a1073eef650c [project @ 2004-07-27 15:22:50 by jwe]
jwe
parents: 4915
diff changeset
465 // shift.
a1073eef650c [project @ 2004-07-27 15:22:50 by jwe]
jwe
parents: 4915
diff changeset
466
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
467 #define DO_BITSHIFT(T) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
468 double d1, d2; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
469 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
470 if (! n.all_integers (d1, d2)) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
471 error ("bitshift: K must be a scalar or array of integers"); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
472 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
473 int m_nel = m.numel (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
474 int n_nel = n.numel (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
475 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
476 bool is_scalar_op = (m_nel == 1 || n_nel == 1); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
477 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
478 dim_vector m_dv = m.dims (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
479 dim_vector n_dv = n.dims (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
480 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
481 bool is_array_op = (m_dv == n_dv); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
482 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
483 if (! is_array_op && ! is_scalar_op) \
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
484 error ("bitshift: size of A and N must match, or one operand must be a scalar"); \
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
485 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
486 T ## NDArray result; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
487 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
488 if (m_nel != 1) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
489 result.resize (m_dv); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
490 else \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
491 result.resize (n_dv); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
492 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
493 for (int i = 0; i < m_nel; i++) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
494 if (is_scalar_op) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
495 for (int k = 0; k < n_nel; k++) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
496 if (static_cast<int> (n(k)) >= bits_in_type) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
497 result(i+k) = 0; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
498 else \
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
499 result(i+k) = bitshift (m(i), static_cast<int> (n(k)), mask); \
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
500 else \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
501 if (static_cast<int> (n(i)) >= bits_in_type) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
502 result(i) = 0; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
503 else \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
504 result(i) = bitshift (m(i), static_cast<int> (n(i)), mask); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
505 \
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
506 retval = result;
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
507
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
508 #define DO_UBITSHIFT(T, N) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
509 do \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
510 { \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
511 int bits_in_type = octave_ ## T :: nbits (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
512 T ## NDArray m = m_arg.T ## _array_value (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
513 octave_ ## T mask = octave_ ## T::max (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
514 if ((N) < bits_in_type) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
515 mask = bitshift (mask, (N) - bits_in_type); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
516 else if ((N) < 1) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
517 mask = 0; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
518 DO_BITSHIFT (T); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
519 } \
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
520 while (0)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
521
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
522 #define DO_SBITSHIFT(T, N) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
523 do \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
524 { \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
525 int bits_in_type = octave_ ## T :: nbits (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
526 T ## NDArray m = m_arg.T ## _array_value (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
527 octave_ ## T mask = octave_ ## T::max (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
528 if ((N) < bits_in_type) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
529 mask = bitshift (mask, (N) - bits_in_type); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
530 else if ((N) < 1) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
531 mask = 0; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
532 /* FIXME: 2's complement only? */ \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
533 mask = mask | octave_ ## T :: min (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
534 DO_BITSHIFT (T); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
535 } \
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
536 while (0)
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
537
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
538 DEFUN (bitshift, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
539 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
540 @deftypefn {} {@var{B} =} bitshift (@var{A}, @var{k})
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
541 @deftypefnx {} {@var{B} =} bitshift (@var{A}, @var{k}, @var{n})
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
542 Return a @var{k} bit shift of @var{n}-digit unsigned integers in @var{A}.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
543
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
544 A positive @var{k} leads to a left shift; A negative value to a right shift.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
545
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
546 If @var{n} is omitted it defaults to 64. @var{n} must be in the range [1,64].
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
547
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
548 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
549 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
550 bitshift (eye (3), 1)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
551 @result{}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
552 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
553 2 0 0
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
554 0 2 0
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
555 0 0 2
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
556 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
557
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
558 bitshift (10, [-2, -1, 0, 1, 2])
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
559 @result{} 2 5 10 20 40
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
560 @c FIXME: restore this example when third arg is allowed to be an array.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
561 @c
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
562 @c
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
563 @c bitshift ([1, 10], 2, [3,4])
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
564 @c @result{} 4 8
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
565 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
566 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
567 @seealso{bitand, bitor, bitxor, bitset, bitget, bitcmp, intmax, flintmax}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
568 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
569 {
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
570 int nargin = args.length ();
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
571
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
572 if (nargin < 2 || nargin > 3)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
573 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
574
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
575 NDArray n = args(1).xarray_value ("bitshift: K must be a scalar or array of integers");
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
576
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
577 int nbits = 64;
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
578
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
579 if (nargin == 3)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
580 {
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
581 // FIXME: for compatibility, we should accept an array or a scalar
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
582 // as the third argument.
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
583 if (args(2).numel () > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
584 error ("bitshift: N must be a scalar integer");
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
585
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
586 nbits = args(2).xint_value ("bitshift: N must be an integer");
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
587
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
588 if (nbits < 0)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
589 error ("bitshift: N must be positive");
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
590 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
591
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
592 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
593
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
594 octave_value m_arg = args(0);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
595 std::string cname = m_arg.class_name ();
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
596
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
597 if (cname == "double")
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
598 {
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
599 static const int bits_in_mantissa
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
600 = std::numeric_limits<double>::digits;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
601
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
602 nbits = (nbits < bits_in_mantissa ? nbits : bits_in_mantissa);
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
603 int64_t mask = max_mantissa_value<double> ();
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
604 if (nbits < bits_in_mantissa)
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
605 mask = mask >> (bits_in_mantissa - nbits);
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
606 int bits_in_type = sizeof (double)
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22323
diff changeset
607 * std::numeric_limits<unsigned char>::digits;
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
608 NDArray m = m_arg.array_value ();
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
609 DO_BITSHIFT ();
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
610 }
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
611 else if (cname == "uint8")
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
612 DO_UBITSHIFT (uint8, nbits < 8 ? nbits : 8);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
613 else if (cname == "uint16")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
614 DO_UBITSHIFT (uint16, nbits < 16 ? nbits : 16);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
615 else if (cname == "uint32")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
616 DO_UBITSHIFT (uint32, nbits < 32 ? nbits : 32);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
617 else if (cname == "uint64")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
618 DO_UBITSHIFT (uint64, nbits < 64 ? nbits : 64);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
619 else if (cname == "int8")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
620 DO_SBITSHIFT (int8, nbits < 8 ? nbits : 8);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
621 else if (cname == "int16")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
622 DO_SBITSHIFT (int16, nbits < 16 ? nbits : 16);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
623 else if (cname == "int32")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
624 DO_SBITSHIFT (int32, nbits < 32 ? nbits : 32);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
625 else if (cname == "int64")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
626 DO_SBITSHIFT (int64, nbits < 64 ? nbits : 64);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
627 else if (cname == "single")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
628 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
629 static const int bits_in_mantissa
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
630 = std::numeric_limits<float>::digits;
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
631 nbits = (nbits < bits_in_mantissa ? nbits : bits_in_mantissa);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
632 int64_t mask = max_mantissa_value<float> ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
633 if (nbits < bits_in_mantissa)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
634 mask = mask >> (bits_in_mantissa - nbits);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
635 int bits_in_type = sizeof (float)
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22323
diff changeset
636 * std::numeric_limits<unsigned char>::digits;
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
637 FloatNDArray m = m_arg.float_array_value ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
638 DO_BITSHIFT (Float);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
639 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
640 else
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
641 error ("bitshift: not defined for %s objects", cname.c_str ());
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
642
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
643 return retval;
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
644 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
645
19146
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
646 /*
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
647 %!assert (bitshift (uint8 (16), 1), uint8 ( 32))
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
648 %!assert (bitshift (uint16 (16), 2), uint16 ( 64))
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
649 %!assert (bitshift (uint32 (16), 3), uint32 (128))
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
650 %!assert (bitshift (uint64 (16), 4), uint64 (256))
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
651 %!assert (bitshift (uint8 (255), 1), uint8 (254))
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
652
20711
7b608fadc663 Make error messages more specific about the variable and problem encountered.
Rik <rik@octave.org>
parents: 20704
diff changeset
653 %!error <K must be a scalar or array of integers> bitshift (16, 1.5)
19146
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
654 %!error bitshift (16, {1})
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
655 %!error <N must be a scalar integer> bitshift (10, [-2 -1 0 1 2], [1 1 1 1 1])
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
656 %!error <N must be positive> bitshift (10, [-2 -1 0 1 2], -1)
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
657 */
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
658
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
659 DEFUN (flintmax, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
660 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
661 @deftypefn {} {@var{Imax} =} flintmax ()
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
662 @deftypefnx {} {@var{Imax} =} flintmax ("double")
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
663 @deftypefnx {} {@var{Imax} =} flintmax ("single")
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
664 @deftypefnx {} {@var{Imax} =} flintmax (@var{var})
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
665 Return the largest integer that can be represented consecutively in a
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
666 floating point value.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
667
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
668 The input is either a string specifying a floating point type, or it is an
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
669 existing floating point variable @var{var}.
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
670
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
671 The default type is @qcode{"double"}, but @qcode{"single"} is a valid option.
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
672 On IEEE 754 compatible systems, @code{flintmax} is @w{@math{2^{53}}} for
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
673 @qcode{"double"} and @w{@math{2^{24}}} for @qcode{"single"}.
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
674
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
675 Example Code - query an existing variable
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
676
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
677 @example
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
678 @group
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
679 x = single (1);
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
680 flintmax (x)
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
681 @result{} 16777216
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
682 @end group
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
683 @end example
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
684
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
685 @seealso{intmax, realmax, realmin}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
686 @end deftypefn */)
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
687 {
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
688 int nargin = args.length ();
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
689
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
690 if (nargin > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
691 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
692
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
693 std::string cname = "double";
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
694 if (nargin == 1)
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
695 {
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
696 if (args(0).is_string ())
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
697 cname = args(0).string_value ();
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
698 else if (args(0).isfloat ())
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
699 cname = args(0).class_name ();
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
700 else
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
701 error ("intmin: argument must be a string or floating point variable");
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
702 }
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
703
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
704 if (cname == "double")
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
705 return ovl (static_cast<double> (max_mantissa_value<double> () + 1));
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
706 else if (cname == "single")
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
707 return ovl (static_cast<float> (max_mantissa_value<float> () + 1));
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
708 else
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
709 error ("flintmax: not defined for class '%s'", cname.c_str ());
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
710 }
16939
06897f865f0b Add flintmax() as an alias for function bitmax().
Rik <rik@octave.org>
parents: 15195
diff changeset
711
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
712 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
713 %!assert (flintmax (), 2^53)
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
714 %!assert (flintmax ("double"), 2^53)
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
715 %!assert (flintmax ("single"), single (2^24))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
716
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
717 %!test
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
718 %! x = single (1);
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
719 %! assert (flintmax (x), single (16777216));
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
720
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
721 %!error flintmax ("double", 0)
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
722 %!error <must be a string or floating point variable> flintmax (int8 (1))
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
723 %!error <not defined for class 'int8'> flintmax ("int8")
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
724 %!error <not defined for class 'char'> flintmax ("char")
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
725 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
726
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
727 DEFUN (intmax, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
728 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
729 @deftypefn {} {@var{Imax} =} intmax ()
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
730 @deftypefnx {} {@var{Imax} =} intmax ("@var{type}")
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
731 @deftypefnx {} {@var{Imax} =} intmax (@var{var})
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
732 Return the largest integer that can be represented by a specific integer type.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
733
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
734 The input is either a string @qcode{"@var{type}"} specifying an integer type,
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
735 or it is an existing integer variable @var{var}.
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
736
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
737 Possible values for @var{type} are
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
738
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
739 @table @asis
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
740 @item @qcode{"int8"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
741 signed 8-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
742
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
743 @item @qcode{"int16"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
744 signed 16-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
745
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
746 @item @qcode{"int32"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
747 signed 32-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
748
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
749 @item @qcode{"int64"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
750 signed 64-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
751
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
752 @item @qcode{"uint8"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
753 unsigned 8-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
754
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
755 @item @qcode{"uint16"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
756 unsigned 16-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
757
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
758 @item @qcode{"uint32"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
759 unsigned 32-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
760
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
761 @item @qcode{"uint64"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
762 unsigned 64-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
763 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
764
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
765 The default for @var{type} is @qcode{"int32"}.
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
766
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
767 Example Code - query an existing variable
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
768
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
769 @example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
770 @group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
771 x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
772 intmax (x)
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
773 @result{} 127
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
774 @end group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
775 @end example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
776
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
777 @seealso{intmin, flintmax}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
778 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
779 {
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
780 int nargin = args.length ();
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
781
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
782 if (nargin > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
783 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
784
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
785 std::string cname = "int32";
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
786 if (nargin == 1)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
787 {
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
788 if (args(0).is_string ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
789 cname = args(0).string_value ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
790 else if (args(0).isinteger ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
791 cname = args(0).class_name ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
792 else
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
793 error ("intmax: argument must be a string or integer variable");
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
794 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
795
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
796 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
797
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
798 if (cname == "uint8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
799 retval = octave_uint8 (std::numeric_limits<uint8_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
800 else if (cname == "uint16")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
801 retval = octave_uint16 (std::numeric_limits<uint16_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
802 else if (cname == "uint32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
803 retval = octave_uint32 (std::numeric_limits<uint32_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
804 else if (cname == "uint64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
805 retval = octave_uint64 (std::numeric_limits<uint64_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
806 else if (cname == "int8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
807 retval = octave_int8 (std::numeric_limits<int8_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
808 else if (cname == "int16")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
809 retval = octave_int16 (std::numeric_limits<int16_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
810 else if (cname == "int32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
811 retval = octave_int32 (std::numeric_limits<int32_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
812 else if (cname == "int64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
813 retval = octave_int64 (std::numeric_limits<int64_t>::max ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
814 else
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
815 error ("intmax: not defined for '%s' objects", cname.c_str ());
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
816
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
817 return retval;
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
818 }
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
819
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
820 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
821 %!assert (intmax (), int32 (2^31 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
822 %!assert (intmax ("int8"), int8 (2^7 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
823 %!assert (intmax ("uint8"), uint8 (2^8 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
824 %!assert (intmax ("int16"), int16 (2^15 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
825 %!assert (intmax ("uint16"), uint16 (2^16 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
826 %!assert (intmax ("int32"), int32 (2^31 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
827 %!assert (intmax ("uint32"), uint32 (2^32 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
828 %!assert (intmax ("int64"), int64 (2^63 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
829 %!assert (intmax ("uint64"), uint64 (2^64 - 1))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
830
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
831 %!test
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
832 %! x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
833 %! assert (intmax (x), int8 (127));
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
834
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
835 %!error intmax ("int32", 0)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
836 %!error <must be a string or integer variable> intmax (1.0)
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
837 %!error <not defined for 'double' objects> intmax ("double")
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
838 %!error <not defined for 'char' objects> intmax ("char")
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
839 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
840
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
841 DEFUN (intmin, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
842 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
843 @deftypefn {} {@var{Imin} =} intmin ()
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
844 @deftypefnx {} {@var{Imin} =} intmin ("@var{type}")
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
845 @deftypefnx {} {@var{Imin} =} intmin (@var{var})
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
846 Return the smallest integer that can be represented by a specific integer type.
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
847
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
848 The input is either a string @qcode{"@var{type}"} specifying an integer type,
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
849 or it is an existing integer variable @var{var}.
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
850
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
851 Possible values for @var{type} are
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
852
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
853 @table @asis
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
854 @item @qcode{"int8"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
855 signed 8-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
856
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
857 @item @qcode{"int16"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
858 signed 16-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
859
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
860 @item @qcode{"int32"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
861 signed 32-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
862
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
863 @item @qcode{"int64"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
864 signed 64-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
865
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
866 @item @qcode{"uint8"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
867 unsigned 8-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
868
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
869 @item @qcode{"uint16"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
870 unsigned 16-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
871
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
872 @item @qcode{"uint32"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
873 unsigned 32-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
874
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
875 @item @qcode{"uint64"}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
876 unsigned 64-bit integer.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
877 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
878
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
879 The default for @var{type} is @qcode{"int32"}.
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
880
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
881 Example Code - query an existing variable
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
882
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
883 @example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
884 @group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
885 x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
886 intmin (x)
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
887 @result{} -128
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
888 @end group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
889 @end example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
890
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
891 @seealso{intmax, flintmax}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
892 @end deftypefn */)
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
893 {
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
894 int nargin = args.length ();
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
895
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
896 if (nargin > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
897 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
898
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
899 std::string cname = "int32";
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
900 if (nargin == 1)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
901 {
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
902 if (args(0).is_string ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
903 cname = args(0).string_value ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
904 else if (args(0).isinteger ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
905 cname = args(0).class_name ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
906 else
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
907 error ("intmin: argument must be a string or integer variable");
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
908 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
909
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
910 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
911
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
912 if (cname == "uint8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
913 retval = octave_uint8 (std::numeric_limits<uint8_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
914 else if (cname == "uint16")
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14725
diff changeset
915 retval = octave_uint16 (std::numeric_limits<uint16_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
916 else if (cname == "uint32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
917 retval = octave_uint32 (std::numeric_limits<uint32_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
918 else if (cname == "uint64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
919 retval = octave_uint64 (std::numeric_limits<uint64_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
920 else if (cname == "int8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
921 retval = octave_int8 (std::numeric_limits<int8_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
922 else if (cname == "int16")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
923 retval = octave_int16 (std::numeric_limits<int16_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
924 else if (cname == "int32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
925 retval = octave_int32 (std::numeric_limits<int32_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
926 else if (cname == "int64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
927 retval = octave_int64 (std::numeric_limits<int64_t>::min ());
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
928 else
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
929 error ("intmin: not defined for '%s' objects", cname.c_str ());
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
930
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
931 return retval;
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
932 }
10811
e38c071bbc41 allow user query the maximum array size
Jaroslav Hajek <highegg@gmail.com>
parents: 10315
diff changeset
933
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
934 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
935 %!assert (intmin (), int32 (-2^31))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
936 %!assert (intmin ("int8"), int8 (-2^7))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
937 %!assert (intmin ("uint8"), uint8 (-2^8))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
938 %!assert (intmin ("int16"), int16 (-2^15))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
939 %!assert (intmin ("uint16"), uint16 (-2^16))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
940 %!assert (intmin ("int32"), int32 (-2^31))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
941 %!assert (intmin ("uint32"), uint32 (-2^32))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
942 %!assert (intmin ("int64"), int64 (-2^63))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
943 %!assert (intmin ("uint64"), uint64 (-2^64))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
944
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
945 %!test
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
946 %! x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
947 %! assert (intmin (x), int8 (-128));
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
948
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
949 %!error intmin ("int32", 0)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
950 %!error <must be a string or integer variable> intmin (1.0)
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
951 %!error <not defined for 'double' objects> intmin ("double")
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
952 %!error <not defined for 'char' objects> intmin ("char")
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
953 */
27880
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
954
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
955 DEFUN (sizemax, args, ,
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
956 doc: /* -*- texinfo -*-
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
957 @deftypefn {} {@var{max_numel} =} sizemax ()
27880
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
958 Return the largest value allowed for the size of an array.
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
959
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
960 If Octave is compiled with 64-bit indexing, the result is of class int64,
30888
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
961 otherwise it is of class int32. The maximum array size is slightly smaller
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
962 than the maximum value allowable for the relevant class as reported by
32d2b6604a9f doc: Ensure documentation lists output argument when it exists for functions in libinterp/
Rik <rik@octave.org>
parents: 30564
diff changeset
963 @code{intmax}.
27880
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
964 @seealso{intmax}
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
965 @end deftypefn */)
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
966 {
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
967 if (args.length () != 0)
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
968 print_usage ();
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
969
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
970 return octave_value (octave_int<octave_idx_type> (dim_vector::dim_max ()));
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
971 }
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
972
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
973 /*
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
974 %!assert (sizemax () >= (intmax ("int32") - 1))
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
975
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
976 %!error sizemax (0)
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
977 */
29958
32c3a5805893 move DEFUN and DEFMETHOD functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 29358
diff changeset
978
31605
e88a07dec498 maint: Use macros to begin/end C++ namespaces.
Rik <rik@octave.org>
parents: 30888
diff changeset
979 OCTAVE_END_NAMESPACE(octave)