Mercurial > octave
annotate libinterp/corefcn/typecast.cc @ 29359:7854d5752dd2
maint: merge stable to default.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Wed, 10 Feb 2021 10:10:40 -0500 |
parents | 06c8e0877864 0a5b15007766 |
children | 7faff48840eb |
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) 2007-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 //////////////////////////////////////////////////////////////////////// |
6869 | 25 |
21724
aba2e6293dd8
use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents:
21660
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" |
6869 | 28 #endif |
29 | |
25621
0fa7312e34bc
Accept case insensitive second argument to typecast for Matlab compatibility (bug #54313).
Rik <rik@octave.org>
parents:
25088
diff
changeset
|
30 #include <algorithm> |
17396 | 31 #include <limits> |
15289
27bdffcb41c5
*typecast.cc: Include <climits> for CHAR_BIT.
Júlio Hoffimann <julio.hoffimann@gmail.com>
parents:
15195
diff
changeset
|
32 |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
33 #include "mx-base.h" |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
34 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14360
diff
changeset
|
35 #include "defun.h" |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
36 #include "error.h" |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
20982
diff
changeset
|
37 #include "errwarn.h" |
20940
48b2ad5ee801
maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents:
20939
diff
changeset
|
38 #include "ovl.h" |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
39 #include "unwind-prot.h" |
6869 | 40 |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
41 static dim_vector |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
42 get_vec_dims (const dim_vector& old_dims, octave_idx_type n) |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
43 { |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21389
diff
changeset
|
44 if (old_dims.ndims () == 2 && old_dims(0) == 1) |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
45 return dim_vector (1, n); |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21389
diff
changeset
|
46 else if (old_dims.ndims () == 2 && old_dims(0) == 0 && old_dims(1) == 0) |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
47 return dim_vector (); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
48 else |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
49 return dim_vector (n, 1); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
50 } |
6869 | 51 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21100
diff
changeset
|
52 template <typename ArrayType> |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11572
diff
changeset
|
53 static void |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
54 get_data_and_bytesize (const ArrayType& array, |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
55 const void *& data, |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
56 octave_idx_type& byte_size, |
10066
2cd940306a06
make unwind_protect frames local
Jaroslav Hajek <highegg@gmail.com>
parents:
9758
diff
changeset
|
57 dim_vector& old_dims, |
21743
f4d7d0eb5b0c
use namespace for unwind_protect class
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
58 octave::unwind_protect& frame) |
6869 | 59 { |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
60 // The array given may be a temporary, constructed from a scalar or sparse |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21743
diff
changeset
|
61 // array. This will ensure the data will be deallocated after we exit. |
10066
2cd940306a06
make unwind_protect frames local
Jaroslav Hajek <highegg@gmail.com>
parents:
9758
diff
changeset
|
62 frame.add_delete (new ArrayType (array)); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
63 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
64 data = reinterpret_cast<const void *> (array.data ()); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
65 byte_size = array.byte_size (); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
66 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
67 old_dims = array.dims (); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
68 } |
6869 | 69 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21100
diff
changeset
|
70 template <typename ArrayType> |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
71 static ArrayType |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
72 reinterpret_copy (const void *data, octave_idx_type byte_size, |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
73 const dim_vector& old_dims) |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
74 { |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
75 typedef typename ArrayType::element_type T; |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
76 octave_idx_type n = byte_size / sizeof (T); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
77 |
20982
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
78 if (n * static_cast<int> (sizeof (T)) != byte_size) |
20831
35241c4b696c
eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents:
20800
diff
changeset
|
79 error ("typecast: incorrect number of input values to make output value"); |
35241c4b696c
eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents:
20800
diff
changeset
|
80 |
20982
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
81 ArrayType retval (get_vec_dims (old_dims, n)); |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
82 T *dest = retval.fortran_vec (); |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
83 std::memcpy (dest, data, n * sizeof (T)); |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
84 |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
85 return retval; |
6869 | 86 } |
87 | |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
88 template <typename ArrayType> |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
89 static ArrayType |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
90 reinterpret_int_copy (const void *data, octave_idx_type byte_size, |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
91 const dim_vector& old_dims) |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
92 { |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
93 typedef typename ArrayType::element_type T; |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
94 typedef typename T::val_type VT; |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
95 octave_idx_type n = byte_size / sizeof (T); |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
96 |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
97 if (n * static_cast<int> (sizeof (T)) != byte_size) |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
98 error ("typecast: incorrect number of input values to make output value"); |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
99 |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
100 ArrayType retval (get_vec_dims (old_dims, n)); |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
101 VT *dest = reinterpret_cast<VT *> (retval.fortran_vec ()); |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
102 std::memcpy (dest, data, n * sizeof (VT)); |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
103 |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
104 return retval; |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
105 } |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
106 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14360
diff
changeset
|
107 DEFUN (typecast, 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
|
108 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
|
109 @deftypefn {} {@var{y} =} typecast (@var{x}, "@var{class}") |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
110 Return a new array @var{y} resulting from interpreting the data of @var{x} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
111 in memory as data of the numeric class @var{class}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
112 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
113 Both the class of @var{x} and @var{class} must be one of the built-in |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
114 numeric classes: |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
115 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
116 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
117 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
118 "logical" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
119 "char" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
120 "int8" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
121 "int16" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
122 "int32" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
123 "int64" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
124 "uint8" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
125 "uint16" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
126 "uint32" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
127 "uint64" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
128 "double" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
129 "single" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
130 "double complex" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
131 "single complex" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
132 @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
|
133 @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
|
134 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
135 @noindent |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
136 the last two are only used with @var{class}; they indicate that a |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
137 complex-valued result is requested. Complex arrays are stored in memory as |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
138 consecutive pairs of real numbers. The sizes of integer types are given by |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
139 their bit counts. Both logical and char are typically one byte wide; |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
140 however, this is not guaranteed by C++. If your system is IEEE conformant, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
141 single and double will be 4 bytes and 8 bytes wide, respectively. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
142 @qcode{"logical"} is not allowed for @var{class}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
143 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
144 If the input is a row vector, the return value is a row vector, otherwise it |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
145 is a column vector. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
146 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
147 If the bit length of @var{x} is not divisible by that of @var{class}, an |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
148 error occurs. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
149 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
150 An example of the use of typecast on a little-endian machine is |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
151 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
152 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
153 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
154 @var{x} = uint16 ([1, 65535]); |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
155 typecast (@var{x}, "uint8") |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
156 @result{} [ 1, 0, 255, 255] |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
157 @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
|
158 @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
|
159 @seealso{cast, bitpack, bitunpack, swapbytes} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
160 @end deftypefn */) |
6869 | 161 { |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
162 if (args.length () != 2) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
163 print_usage (); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
164 |
20939
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
165 octave_value retval; |
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
166 |
21743
f4d7d0eb5b0c
use namespace for unwind_protect class
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
167 octave::unwind_protect frame; |
20939
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
168 |
23457
21baad6b35c4
maint: Use C++11 nullptr rather than 0 or NULL when possible.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
169 const void *data = nullptr; |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
170 octave_idx_type byte_size = 0; |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
171 dim_vector old_dims; |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
172 |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
173 octave_value array = args(0); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
174 |
23579
c20a0fa91c0c
maint: Deprecate is_bool_type and replace with islogical.
Rik <rik@octave.org>
parents:
23457
diff
changeset
|
175 if (array.islogical ()) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
176 get_data_and_bytesize (array.bool_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
177 old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
178 else if (array.is_string ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
179 get_data_and_bytesize (array.char_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
180 old_dims, frame); |
23580
2230f9e10fb3
maint: Deprecate is_integer_type and replace with isinteger.
Rik <rik@octave.org>
parents:
23579
diff
changeset
|
181 else if (array.isinteger ()) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
182 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
183 if (array.is_int8_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
184 get_data_and_bytesize (array.int8_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
185 old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
186 else if (array.is_int16_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
187 get_data_and_bytesize (array.int16_array_value (), data, byte_size, |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
188 old_dims, frame); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
189 else if (array.is_int32_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
190 get_data_and_bytesize (array.int32_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
191 old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
192 else if (array.is_int64_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
193 get_data_and_bytesize (array.int64_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
194 old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
195 else if (array.is_uint8_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
196 get_data_and_bytesize (array.uint8_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
197 old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
198 else if (array.is_uint16_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
199 get_data_and_bytesize (array.uint16_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
200 old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
201 else if (array.is_uint32_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
202 get_data_and_bytesize (array.uint32_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
203 old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
204 else if (array.is_uint64_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
205 get_data_and_bytesize (array.uint64_array_value (), data, byte_size, |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
206 old_dims, frame); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
207 else |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
208 assert (0); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
209 } |
23581
c3075ae020e1
maint: Deprecate is_complex_type and replace with iscomplex.
Rik <rik@octave.org>
parents:
23580
diff
changeset
|
210 else if (array.iscomplex ()) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
211 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
212 if (array.is_single_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
213 get_data_and_bytesize (array.float_complex_array_value (), data, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
214 byte_size, old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
215 else |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
216 get_data_and_bytesize (array.complex_array_value (), data, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
217 byte_size, old_dims, frame); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
218 } |
23582
0cc2011d800e
maint: Deprecate is_real_type and replace with isreal.
Rik <rik@octave.org>
parents:
23581
diff
changeset
|
219 else if (array.isreal ()) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
220 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
221 if (array.is_single_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
222 get_data_and_bytesize (array.float_array_value (), data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
223 old_dims, frame); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
224 else |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
225 get_data_and_bytesize (array.array_value (), data, byte_size, |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
226 old_dims, frame); |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
227 } |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
228 else |
22778
093b49ac544e
maint: Capitalize variable names appearing in error() messages of C++ files.
Rik <rik@octave.org>
parents:
22755
diff
changeset
|
229 error ("typecast: invalid input CLASS: %s", |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
230 array.class_name ().c_str ()); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
231 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
232 std::string numclass = args(1).string_value (); |
25621
0fa7312e34bc
Accept case insensitive second argument to typecast for Matlab compatibility (bug #54313).
Rik <rik@octave.org>
parents:
25088
diff
changeset
|
233 std::transform (numclass.begin (), numclass.end (), numclass.begin (), |
0fa7312e34bc
Accept case insensitive second argument to typecast for Matlab compatibility (bug #54313).
Rik <rik@octave.org>
parents:
25088
diff
changeset
|
234 tolower); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
235 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
236 if (numclass.size () == 0) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
237 ; |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
238 else if (numclass == "char") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
239 retval = octave_value (reinterpret_copy<charNDArray> |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
240 (data, byte_size, old_dims), array.is_dq_string () ? '"' |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
241 : '\''); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
242 else if (numclass[0] == 'i') |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
243 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
244 if (numclass == "int8") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
245 retval = reinterpret_int_copy<int8NDArray> (data, byte_size, old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
246 else if (numclass == "int16") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
247 retval = reinterpret_int_copy<int16NDArray> (data, byte_size, old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
248 else if (numclass == "int32") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
249 retval = reinterpret_int_copy<int32NDArray> (data, byte_size, old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
250 else if (numclass == "int64") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
251 retval = reinterpret_int_copy<int64NDArray> (data, byte_size, old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
252 } |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
253 else if (numclass[0] == 'u') |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
254 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
255 if (numclass == "uint8") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
256 retval = reinterpret_int_copy<uint8NDArray> (data, byte_size, old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
257 else if (numclass == "uint16") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
258 retval = reinterpret_int_copy<uint16NDArray> (data, byte_size, |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
259 old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
260 else if (numclass == "uint32") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
261 retval = reinterpret_int_copy<uint32NDArray> (data, byte_size, |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
262 old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
263 else if (numclass == "uint64") |
25088
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
264 retval = reinterpret_int_copy<uint64NDArray> (data, byte_size, |
56e888cd8298
avoid cast warnings from GCC 8 (bug #53544)
John W. Eaton <jwe@octave.org>
parents:
25054
diff
changeset
|
265 old_dims); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
266 } |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
267 else if (numclass == "single") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
268 retval = reinterpret_copy<FloatNDArray> (data, byte_size, old_dims); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
269 else if (numclass == "double") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
270 retval = reinterpret_copy<NDArray> (data, byte_size, old_dims); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
271 else if (numclass == "single complex") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
272 retval = reinterpret_copy<FloatComplexNDArray> (data, byte_size, |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
273 old_dims); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
274 else if (numclass == "double complex") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
275 retval = reinterpret_copy<ComplexNDArray> (data, byte_size, old_dims); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
276 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
277 if (retval.is_undefined ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
278 error ("typecast: cannot convert to %s class", numclass.c_str ()); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
279 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
280 return retval; |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
281 } |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
282 |
21389
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
283 /* |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
284 %!assert (typecast (int64 (0), "char"), char (zeros (1, 8))) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
285 %!assert (typecast (int64 (0), "int8"), zeros (1, 8, "int8")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
286 %!assert (typecast (int64 (0), "uint8"), zeros (1, 8, "uint8")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
287 %!assert (typecast (int64 (0), "int16"), zeros (1, 4, "int16")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
288 %!assert (typecast (int64 (0), "uint16"), zeros (1, 4, "uint16")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
289 %!assert (typecast (int64 (0), "int32"), zeros (1, 2, "int32")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
290 %!assert (typecast (int64 (0), "uint32"), zeros (1, 2, "uint32")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
291 %!assert (typecast (int64 (0), "int64"), zeros (1, 1, "int64")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
292 %!assert (typecast (int64 (0), "uint64"), zeros (1, 1, "uint64")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
293 %!assert (typecast (int64 (0), "single"), zeros (1, 2, "single")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
294 %!assert (typecast (int64 (0), "double"), 0) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
295 %!assert (typecast (int64 (0), "single complex"), single (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
296 %!assert (typecast (int64 ([0 0]), "double complex"), 0) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
297 |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
298 %!assert (typecast ([], "double"), []) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
299 %!assert (typecast (0, "double"), 0) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
300 %!assert (typecast (inf, "double"), inf) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
301 %!assert (typecast (-inf, "double"), -inf) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
302 %!assert (typecast (nan, "double"), nan) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
303 |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
304 %!error typecast () |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
305 %!error typecast (1) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
306 %!error typecast (1, 2, 3) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
307 %!error typecast (1, "invalid") |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
308 %!error typecast (int8 (0), "double") |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
309 */ |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
310 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21100
diff
changeset
|
311 template <typename ArrayType> |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
312 ArrayType |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
313 do_bitpack (const boolNDArray& bitp) |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
314 { |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
315 typedef typename ArrayType::element_type T; |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
316 octave_idx_type n |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
317 = bitp.numel () / (sizeof (T) * std::numeric_limits<unsigned char>::digits); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
318 |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
319 if (n * static_cast<int> (sizeof (T)) * |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
320 std::numeric_limits<unsigned char>::digits != bitp.numel ()) |
20831
35241c4b696c
eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents:
20800
diff
changeset
|
321 error ("bitpack: incorrect number of bits to make up output value"); |
35241c4b696c
eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents:
20800
diff
changeset
|
322 |
20982
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
323 ArrayType retval (get_vec_dims (bitp.dims (), n)); |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
324 |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
325 const bool *bits = bitp.fortran_vec (); |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
326 char *packed = reinterpret_cast<char *> (retval.fortran_vec ()); |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
327 |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
328 octave_idx_type m = n * sizeof (T); |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
329 |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
330 for (octave_idx_type i = 0; i < m; i++) |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
331 { |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
332 char c = bits[0]; |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
333 for (int j = 1; j < std::numeric_limits<unsigned char>::digits; j++) |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
334 c |= bits[j] << j; |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
335 |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
336 packed[i] = c; |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
337 bits += std::numeric_limits<unsigned char>::digits; |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
338 } |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
339 |
d27f66b4b8e6
maint: invert if/else/error instances.
John W. Eaton <jwe@octave.org>
parents:
20940
diff
changeset
|
340 return retval; |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
341 } |
6869 | 342 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14360
diff
changeset
|
343 DEFUN (bitpack, 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
|
344 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
|
345 @deftypefn {} {@var{y} =} bitpack (@var{x}, @var{class}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
346 Return a new array @var{y} resulting from interpreting the logical array |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
347 @var{x} as raw bit patterns for data of the numeric class @var{class}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
348 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
349 @var{class} must be one of the built-in numeric classes: |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
350 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
351 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
352 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
353 "double" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
354 "single" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
355 "double complex" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
356 "single complex" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
357 "char" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
358 "int8" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
359 "int16" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
360 "int32" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
361 "int64" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
362 "uint8" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
363 "uint16" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
364 "uint32" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
365 "uint64" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
366 @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
|
367 @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
|
368 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
369 The number of elements of @var{x} should be divisible by the bit length of |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
370 @var{class}. If it is not, excess bits are discarded. Bits come in |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
371 increasing order of significance, i.e., @code{x(1)} is bit 0, @code{x(2)} is |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
372 bit 1, etc. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
373 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
374 The result is a row vector if @var{x} is a row vector, otherwise it is a |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
375 column vector. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
376 @seealso{bitunpack, typecast} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
377 @end deftypefn */) |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
378 { |
19174
6f3e922c5197
doc: Improve docstrings for typecast, bitpack, bitunpack.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
379 if (args.length () != 2) |
6f3e922c5197
doc: Improve docstrings for typecast, bitpack, bitunpack.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
380 print_usage (); |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
381 |
23579
c20a0fa91c0c
maint: Deprecate is_bool_type and replace with islogical.
Rik <rik@octave.org>
parents:
23457
diff
changeset
|
382 if (! args(0).islogical ()) |
19174
6f3e922c5197
doc: Improve docstrings for typecast, bitpack, bitunpack.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
383 error ("bitpack: X must be a logical array"); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
384 |
20939
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
385 octave_value retval; |
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
386 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
387 boolNDArray bitp = args(0).bool_array_value (); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
388 |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
389 std::string numclass = args(1).string_value (); |
6869 | 390 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
391 if (numclass.size () == 0) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
392 ; |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
393 else if (numclass == "char") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
394 retval = octave_value (do_bitpack<charNDArray> (bitp), '\''); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
395 else if (numclass[0] == 'i') |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
396 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
397 if (numclass == "int8") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
398 retval = do_bitpack<int8NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
399 else if (numclass == "int16") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
400 retval = do_bitpack<int16NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
401 else if (numclass == "int32") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
402 retval = do_bitpack<int32NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
403 else if (numclass == "int64") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
404 retval = do_bitpack<int64NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
405 } |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
406 else if (numclass[0] == 'u') |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
407 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
408 if (numclass == "uint8") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
409 retval = do_bitpack<uint8NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
410 else if (numclass == "uint16") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
411 retval = do_bitpack<uint16NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
412 else if (numclass == "uint32") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
413 retval = do_bitpack<uint32NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
414 else if (numclass == "uint64") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
415 retval = do_bitpack<uint64NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
416 } |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
417 else if (numclass == "single") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
418 retval = do_bitpack<FloatNDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
419 else if (numclass == "double") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
420 retval = do_bitpack<NDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
421 else if (numclass == "single complex") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
422 retval = do_bitpack<FloatComplexNDArray> (bitp); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
423 else if (numclass == "double complex") |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
424 retval = do_bitpack<ComplexNDArray> (bitp); |
6869 | 425 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
426 if (retval.is_undefined ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
427 error ("bitpack: cannot pack to %s class", numclass.c_str ()); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
428 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
429 return retval; |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
430 } |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
431 |
21389
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
432 /* |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
433 %!assert (bitpack (zeros (1, 8, "logical"), "char"), "\0") |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
434 %!assert (bitpack (zeros (1, 8, "logical"), "int8"), int8 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
435 %!assert (bitpack (zeros (1, 8, "logical"), "uint8"), uint8 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
436 %!assert (bitpack (zeros (1, 16, "logical"), "int16"), int16 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
437 %!assert (bitpack (zeros (1, 16, "logical"), "uint16"), uint16 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
438 %!assert (bitpack (zeros (1, 32, "logical"), "int32"), int32 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
439 %!assert (bitpack (zeros (1, 32, "logical"), "uint32"), uint32 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
440 %!assert (bitpack (zeros (1, 64, "logical"), "int64"), int64 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
441 %!assert (bitpack (zeros (1, 64, "logical"), "uint64"), uint64 (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
442 %!assert (bitpack (zeros (1, 32, "logical"), "single"), single (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
443 %!assert (bitpack (zeros (1, 64, "logical"), "double"), double (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
444 %!assert (bitpack (zeros (1, 64, "logical"), "single complex"), single (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
445 %!assert (bitpack (zeros (1, 128, "logical"), "double complex"), double (0)) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
446 |
26049
09665529b6ba
Add a BIST test for bitpack (bug #54931).
Rik <rik@octave.org>
parents:
25621
diff
changeset
|
447 %!test <54931> |
09665529b6ba
Add a BIST test for bitpack (bug #54931).
Rik <rik@octave.org>
parents:
25621
diff
changeset
|
448 %! x = false (1, 32); |
09665529b6ba
Add a BIST test for bitpack (bug #54931).
Rik <rik@octave.org>
parents:
25621
diff
changeset
|
449 %! x(1) = true; |
09665529b6ba
Add a BIST test for bitpack (bug #54931).
Rik <rik@octave.org>
parents:
25621
diff
changeset
|
450 %! assert (bitpack (x, "uint32"), uint32 (1)); |
09665529b6ba
Add a BIST test for bitpack (bug #54931).
Rik <rik@octave.org>
parents:
25621
diff
changeset
|
451 %! x([1, 9]) = true; |
09665529b6ba
Add a BIST test for bitpack (bug #54931).
Rik <rik@octave.org>
parents:
25621
diff
changeset
|
452 %! assert (bitpack (x, "uint32"), uint32 (257)); |
09665529b6ba
Add a BIST test for bitpack (bug #54931).
Rik <rik@octave.org>
parents:
25621
diff
changeset
|
453 |
21389
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
454 %!error bitpack () |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
455 %!error bitpack (1) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
456 %!error bitpack (1, 2, 3) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
457 %!error bitpack (1, "invalid") |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
458 %!error bitpack (1, "double") |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
459 %!error bitpack (false, "invalid") |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
460 %!error bitpack (false, "double") |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
461 */ |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
462 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21100
diff
changeset
|
463 template <typename ArrayType> |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
464 boolNDArray |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
465 do_bitunpack (const ArrayType& array) |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
466 { |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
467 typedef typename ArrayType::element_type T; |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
468 octave_idx_type n = array.numel () * sizeof (T) |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
469 * std::numeric_limits<unsigned char>::digits; |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
470 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
471 boolNDArray retval (get_vec_dims (array.dims (), n)); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
472 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
473 const char *packed = reinterpret_cast<const char *> (array.fortran_vec ()); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
474 bool *bits = retval.fortran_vec (); |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
475 |
17396 | 476 octave_idx_type m = n / std::numeric_limits<unsigned char>::digits; |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
477 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
478 for (octave_idx_type i = 0; i < m; i++) |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
479 { |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
480 char c = packed[i]; |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
481 bits[0] = c & 1; |
17396 | 482 for (int j = 1; j < std::numeric_limits<unsigned char>::digits; j++) |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
483 bits[j] = (c >>= 1) & 1; |
17396 | 484 bits += std::numeric_limits<unsigned char>::digits; |
6869 | 485 } |
486 | |
487 return retval; | |
488 } | |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
489 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14360
diff
changeset
|
490 DEFUN (bitunpack, 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
|
491 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
|
492 @deftypefn {} {@var{y} =} bitunpack (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
493 Return a logical array @var{y} corresponding to the raw bit patterns of |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
494 @var{x}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
495 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
496 @var{x} must belong to one of the built-in numeric classes: |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
497 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
498 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
499 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
500 "double" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
501 "single" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
502 "char" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
503 "int8" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
504 "int16" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
505 "int32" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
506 "int64" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
507 "uint8" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
508 "uint16" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
509 "uint32" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
510 "uint64" |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
511 @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
|
512 @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
|
513 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
514 The result is a row vector if @var{x} is a row vector; otherwise, it is a |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
515 column vector. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
516 @seealso{bitpack, typecast} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
517 @end deftypefn */) |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
518 { |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
519 if (args.length () != 1) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
520 print_usage (); |
20921
4d3daf7e43f3
eliminate trailing whitespace in source files
John W. Eaton <jwe@octave.org>
parents:
20853
diff
changeset
|
521 |
23586
f6c5db0a02e7
maint: Deprecate is_numeric_type and replace with isnumeric.
Rik <rik@octave.org>
parents:
23582
diff
changeset
|
522 if (! (args(0).isnumeric () || args(0).is_string ())) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
523 error ("bitunpack: argument must be a number or a string"); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
524 |
20939
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
525 octave_value retval; |
b17fda023ca6
maint: Use new C++ archetype in more files.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
526 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
527 octave_value array = args(0); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
528 |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
529 if (array.is_string ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
530 retval = do_bitunpack (array.char_array_value ()); |
23580
2230f9e10fb3
maint: Deprecate is_integer_type and replace with isinteger.
Rik <rik@octave.org>
parents:
23579
diff
changeset
|
531 else if (array.isinteger ()) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
532 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
533 if (array.is_int8_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
534 retval = do_bitunpack (array.int8_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
535 else if (array.is_int16_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
536 retval = do_bitunpack (array.int16_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
537 else if (array.is_int32_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
538 retval = do_bitunpack (array.int32_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
539 else if (array.is_int64_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
540 retval = do_bitunpack (array.int64_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
541 else if (array.is_uint8_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
542 retval = do_bitunpack (array.uint8_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
543 else if (array.is_uint16_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
544 retval = do_bitunpack (array.uint16_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
545 else if (array.is_uint32_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
546 retval = do_bitunpack (array.uint32_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
547 else if (array.is_uint64_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
548 retval = do_bitunpack (array.uint64_array_value ()); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
549 else |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
550 assert (0); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
551 } |
23581
c3075ae020e1
maint: Deprecate is_complex_type and replace with iscomplex.
Rik <rik@octave.org>
parents:
23580
diff
changeset
|
552 else if (array.iscomplex ()) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
553 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
554 if (array.is_single_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
555 retval = do_bitunpack (array.float_complex_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
556 else |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
557 retval = do_bitunpack (array.complex_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
558 } |
23582
0cc2011d800e
maint: Deprecate is_real_type and replace with isreal.
Rik <rik@octave.org>
parents:
23581
diff
changeset
|
559 else if (array.isreal ()) |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
560 { |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
561 if (array.is_single_type ()) |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
562 retval = do_bitunpack (array.float_array_value ()); |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
563 else |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
564 retval = do_bitunpack (array.array_value ()); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
565 } |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
566 else |
20800
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
567 error ("bitunpack: invalid input class: %s", |
fb128aafc322
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
568 array.class_name ().c_str ()); |
9671
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
569 |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
570 return retval; |
e4b383a0effa
merge reinterpret.cc into typecast.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9036
diff
changeset
|
571 } |
21389
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
572 |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
573 /* |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
574 %!assert (bitunpack ("\0"), zeros (1, 8, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
575 %!assert (bitunpack (int8 (0)), zeros (1, 8, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
576 %!assert (bitunpack (uint8 (0)), zeros (1, 8, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
577 %!assert (bitunpack (int16 (0)), zeros (1, 16, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
578 %!assert (bitunpack (uint16 (0)), zeros (1, 16, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
579 %!assert (bitunpack (int32 (0)), zeros (1, 32, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
580 %!assert (bitunpack (uint32 (0)), zeros (1, 32, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
581 %!assert (bitunpack (int64 (0)), zeros (1, 64, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
582 %!assert (bitunpack (uint64 (0)), zeros (1, 64, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
583 %!assert (bitunpack (single (0)), zeros (1, 32, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
584 %!assert (bitunpack (double (0)), zeros (1, 64, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
585 %!assert (bitunpack (complex (single (0))), zeros (1, 64, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
586 %!assert (bitunpack (complex (double (0))), zeros (1, 128, "logical")) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
587 |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
588 %!error bitunpack () |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
589 %!error bitunpack (1, 2) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
590 %!error bitunpack ({}) |
64efef931bd0
Add BIST tests for bitpack, bitunpack, isglobal, and typecast
Mike Miller <mtmiller@octave.org>
parents:
21301
diff
changeset
|
591 */ |