Mercurial > octave

annotate libinterp/corefcn/bitfcns.cc @ 29358:0a5b15007766 stable

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update Octave Project Developers copyright for the new year In files that have the "Octave Project Developers" copyright notice, update for 2021.
author John W. Eaton <jwe@octave.org>
date Wed, 10 Feb 2021 09:52:15 -0500
parents bd51beb6205e
children 32c3a5805893
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 //
29358
0a5b15007766 update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents: 27923
diff changeset
3 // Copyright (C) 2004-2021 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)
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
54 namespace std
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
55 {
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
56 template <typename T>
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
57 struct bit_and
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
58 {
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
59 public:
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
60 T operator() (const T & op1, const T & op2) const { return (op1 & op2); }
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
61 };
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
62
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
63 template <typename T>
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
64 struct bit_or
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
65 {
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
66 public:
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
67 T operator() (const T & op1, const T & op2) const { return (op1 | op2); }
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
68 };
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
69
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
70 template <typename T>
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
71 struct bit_xor
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
72 {
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
73 public:
14725
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
74 T operator() (const T & op1, const T & op2) const { return (op1 ^ op2); }
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
75 };
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
76 }
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
77 #endif
fa48fd0f160f Add configure check for templated bitwise operators.
Carlo de Falco <cdf@users.sourceforge.net>
parents: 14631
diff changeset
78
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
79 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
80 octave_value
14861
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
81 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
82 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
83 {
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
84 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
85 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
86
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
87 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
88
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
89 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
90 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
91
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
92 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
93
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
94 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
95 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
96 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
97
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
98 Array<T> result;
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
99
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
100 if (nelx != 1)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
101 result.resize (dvx);
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
102 else
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
103 result.resize (dvy);
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
104
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
105 for (int i = 0; i < nelx; i++)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
106 if (is_scalar_op)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
107 for (int k = 0; k < nely; k++)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
108 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
109 else
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
110 result(i) = op (x(i), y(i));
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
111
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
112 return result;
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
113 }
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
114
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
115 // 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
116 // 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
117 // 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
118 // 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
119 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
120 octave_value
14861
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
121 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
122 {
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
123 if (fname == "bitand")
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
124 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
125 if (fname == "bitor")
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
126 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
127
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
128 //else (fname == "bitxor")
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_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
130 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
131
19864
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
132 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
133 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
134 {
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
135 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
136 && 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
137 && 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
138 }
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
139
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
140 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
141 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
142 {
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
143 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
144 }
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 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
147 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
148 {
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
149 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
150 }
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions.
John W. Eaton <jwe@octave.org>
parents: 19697
diff changeset
151
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
152 octave_value
14861
f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory
Rik <octave@nomad.inbox5.com>
parents: 14846
diff changeset
153 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
154 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
155 if (args.length () != 2)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
156 print_usage ();
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
157
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
158 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
159
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
160 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
161 || 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
162 || 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
163 || 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
164 || 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
165 || 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
166 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
167 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
168 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
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_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
171 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
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_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
174 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
175
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
176 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
177 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
178 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
179 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
180 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
181 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
182
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
183 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
184 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
185 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
186 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
187 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
188 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
189
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
190 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
191 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
192 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
193 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
194 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
195 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
196
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
197 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
198 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
199 else
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
200 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
201 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
202 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
203
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
204 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
205 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
206
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
207 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
208 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
209 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
210 else
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
211 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
212 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
213 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
214
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
215 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
216
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
217 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
218 || 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
219 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
220 uint64NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
221 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
222
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
223 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
224 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
225 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
226 || 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
227 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
228 uint32NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
229 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
230
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
231 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
232 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
233 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
234 || 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
235 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
236 uint16NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
237 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
238
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
239 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
240 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
241 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
242 || 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
243 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
244 uint8NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
245 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
246
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
247 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
248 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
249 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
250 || 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
251 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
252 int64NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
253 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
254
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
255 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
256 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
257 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
258 || 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
259 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
260 int32NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
261 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
262
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
263 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
264 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
265 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
266 || 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
267 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
268 int16NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
269 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
270
21568
3d60ed163b70 maint: Eliminate bad spacing around '='.
Rik <rik@octave.org>
parents: 21547
diff changeset
271 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
272 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
273 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
274 || 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
275 {
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
276 int8NDArray x (dx);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
277 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
278
0650b8431037 eliminate more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20486
diff changeset
279 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
280 }
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
281 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
282 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
283 }
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
284 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
285 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
286 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
287 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
288 || 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
289 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
290 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
291 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
292
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
293 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
294 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
295 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
296 || 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
297 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
298 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
299 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
300
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
301 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
302 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
303 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
304 || 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
305 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
306 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
307 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
308
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
309 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
310 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
311 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
312 || 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
313 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
314 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
315 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
316
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
317 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
318 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
319 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
320 || 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
321 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
322 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
323 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
324
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
325 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
326 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
327 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
328 || 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
329 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
330 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
331 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
332
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
333 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
334 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
335 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
336 || 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
337 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
338 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
339 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
340
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
341 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
342 }
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
343 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
344 || 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
345 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
346 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
347 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
348
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
349 retval = bitopx (fname, x, y);
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
350 }
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
351 else
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
352 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
353 }
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: 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
356
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
357 return retval;
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
358 }
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
359
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
360 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
361 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
362 @deftypefn {} {} bitand (@var{x}, @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
363 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
364
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
365 @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
366 @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
367 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
368 {
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
369 return bitop ("bitand", args);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
370 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
371
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
372 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
373 %!# 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
374 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
375
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
376 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
377 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
378 @deftypefn {} {} bitor (@var{x}, @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
379 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
380
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
381 @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
382 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
383 {
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
384 return bitop ("bitor", args);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
385 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
386
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
387 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
388 %!# 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
389 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
390
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
391 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
392 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
393 @deftypefn {} {} bitxor (@var{x}, @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
394 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
395
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
396 @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
397 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
398 {
14631
57e4ff70b7c1 Use more templates in bitwise operators. Death to macros! ☠
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
399 return bitop ("bitxor", args);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
400 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
401
19146
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
402 /*
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
403 %!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
404 %!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
405 %!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
406
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
407 %!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
408 %!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
409 %!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
410
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
411 %!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
412
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
413 %!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
414 %!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
415 %!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
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
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
418 ## 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
419 %!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
420 %!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
421 */
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
422
17389
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
423 template <typename T>
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
424 static int64_t
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
425 max_mantissa_value ()
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
426 {
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
427 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
428 }
dbdff94bf977 Use std::numeric_limits for floating point bit widths
Mike Miller <mtmiller@ieee.org>
parents: 17281
diff changeset
429
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
430 static int64_t
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
431 bitshift (double a, int n, int64_t mask)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
432 {
6108
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
433 // In the name of bug-for-bug compatibility.
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
434 if (a < 0)
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
435 return -bitshift (-a, n, mask);
143b556ce725 [project @ 2006-10-27 01:45:54 by jwe]
jwe
parents: 5828
diff changeset
436
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
437 if (n > 0)
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
438 return (static_cast<int64_t> (a) << n) & mask;
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
439 else if (n < 0)
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
440 return (static_cast<int64_t> (a) >> -n) & mask;
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
441 else
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
442 return static_cast<int64_t> (a) & mask;
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
443 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
444
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
445 static int64_t
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
446 bitshift (float a, int n, int64_t mask)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
447 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
448 // In the name of bug-for-bug compatibility.
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
449 if (a < 0)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
450 return -bitshift (-a, n, mask);
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
451
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
452 if (n > 0)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
453 return (static_cast<int64_t> (a) << n) & mask;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
454 else if (n < 0)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
455 return (static_cast<int64_t> (a) >> -n) & mask;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
456 else
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
457 return static_cast<int64_t> (a) & mask;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
458 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7763
diff changeset
459
4919
a1073eef650c [project @ 2004-07-27 15:22:50 by jwe]
jwe
parents: 4915
diff changeset
460 // 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
461 // 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
462 // shift.
a1073eef650c [project @ 2004-07-27 15:22:50 by jwe]
jwe
parents: 4915
diff changeset
463
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
464 #define DO_BITSHIFT(T) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
465 double d1, d2; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
466 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
467 if (! n.all_integers (d1, d2)) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
468 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
469 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
470 int m_nel = m.numel (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
471 int n_nel = n.numel (); \
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 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
474 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
475 dim_vector m_dv = m.dims (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
476 dim_vector n_dv = n.dims (); \
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 bool is_array_op = (m_dv == n_dv); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
479 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
480 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
481 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
482 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
483 T ## NDArray result; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
484 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
485 if (m_nel != 1) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
486 result.resize (m_dv); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
487 else \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
488 result.resize (n_dv); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
489 \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
490 for (int i = 0; i < m_nel; i++) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
491 if (is_scalar_op) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
492 for (int k = 0; k < n_nel; k++) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
493 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
494 result(i+k) = 0; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
495 else \
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
496 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
497 else \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
498 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
499 result(i) = 0; \
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 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
502 \
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
503 retval = result;
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
504
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
505 #define DO_UBITSHIFT(T, N) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
506 do \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
507 { \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
508 int bits_in_type = octave_ ## T :: nbits (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
509 T ## NDArray m = m_arg.T ## _array_value (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
510 octave_ ## T mask = octave_ ## T::max (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
511 if ((N) < bits_in_type) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
512 mask = bitshift (mask, (N) - bits_in_type); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
513 else if ((N) < 1) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
514 mask = 0; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
515 DO_BITSHIFT (T); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
516 } \
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
517 while (0)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
518
22197
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
519 #define DO_SBITSHIFT(T, N) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
520 do \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
521 { \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
522 int bits_in_type = octave_ ## T :: nbits (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
523 T ## NDArray m = m_arg.T ## _array_value (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
524 octave_ ## T mask = octave_ ## T::max (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
525 if ((N) < bits_in_type) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
526 mask = bitshift (mask, (N) - bits_in_type); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
527 else if ((N) < 1) \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
528 mask = 0; \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
529 /* FIXME: 2's complement only? */ \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
530 mask = mask | octave_ ## T :: min (); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
531 DO_BITSHIFT (T); \
e43d83253e28 refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents: 21966
diff changeset
532 } \
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
533 while (0)
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
534
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
535 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
536 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
537 @deftypefn {} {} bitshift (@var{a}, @var{k})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
538 @deftypefnx {} {} bitshift (@var{a}, @var{k}, @var{n})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
539 Return a @var{k} bit shift of @var{n}-digit unsigned integers in @var{a}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
540
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
541 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
542
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
543 If @var{n} is omitted it defaults to 64.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
544 @var{n} must be in the range [1,64].
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
545
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
546 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
547 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
548 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
549 @result{}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
550 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
551 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
552 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
553 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
554 @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
555
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
556 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
557 @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
558 @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
559 @c
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
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 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
562 @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
563 @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
564 @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
565 @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
566 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
567 {
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
568 int nargin = args.length ();
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
569
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
570 if (nargin < 2 || nargin > 3)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
571 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
572
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
573 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
574
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
575 int nbits = 64;
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
576
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
577 if (nargin == 3)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
578 {
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
579 // 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
580 // as the third argument.
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
581 if (args(2).numel () > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
582 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
583
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
584 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
585
20980
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
586 if (nbits < 0)
81c2b14c209f maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents: 20918
diff changeset
587 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
588 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
589
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
590 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
591
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
592 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
593 std::string cname = m_arg.class_name ();
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
594
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
595 if (cname == "double")
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
596 {
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
597 static const int bits_in_mantissa
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
598 = std::numeric_limits<double>::digits;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
599
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
600 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
601 int64_t mask = max_mantissa_value<double> ();
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
602 if (nbits < bits_in_mantissa)
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
603 mask = mask >> (bits_in_mantissa - nbits);
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
604 int bits_in_type = sizeof (double)
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22323
diff changeset
605 * std::numeric_limits<unsigned char>::digits;
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
606 NDArray m = m_arg.array_value ();
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
607 DO_BITSHIFT ();
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
608 }
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
609 else if (cname == "uint8")
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
610 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
611 else if (cname == "uint16")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
612 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
613 else if (cname == "uint32")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
614 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
615 else if (cname == "uint64")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
616 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
617 else if (cname == "int8")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
618 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
619 else if (cname == "int16")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
620 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
621 else if (cname == "int32")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
622 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
623 else if (cname == "int64")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
624 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
625 else if (cname == "single")
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
626 {
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
627 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
628 = std::numeric_limits<float>::digits;
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
629 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
630 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
631 if (nbits < bits_in_mantissa)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
632 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
633 int bits_in_type = sizeof (float)
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22323
diff changeset
634 * 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
635 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
636 DO_BITSHIFT (Float);
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
637 }
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
638 else
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
639 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
640
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
641 return retval;
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
19146
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
644 /*
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
645 %!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
646 %!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
647 %!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
648 %!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
649 %!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
650
20711
7b608fadc663 Make error messages more specific about the variable and problem encountered.
Rik <rik@octave.org>
parents: 20704
diff changeset
651 %!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
652 %!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
653 %!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
654 %!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
655 */
a84f0182f912 bitfcns.cc: add tests for bitwise operators (some of them failing).
Carnë Draug <carandraug@octave.org>
parents: 18678
diff changeset
656
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
657 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
658 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
659 @deftypefn {} {} flintmax ()
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
660 @deftypefnx {} {} flintmax ("double")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
661 @deftypefnx {} {} flintmax ("single")
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
662 @deftypefnx {} {} 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
663 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
664 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
665
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
666 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
667 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
668
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
669 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
670 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
671 @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
672
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
673 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
674
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
675 @example
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
676 @group
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
677 x = single (1);
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
678 flintmax (x)
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
679 @result{} 16777216
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
680 @end group
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
681 @end example
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
682
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
683 @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
684 @end deftypefn */)
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
685 {
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
686 int nargin = args.length ();
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
687
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
688 if (nargin > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
689 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
690
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
691 std::string cname = "double";
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
692 if (nargin == 1)
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
693 {
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
694 if (args(0).is_string ())
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
695 cname = args(0).string_value ();
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
696 else if (args(0).isfloat ())
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
697 cname = args(0).class_name ();
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
698 else
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
699 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
700 }
17390
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
701
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
702 if (cname == "double")
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
703 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
704 else if (cname == "single")
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
705 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
706 else
4bcd301754ce Add Matlab-compatible flintmax function
Mike Miller <mtmiller@ieee.org>
parents: 17389
diff changeset
707 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
708 }
16939
06897f865f0b Add flintmax() as an alias for function bitmax().
Rik <rik@octave.org>
parents: 15195
diff changeset
709
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
710 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
711 %!assert (flintmax (), 2^53)
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
712 %!assert (flintmax ("double"), 2^53)
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
713 %!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
714
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
715 %!test
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
716 %! x = single (1);
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
717 %! assert (flintmax (x), single (16777216));
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
718
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
719 %!error flintmax ("double", 0)
26057
afc3d1da58e5 Expand flintmax to accept a floating point variable as input.
Rik <rik@octave.org>
parents: 26056
diff changeset
720 %!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
721 %!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
722 %!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
723 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
724
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
725 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
726 doc: /* -*- texinfo -*-
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
727 @deftypefn {} {} intmax ()
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
728 @deftypefnx {} {} intmax ("@var{type}")
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
729 @deftypefnx {} {} intmax (@var{var})
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
730 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
731
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
732 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
733 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
734
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
735 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
736
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
737 @table @asis
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
738 @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
739 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
740
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
741 @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
742 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
743
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
744 @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
745 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
746
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
747 @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
748 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
749
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
750 @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
751 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
752
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
753 @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
754 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
755
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
756 @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
757 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
758
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
759 @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
760 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
761 @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
762
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
763 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
764
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
765 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
766
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
767 @example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
768 @group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
769 x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
770 intmax (x)
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
771 @result{} 127
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
772 @end group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
773 @end example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
774
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
775 @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
776 @end deftypefn */)
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
777 {
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
778 int nargin = args.length ();
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
779
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
780 if (nargin > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
781 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
782
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
783 std::string cname = "int32";
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
784 if (nargin == 1)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
785 {
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
786 if (args(0).is_string ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
787 cname = args(0).string_value ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
788 else if (args(0).isinteger ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
789 cname = args(0).class_name ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
790 else
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
791 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
792 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
793
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
794 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
795
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
796 if (cname == "uint8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
797 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
798 else if (cname == "uint16")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
799 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
800 else if (cname == "uint32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
801 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
802 else if (cname == "uint64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
803 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
804 else if (cname == "int8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
805 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
806 else if (cname == "int16")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
807 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
808 else if (cname == "int32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
809 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
810 else if (cname == "int64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
811 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
812 else
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
813 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
814
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
815 return retval;
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
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
818 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
819 %!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
820 %!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
821 %!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
822 %!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
823 %!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
824 %!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
825 %!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
826 %!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
827 %!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
828
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
829 %!test
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
830 %! x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
831 %! assert (intmax (x), int8 (127));
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
832
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
833 %!error intmax ("int32", 0)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
834 %!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
835 %!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
836 %!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
837 */
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
838
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
839 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
840 doc: /* -*- texinfo -*-
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
841 @deftypefn {} {} intmin ()
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
842 @deftypefnx {} {} intmin ("@var{type}")
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
843 @deftypefnx {} {} intmin (@var{var})
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
844 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
845
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
846 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
847 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
848
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
849 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
850
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
851 @table @asis
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
852 @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
853 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
854
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
855 @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
856 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
857
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
858 @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
859 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
860
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
861 @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
862 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
863
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
864 @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
865 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
866
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
867 @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
868 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
869
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
870 @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
871 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
872
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
873 @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
874 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
875 @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
876
26051
aa1064eca173 Improve documentation for intmax/intmin (bug #54866).
Rik <rik@octave.org>
parents: 25054
diff changeset
877 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
878
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
879 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
880
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
881 @example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
882 @group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
883 x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
884 intmin (x)
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
885 @result{} -128
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
886 @end group
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
887 @end example
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
888
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21751
diff changeset
889 @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
890 @end deftypefn */)
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
891 {
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
892 int nargin = args.length ();
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
893
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
894 if (nargin > 1)
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
895 print_usage ();
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
896
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
897 std::string cname = "int32";
20804
a6eaedd8bd75 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20791
diff changeset
898 if (nargin == 1)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
899 {
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
900 if (args(0).is_string ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
901 cname = args(0).string_value ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
902 else if (args(0).isinteger ())
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
903 cname = args(0).class_name ();
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
904 else
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
905 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
906 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
907
20918
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
908 octave_value retval;
6f0bd96f93c0 maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents: 20870
diff changeset
909
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
910 if (cname == "uint8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
911 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
912 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
913 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
914 else if (cname == "uint32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
915 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
916 else if (cname == "uint64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
917 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
918 else if (cname == "int8")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
919 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
920 else if (cname == "int16")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
921 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
922 else if (cname == "int32")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
923 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
924 else if (cname == "int64")
5828
22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe]
jwe
parents: 5823
diff changeset
925 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
926 else
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4908
diff changeset
927 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
928
4908
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
929 return retval;
66af4b9f451e [project @ 2004-06-29 19:20:00 by jwe]
jwe
parents:
diff changeset
930 }
10811
e38c071bbc41 allow user query the maximum array size
Jaroslav Hajek <highegg@gmail.com>
parents: 10315
diff changeset
931
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
932 /*
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
933 %!assert (intmin (), int32 (-2^31))
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
934 %!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
935 %!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
936 %!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
937 %!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
938 %!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
939 %!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
940 %!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
941 %!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
942
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
943 %!test
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
944 %! x = int8 (1);
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
945 %! assert (intmin (x), int8 (-128));
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
946
20870
020b71557b12 2015 Code Sprint: add BIST tests to bitfcns.cc
Mike Miller <mtmiller@octave.org>
parents: 20853
diff changeset
947 %!error intmin ("int32", 0)
26056
df3f2e119944 Expand intmax/intmin to accept an integer variable as input.
Rik <rik@octave.org>
parents: 26051
diff changeset
948 %!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
949 %!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
950 %!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
951 */
27880
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
952
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
953 DEFUN (sizemax, args, ,
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
954 doc: /* -*- texinfo -*-
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
955 @deftypefn {} {} sizemax ()
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
956 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
957
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
958 If Octave is compiled with 64-bit indexing, the result is of class int64,
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
959 otherwise it is of class int32. The maximum array size is slightly
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
960 smaller than the maximum value allowable for the relevant class as reported
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
961 by @code{intmax}.
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
962 @seealso{intmax}
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
963 @end deftypefn */)
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
964 {
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
965 if (args.length () != 0)
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
966 print_usage ();
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
967
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
968 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
969 }
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
970
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 %!assert (sizemax () >= (intmax ("int32") - 1))
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 %!error sizemax (0)
31b95261c7d2 Backed out changeset 2890a931e647 (bug #47469)
Rik <rik@octave.org>
parents: 27627
diff changeset
975 */