Mercurial > octave

annotate libinterp/corefcn/bitfcns.cc @ 30390:a61e1a0f6024 stable

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