Mercurial > octave
annotate liboctave/array/idx-vector.cc @ 23796:4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
* mk-opts.pl, BlockArray.cpp, KeyboardTranslator.cpp, Screen.cpp,
TerminalCharacterDecoder.cpp, TerminalView.cpp, Vt102Emulation.cpp, dialog.cc,
find-files-dialog.cc, file-editor-tab.cc, main-window.cc, ls-hdf5.cc,
oct-procbuf.h, oct-stream.cc, oct-tex-lexer.in.ll, zfstream.cc, ov-builtin.h,
ov-fcn-handle.cc, ov-typeinfo.h, ov-usr-fcn.h, options-usage.h, lex.ll,
oct-parse.in.yy, pt-loop.h, Array.cc, CSparse.cc, Sparse.h, dSparse.cc,
fCMatrix.cc, idx-vector.cc, idx-vector.h, sparse-chol.cc, cmd-edit.cc,
oct-sort.cc, main.in.cc:
Use C++11 nullptr rather than 0 in code (bug #51565).
author | Rik <rik@octave.org> |
---|---|
date | Wed, 26 Jul 2017 16:26:31 -0700 |
parents | 980f39c3ab90 |
children | 336f89b6208b |
rev | line source |
---|---|
1 | 1 /* |
2 | |
23219
3ac9f9ecfae5
maint: Update copyright dates.
John W. Eaton <jwe@octave.org>
parents:
23083
diff
changeset
|
3 Copyright (C) 1993-2017 John W. Eaton |
11523 | 4 Copyright (C) 2008-2009 Jaroslav Hajek |
5 Copyright (C) 2009-2010 VZLU Prague | |
1 | 6 |
7 This file is part of Octave. | |
8 | |
9 Octave is free software; you can redistribute it and/or modify it | |
22755
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
10 under the terms of the GNU General Public License as published by |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
11 the Free Software Foundation; either version 3 of the License, or |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
12 (at your option) any later version. |
1 | 13 |
22755
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
14 Octave is distributed in the hope that it will be useful, but |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
15 WITHOUT ANY WARRANTY; without even the implied warranty of |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
3a2b891d0b33
maint: Standardize Copyright formatting.
Rik <rik@octave.org>
parents:
22402
diff
changeset
|
17 GNU General Public License for more details. |
1 | 18 |
19 You should have received a copy of the GNU General Public License | |
7016 | 20 along with Octave; see the file COPYING. If not, see |
21 <http://www.gnu.org/licenses/>. | |
1 | 22 |
23 */ | |
24 | |
21724
aba2e6293dd8
use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents:
21660
diff
changeset
|
25 #if defined (HAVE_CONFIG_H) |
21301
40de9f8f23a6
Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents:
21202
diff
changeset
|
26 # include "config.h" |
1 | 27 #endif |
28 | |
1343 | 29 #include <cstdlib> |
30 | |
3503 | 31 #include <iostream> |
164 | 32 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
33 #include "idx-vector.h" |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
34 #include "Array.h" |
10370
9c4daf174387
implement IDs for common liboctave exceptions
Jaroslav Hajek <highegg@gmail.com>
parents:
10339
diff
changeset
|
35 #include "Array-util.h" |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
36 #include "Sparse.h" |
1352 | 37 #include "Range.h" |
38 | |
8379
ad8ed668e0a4
allow initialized local buffers
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
39 #include "oct-locbuf.h" |
1560 | 40 #include "lo-error.h" |
2500 | 41 #include "lo-mappers.h" |
1 | 42 |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
43 OCTAVE_NORETURN static |
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
44 void |
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
45 err_invalid_range (void) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
46 { |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
47 (*current_liboctave_error_handler) ("invalid range used as index"); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
48 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
49 |
8333 | 50 static void |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
21019
diff
changeset
|
51 err_index_out_of_range (void) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
52 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
53 (*current_liboctave_error_handler) |
11590
4ced6b90fffb
style fixes for warning and error messages in source files
John W. Eaton <jwe@octave.org>
parents:
11586
diff
changeset
|
54 ("internal error: idx_vector index out of range"); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
55 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
56 |
21573
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
57 idx_vector::idx_vector_rep * |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
58 idx_vector::nil_rep (void) |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
59 { |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
60 static idx_vector_rep ivr; |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
61 return &ivr; |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
62 } |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
63 |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
64 idx_vector::idx_vector_rep * |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
65 idx_vector::err_rep (void) |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
66 { |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
67 static idx_vector_rep ivr; |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
68 ivr.err = true; |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
69 return &ivr; |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
70 } |
f3f8e1d3e399
avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
19697
diff
changeset
|
71 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
72 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
73 idx_vector::idx_base_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
74 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
75 (*current_liboctave_error_handler) |
11590
4ced6b90fffb
style fixes for warning and error messages in source files
John W. Eaton <jwe@octave.org>
parents:
11586
diff
changeset
|
76 ("internal error: as_array not allowed for this index class"); |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
77 |
21411
9f7282acc30f
Fix segfault caused by clang processing of GCC noreturn attribute.
Rik <rik@octave.org>
parents:
21307
diff
changeset
|
78 // Never actually executed, but required to silence compiler warning |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
79 return Array<octave_idx_type> (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
80 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
81 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
82 idx_vector::idx_colon_rep::idx_colon_rep (char c) |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
83 : idx_base_rep () |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
84 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
85 if (c != ':') |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
86 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
87 (*current_liboctave_error_handler) |
11590
4ced6b90fffb
style fixes for warning and error messages in source files
John W. Eaton <jwe@octave.org>
parents:
11586
diff
changeset
|
88 ("internal error: invalid character converted to idx_vector; must be ':'"); |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21129
diff
changeset
|
89 // FIXME: this is unreachable now. |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
90 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
91 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
92 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
93 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
94 octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
95 idx_vector::idx_colon_rep::checkelem (octave_idx_type i) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
96 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
97 if (i < 0) |
21129
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
98 err_index_out_of_range (); |
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
99 |
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
100 return i; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
101 } |
1560 | 102 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
103 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
104 idx_vector::idx_colon_rep::sort_idx (Array<octave_idx_type>&) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
105 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
106 (*current_liboctave_error_handler) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
107 ("internal error: idx_colon_rep::sort_idx"); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
108 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
109 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
110 std::ostream& |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
111 idx_vector::idx_colon_rep::print (std::ostream& os) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
112 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
113 return os << ":"; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
114 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
115 |
10258 | 116 idx_vector::idx_range_rep::idx_range_rep (octave_idx_type _start, |
117 octave_idx_type _limit, | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
118 octave_idx_type _step) |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
119 : idx_base_rep (), start(_start), |
22402
4caa7b28d183
maint: Style check C++ code in liboctave/
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
120 len (_step ? std::max ((_limit - _start) / _step, |
4caa7b28d183
maint: Style check C++ code in liboctave/
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
121 static_cast<octave_idx_type> (0)) |
4caa7b28d183
maint: Style check C++ code in liboctave/
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
122 : -1), |
4caa7b28d183
maint: Style check C++ code in liboctave/
Rik <rik@octave.org>
parents:
22327
diff
changeset
|
123 step (_step) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
124 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
125 if (len < 0) |
21129
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
126 err_invalid_range (); |
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
127 if (start < 0) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
128 octave::err_invalid_index (start); |
21129
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
129 if (step < 0 && start + (len-1)*step < 0) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
130 octave::err_invalid_index (start + (len-1)*step); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
131 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
132 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
133 idx_vector::idx_range_rep::idx_range_rep (const Range& r) |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
134 : idx_base_rep (), start (0), len (r.numel ()), step (1) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
135 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
136 if (len < 0) |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
137 err_invalid_range (); |
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
138 |
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
139 if (len > 0) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
140 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
141 if (r.all_elements_are_ints ()) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
142 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
143 start = static_cast<octave_idx_type> (r.base ()) - 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
144 step = static_cast<octave_idx_type> (r.inc ()); |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20232
diff
changeset
|
145 if (start < 0) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
146 octave::err_invalid_index (start); |
21129
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
147 if (step < 0 && start + (len - 1)*step < 0) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
148 octave::err_invalid_index (start + (len - 1)*step); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
149 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
150 else |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
151 { |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20232
diff
changeset
|
152 // find first non-integer, then gripe about it |
20648 | 153 double b = r.base (); |
154 double inc = r.inc (); | |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
155 octave::err_invalid_index (b != std::floor (b) ? b : b + inc); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
156 } |
1 | 157 } |
158 } | |
159 | |
5275 | 160 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
161 idx_vector::idx_range_rep::checkelem (octave_idx_type i) const |
1 | 162 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
163 if (i < 0 || i >= len) |
21129
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
164 err_index_out_of_range (); |
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
165 |
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
166 return start + i*step; |
3928 | 167 } |
168 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
169 idx_vector::idx_base_rep * |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
170 idx_vector::idx_range_rep::sort_uniq_clone (bool) |
2500 | 171 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
172 if (step < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
173 return new idx_range_rep (start + (len - 1)*step, len, -step, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
174 else |
2500 | 175 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
176 count++; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
177 return this; |
2500 | 178 } |
1 | 179 } |
180 | |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
181 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
182 idx_vector::idx_range_rep::sort_idx (Array<octave_idx_type>& idx) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
183 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
184 if (step < 0 && len > 0) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
185 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
186 idx.clear (1, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
187 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
188 idx.xelem (i) = len - 1 - i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
189 return new idx_range_rep (start + (len - 1)*step, len, -step, DIRECT); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
190 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
191 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
192 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
193 idx.clear (1, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
194 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
195 idx.xelem (i) = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
196 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
197 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
198 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
199 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
200 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
201 std::ostream& |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
202 idx_vector::idx_range_rep::print (std::ostream& os) const |
1 | 203 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
204 os << start << ':' << step << ':' << start + len*step; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
205 return os; |
1560 | 206 } |
207 | |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
208 Range |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
209 idx_vector::idx_range_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
210 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
211 return Range (static_cast<double> (start+1), |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
212 static_cast<double> (step), len); |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
213 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
214 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
215 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
216 idx_vector::idx_range_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
217 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
218 Array<octave_idx_type> retval (dim_vector (1, len)); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
219 for (octave_idx_type i = 0; i < len; i++) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10475
diff
changeset
|
220 retval.xelem (i) = start + i*step; |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
221 |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
222 return retval; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
223 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
224 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
225 inline octave_idx_type |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
226 convert_index (octave_idx_type i, bool& conv_error, |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
227 octave_idx_type& ext) |
1560 | 228 { |
21102
dfcb9d74b253
Rename local gripe_XXX functions to err_XXX or warn_XXX.
Rik <rik@octave.org>
parents:
21100
diff
changeset
|
229 if (i <= 0 && ! conv_error) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
230 octave::err_invalid_index (i-1); |
10487 | 231 |
232 if (ext < i) | |
233 ext = i; | |
234 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
235 return i - 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
236 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
237 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
238 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
239 convert_index (double x, bool& conv_error, octave_idx_type& ext) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
240 { |
9007
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
241 octave_idx_type i = static_cast<octave_idx_type> (x); |
10487 | 242 |
9007
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
243 if (static_cast<double> (i) != x) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
244 octave::err_invalid_index (x-1); |
1 | 245 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
246 return convert_index (i, conv_error, ext); |
1 | 247 } |
248 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
249 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
250 convert_index (float x, bool& conv_error, octave_idx_type& ext) |
1 | 251 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
252 return convert_index (static_cast<double> (x), conv_error, ext); |
1 | 253 } |
254 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
255 template <typename T> |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
256 inline octave_idx_type |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
257 convert_index (octave_int<T> x, bool& conv_error, |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
258 octave_idx_type& ext) |
3928 | 259 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
260 octave_idx_type i = octave_int<octave_idx_type> (x).value (); |
10487 | 261 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
262 return convert_index (i, conv_error, ext); |
3928 | 263 } |
264 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
265 template <typename T> |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
266 idx_vector::idx_scalar_rep::idx_scalar_rep (T x) |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
267 : idx_base_rep (), data (0) |
3928 | 268 { |
10101
b51848e95e4b
cleanups to avoid valgrind warnings
John W. Eaton <jwe@octave.org>
parents:
10042
diff
changeset
|
269 octave_idx_type dummy = 0; |
10487 | 270 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
271 data = convert_index (x, err, dummy); |
3928 | 272 } |
273 | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
274 idx_vector::idx_scalar_rep::idx_scalar_rep (octave_idx_type i) |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
275 : idx_base_rep (), data (i) |
1560 | 276 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
277 if (data < 0) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
278 octave::err_invalid_index (data); |
2828 | 279 } |
280 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
281 octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
282 idx_vector::idx_scalar_rep::checkelem (octave_idx_type i) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
283 { |
10487 | 284 if (i != 0) |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
21019
diff
changeset
|
285 err_index_out_of_range (); |
10487 | 286 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
287 return data; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
288 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
289 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
290 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
291 idx_vector::idx_scalar_rep::sort_idx (Array<octave_idx_type>& idx) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
292 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
293 idx.clear (1, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
294 idx.fill (0); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
295 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
296 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
297 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
298 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
299 std::ostream& idx_vector::idx_scalar_rep::print (std::ostream& os) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
300 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
301 return os << data; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
302 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
303 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
304 double |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
305 idx_vector::idx_scalar_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
306 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
307 return data + 1; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
308 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
309 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
310 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
311 idx_vector::idx_scalar_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
312 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
313 return Array<octave_idx_type> (dim_vector (1, 1), data); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
314 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
315 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21136
diff
changeset
|
316 template <typename T> |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
317 idx_vector::idx_vector_rep::idx_vector_rep (const Array<T>& nda) |
23796
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
318 : idx_base_rep (), data (nullptr), len (nda.numel ()), ext (0), |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23592
diff
changeset
|
319 aowner (nullptr), orig_dims (nda.dims ()) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
320 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
321 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
322 { |
21448
06a2f9245a11
avoid possible memory leak in idx_vector_rep constructor (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21411
diff
changeset
|
323 std::unique_ptr<octave_idx_type []> d (new octave_idx_type [len]); |
06a2f9245a11
avoid possible memory leak in idx_vector_rep constructor (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21411
diff
changeset
|
324 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
325 for (octave_idx_type i = 0; i < len; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
326 d[i] = convert_index (nda.xelem (i), err, ext); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
327 |
21448
06a2f9245a11
avoid possible memory leak in idx_vector_rep constructor (bug #47372)
John W. Eaton <jwe@octave.org>
parents:
21411
diff
changeset
|
328 data = d.release (); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
329 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
330 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
331 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
332 // Note that this makes a shallow copy of the index array. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
333 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
334 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda) |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
335 : idx_base_rep (), data (inda.data ()), len (inda.numel ()), ext (0), |
11503
b3f511c48b14
idx-vector.h, idx-vector.cc: data member initialization and constructor fixes
John W. Eaton <jwe@octave.org>
parents:
10702
diff
changeset
|
336 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ()) |
2828 | 337 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
338 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
339 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
340 octave_idx_type max = -1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
341 for (octave_idx_type i = 0; i < len; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
342 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
343 octave_idx_type k = inda.xelem (i); |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
344 if (k < 0) |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20232
diff
changeset
|
345 { |
21129
228b65504557
maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents:
21102
diff
changeset
|
346 if (! err) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
347 octave::err_invalid_index (k); |
20542
dd6345fd8a97
use exceptions for better invalid index error reporting (bug #45957)
Lachlan Andrew <lachlanbis@gmail.com>
parents:
20232
diff
changeset
|
348 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
349 else if (k > max) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
350 max = k; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
351 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
352 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
353 ext = max + 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
354 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
355 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
356 |
10285
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
357 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda, |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
358 octave_idx_type _ext, direct) |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
359 : idx_base_rep (), data (inda.data ()), len (inda.numel ()), ext (_ext), |
10487 | 360 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ()) |
10285
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
361 { |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
362 // No checking. |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
363 if (ext < 0) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
364 { |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
365 octave_idx_type max = -1; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
366 for (octave_idx_type i = 0; i < len; i++) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
367 if (data[i] > max) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
368 max = data[i]; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
369 |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
370 ext = max + 1; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
371 } |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
372 } |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
373 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
374 idx_vector::idx_vector_rep::idx_vector_rep (bool b) |
23796
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
375 : idx_base_rep (), data (nullptr), len (b ? 1 : 0), ext (0), |
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
376 aowner (nullptr), orig_dims (len, len) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
377 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
378 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
379 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
380 octave_idx_type *d = new octave_idx_type [1]; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
381 d[0] = 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
382 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
383 ext = 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
384 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
385 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
386 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
387 idx_vector::idx_vector_rep::idx_vector_rep (const Array<bool>& bnda, |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
388 octave_idx_type nnz) |
23796
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
389 : idx_base_rep (), data (nullptr), len (nnz), ext (0), aowner (nullptr), |
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
390 orig_dims () |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
391 { |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
392 if (nnz < 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
393 len = bnda.nnz (); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
394 |
9045
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
395 const dim_vector dv = bnda.dims (); |
7774
ce52af0e4a10
all false logical indexing fix
David Bateman <dbateman@free.fr>
parents:
7727
diff
changeset
|
396 |
23386
f1ea44e92df8
improve compatibility for single index indexing (bug #50776)
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
397 orig_dims = dv.make_nd_vector (len); |
7774
ce52af0e4a10
all false logical indexing fix
David Bateman <dbateman@free.fr>
parents:
7727
diff
changeset
|
398 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
399 if (len != 0) |
2828 | 400 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
401 octave_idx_type *d = new octave_idx_type [len]; |
2828 | 402 |
20232
a9574e3c6e9e
Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20228
diff
changeset
|
403 octave_idx_type ntot = bnda.numel (); |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
404 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
405 octave_idx_type k = 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
406 for (octave_idx_type i = 0; i < ntot; i++) |
10487 | 407 if (bnda.xelem (i)) |
408 d[k++] = i; | |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
409 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
410 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
411 |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
412 ext = d[k-1] + 1; |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
413 } |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
414 } |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
415 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
416 idx_vector::idx_vector_rep::idx_vector_rep (const Sparse<bool>& bnda) |
23796
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
417 : idx_base_rep (), data (nullptr), len (bnda.nnz ()), ext (0), |
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
418 aowner (nullptr), orig_dims () |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
419 { |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
420 const dim_vector dv = bnda.dims (); |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
421 |
23386
f1ea44e92df8
improve compatibility for single index indexing (bug #50776)
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
422 orig_dims = dv.make_nd_vector (len); |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
423 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
424 if (len != 0) |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
425 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
426 octave_idx_type *d = new octave_idx_type [len]; |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
427 |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
428 octave_idx_type k = 0; |
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
429 octave_idx_type nc = bnda.cols (); |
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
430 octave_idx_type nr = bnda.rows (); |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
431 |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
432 for (octave_idx_type j = 0; j < nc; j++) |
18083
938f01339043
maint: Use Octave coding convention for indexing vs. function calls in liboctave/array.
Rik <rik@octave.org>
parents:
17769
diff
changeset
|
433 for (octave_idx_type i = bnda.cidx (j); i < bnda.cidx (j+1); i++) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
434 if (bnda.data (i)) |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
435 d[k++] = j * nr + bnda.ridx (i); |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
436 |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
437 data = d; |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
438 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
439 ext = d[k-1] + 1; |
2828 | 440 } |
441 } | |
442 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
443 idx_vector::idx_vector_rep::~idx_vector_rep (void) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
444 { |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
445 if (aowner) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
446 delete aowner; |
1 | 447 else |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
448 delete [] data; |
1560 | 449 } |
450 | |
5275 | 451 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
452 idx_vector::idx_vector_rep::checkelem (octave_idx_type n) const |
227 | 453 { |
454 if (n < 0 || n >= len) | |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
455 octave::err_invalid_index (n); |
227 | 456 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
457 return xelem (n); |
1560 | 458 } |
459 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
460 idx_vector::idx_base_rep * |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
461 idx_vector::idx_vector_rep::sort_uniq_clone (bool uniq) |
1560 | 462 { |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
463 if (len == 0) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
464 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
465 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
466 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
467 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
468 |
21307
61c96c37ce69
Use std::unique_ptr to replace deprecated std::auto_ptr.
Rik <rik@octave.org>
parents:
21301
diff
changeset
|
469 // This is wrapped in unique_ptr so that we don't leak on out-of-memory. |
61c96c37ce69
Use std::unique_ptr to replace deprecated std::auto_ptr.
Rik <rik@octave.org>
parents:
21301
diff
changeset
|
470 std::unique_ptr<idx_vector_rep> new_rep ( |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23592
diff
changeset
|
471 new idx_vector_rep (nullptr, len, ext, orig_dims, DIRECT)); |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
472 |
21782
2aef506f3fec
use namespace for lo-mappers.h functions
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
473 if (ext > len*octave::math::log2 (1.0 + len)) |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
474 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
475 // Use standard sort via octave_sort. |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
476 octave_idx_type *new_data = new octave_idx_type [len]; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
477 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
478 |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23408
diff
changeset
|
479 std::copy_n (data, len, new_data); |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
480 octave_sort<octave_idx_type> lsort; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
481 lsort.set_compare (ASCENDING); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
482 lsort.sort (new_data, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
483 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
484 if (uniq) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
485 { |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
486 octave_idx_type new_len = std::unique (new_data, new_data + len) |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
487 - new_data; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
488 new_rep->len = new_len; |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
489 if (new_rep->orig_dims.ndims () == 2 && new_rep->orig_dims(0) == 1) |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
490 new_rep->orig_dims = dim_vector (1, new_len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
491 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
492 new_rep->orig_dims = dim_vector (new_len, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
493 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
494 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
495 else if (uniq) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
496 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
497 // Use two-pass bucket sort (only a mask array needed). |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
498 OCTAVE_LOCAL_BUFFER_INIT (bool, has, ext, false); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
499 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
500 has[data[i]] = true; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
501 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
502 octave_idx_type new_len = 0; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
503 for (octave_idx_type i = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
504 new_len += has[i]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
505 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
506 new_rep->len = new_len; |
21660
53728df3e4c9
maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents:
21574
diff
changeset
|
507 if (new_rep->orig_dims.ndims () == 2 && new_rep->orig_dims(0) == 1) |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
508 new_rep->orig_dims = dim_vector (1, new_len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
509 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
510 new_rep->orig_dims = dim_vector (new_len, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
511 |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
512 octave_idx_type *new_data = new octave_idx_type [new_len]; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
513 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
514 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
515 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
516 if (has[i]) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
517 new_data[j++] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
518 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
519 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
520 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
521 // Use two-pass bucket sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
522 OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, ext, 0); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
523 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
524 cnt[data[i]]++; |
2966 | 525 |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
526 octave_idx_type *new_data = new octave_idx_type [len]; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
527 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
528 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
529 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
530 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
531 for (octave_idx_type k = 0; k < cnt[i]; k++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
532 new_data[j++] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
533 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
534 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
535 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
536 return new_rep.release (); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
537 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
538 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
539 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
540 idx_vector::idx_vector_rep::sort_idx (Array<octave_idx_type>& idx) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
541 { |
21307
61c96c37ce69
Use std::unique_ptr to replace deprecated std::auto_ptr.
Rik <rik@octave.org>
parents:
21301
diff
changeset
|
542 // This is wrapped in unique_ptr so that we don't leak on out-of-memory. |
61c96c37ce69
Use std::unique_ptr to replace deprecated std::auto_ptr.
Rik <rik@octave.org>
parents:
21301
diff
changeset
|
543 std::unique_ptr<idx_vector_rep> new_rep ( |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23592
diff
changeset
|
544 new idx_vector_rep (nullptr, len, ext, orig_dims, DIRECT)); |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
545 |
21782
2aef506f3fec
use namespace for lo-mappers.h functions
John W. Eaton <jwe@octave.org>
parents:
21751
diff
changeset
|
546 if (ext > len*octave::math::log2 (1.0 + len)) |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
547 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
548 // Use standard sort via octave_sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
549 idx.clear (orig_dims); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
550 octave_idx_type *idx_data = idx.fortran_vec (); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
551 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
552 idx_data[i] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
553 |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
554 octave_idx_type *new_data = new octave_idx_type [len]; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
555 new_rep->data = new_data; |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23408
diff
changeset
|
556 std::copy_n (data, len, new_data); |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
557 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
558 octave_sort<octave_idx_type> lsort; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
559 lsort.set_compare (ASCENDING); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
560 lsort.sort (new_data, idx_data, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
561 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
562 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
563 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
564 // Use two-pass bucket sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
565 OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, ext, 0); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
566 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
567 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
568 cnt[data[i]]++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
569 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
570 idx.clear (orig_dims); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
571 octave_idx_type *idx_data = idx.fortran_vec (); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
572 |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
573 octave_idx_type *new_data = new octave_idx_type [len]; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
574 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
575 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
576 for (octave_idx_type i = 0, k = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
577 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
578 octave_idx_type j = cnt[i]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
579 cnt[i] = k; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
580 k += j; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
581 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
582 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
583 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
584 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
585 octave_idx_type j = data[i]; |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
586 octave_idx_type k = cnt[j]++; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
587 new_data[k] = j; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
588 idx_data[k] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
589 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
590 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
591 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
592 return new_rep.release (); |
209 | 593 } |
594 | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
595 std::ostream& |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
596 idx_vector::idx_vector_rep::print (std::ostream& os) const |
3079 | 597 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
598 os << '['; |
10487 | 599 |
23408
0af9a1ae0912
maint: Use std::copy_n and std::fill_n for dim_vectors and idx_vectors.
Rik <rik@octave.org>
parents:
23401
diff
changeset
|
600 for (octave_idx_type i = 0; i < len - 1; i++) |
0af9a1ae0912
maint: Use std::copy_n and std::fill_n for dim_vectors and idx_vectors.
Rik <rik@octave.org>
parents:
23401
diff
changeset
|
601 os << data[i] << ',' << ' '; |
10487 | 602 |
603 if (len > 0) | |
21943
2fc1ce5deae4
fix misleading indentation
John W. Eaton <jwe@octave.org>
parents:
21942
diff
changeset
|
604 os << data[len-1]; |
2fc1ce5deae4
fix misleading indentation
John W. Eaton <jwe@octave.org>
parents:
21942
diff
changeset
|
605 |
2fc1ce5deae4
fix misleading indentation
John W. Eaton <jwe@octave.org>
parents:
21942
diff
changeset
|
606 os << ']'; |
7425 | 607 |
1560 | 608 return os; |
609 } | |
610 | |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
611 Array<double> |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
612 idx_vector::idx_vector_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
613 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
614 Array<double> retval (orig_dims); |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
615 for (octave_idx_type i = 0; i < len; i++) |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
616 retval.xelem (i) = data[i] + 1; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
617 return retval; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
618 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
619 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
620 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
621 idx_vector::idx_vector_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
622 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
623 if (aowner) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
624 return *aowner; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
625 else |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
626 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
627 Array<octave_idx_type> retval (orig_dims); |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
628 |
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
629 if (data) |
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
630 { |
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
631 std::memcpy (retval.fortran_vec (), data, len*sizeof (octave_idx_type)); |
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
632 // Delete the old copy and share the data instead to save memory. |
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
633 delete [] data; |
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
634 } |
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
635 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
636 data = retval.fortran_vec (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
637 aowner = new Array<octave_idx_type> (retval); |
23401
e0c20a22da7e
eliminate some errors exposed by -fsanitize=undefined
John W. Eaton <jwe@octave.org>
parents:
23386
diff
changeset
|
638 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
639 return retval; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
640 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
641 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
642 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
643 idx_vector::idx_mask_rep::idx_mask_rep (bool b) |
23796
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
644 : idx_base_rep (), data (nullptr), len (b ? 1 : 0), ext (0), |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23592
diff
changeset
|
645 lsti (-1), lste (-1), aowner (nullptr), orig_dims (len, len) |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
646 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
647 if (len != 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
648 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
649 bool *d = new bool [1]; |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
650 d[0] = true; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
651 data = d; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
652 ext = 1; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
653 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
654 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
655 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
656 idx_vector::idx_mask_rep::idx_mask_rep (const Array<bool>& bnda, |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
657 octave_idx_type nnz) |
23796
4f12819a634f
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23795
diff
changeset
|
658 : idx_base_rep (), data (nullptr), len (nnz), ext (bnda.numel ()), |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23592
diff
changeset
|
659 lsti (-1), lste (-1), aowner (nullptr), orig_dims () |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
660 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
661 if (nnz < 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
662 len = bnda.nnz (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
663 |
21751
b571fc85953f
maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents:
21724
diff
changeset
|
664 // We truncate the extent as much as possible. For Matlab |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
665 // compatibility, but maybe it's not a bad idea anyway. |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
666 while (ext > 0 && ! bnda(ext-1)) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
667 ext--; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
668 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
669 const dim_vector dv = bnda.dims (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
670 |
23386
f1ea44e92df8
improve compatibility for single index indexing (bug #50776)
John W. Eaton <jwe@octave.org>
parents:
23220
diff
changeset
|
671 orig_dims = dv.make_nd_vector (len); |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
672 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
673 aowner = new Array<bool> (bnda); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
674 data = bnda.data (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
675 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
676 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
677 idx_vector::idx_mask_rep::~idx_mask_rep (void) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
678 { |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
679 if (aowner) |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
680 delete aowner; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
681 else |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
682 delete [] data; |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
683 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
684 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
685 octave_idx_type |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
686 idx_vector::idx_mask_rep::xelem (octave_idx_type n) const |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
687 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
688 if (n == lsti + 1) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
689 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
690 lsti = n; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
691 while (! data[++lste]) ; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
692 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
693 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
694 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
695 lsti = n++; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
696 lste = -1; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
697 while (n > 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
698 if (data[++lste]) --n; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
699 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
700 return lste; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
701 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
702 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
703 octave_idx_type |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
704 idx_vector::idx_mask_rep::checkelem (octave_idx_type n) const |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
705 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
706 if (n < 0 || n >= len) |
22327
d0562b3159c7
move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents:
22323
diff
changeset
|
707 octave::err_invalid_index (n); |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
708 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
709 return xelem (n); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
710 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
711 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
712 std::ostream& |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
713 idx_vector::idx_mask_rep::print (std::ostream& os) const |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
714 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
715 os << '['; |
10487 | 716 |
23408
0af9a1ae0912
maint: Use std::copy_n and std::fill_n for dim_vectors and idx_vectors.
Rik <rik@octave.org>
parents:
23401
diff
changeset
|
717 for (octave_idx_type i = 0; i < ext - 1; i++) |
0af9a1ae0912
maint: Use std::copy_n and std::fill_n for dim_vectors and idx_vectors.
Rik <rik@octave.org>
parents:
23401
diff
changeset
|
718 os << data[i] << ',' << ' '; |
10487 | 719 |
720 if (ext > 0) | |
21943
2fc1ce5deae4
fix misleading indentation
John W. Eaton <jwe@octave.org>
parents:
21942
diff
changeset
|
721 os << data[ext-1]; |
2fc1ce5deae4
fix misleading indentation
John W. Eaton <jwe@octave.org>
parents:
21942
diff
changeset
|
722 |
2fc1ce5deae4
fix misleading indentation
John W. Eaton <jwe@octave.org>
parents:
21942
diff
changeset
|
723 os << ']'; |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
724 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
725 return os; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
726 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
727 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
728 Array<bool> |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
729 idx_vector::idx_mask_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
730 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
731 if (aowner) |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
732 return *aowner; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
733 else |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
734 { |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
735 Array<bool> retval (dim_vector (ext, 1)); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
736 for (octave_idx_type i = 0; i < ext; i++) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
737 retval.xelem (i) = data[i]; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
738 return retval; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
739 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
740 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
741 |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
742 Array<octave_idx_type> |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
743 idx_vector::idx_mask_rep::as_array (void) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
744 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
745 if (aowner) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
746 return aowner->find ().reshape (orig_dims); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
747 else |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
748 { |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
749 Array<bool> retval (orig_dims); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
750 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
751 if (data[i]) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
752 retval.xelem (j++) = i; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
753 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
754 return retval; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
755 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
756 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
757 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
758 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
759 idx_vector::idx_mask_rep::sort_idx (Array<octave_idx_type>& idx) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
760 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
761 idx.clear (len, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
762 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
763 idx.xelem (i) = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
764 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
765 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
766 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
767 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
768 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
769 const idx_vector idx_vector::colon (new idx_vector::idx_colon_rep ()); |
1560 | 770 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
771 idx_vector::idx_vector (const Array<bool>& bnda) |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23592
diff
changeset
|
772 : rep (nullptr) |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
773 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
774 // Convert only if it means saving at least half the memory. |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
775 static const int factor = (2 * sizeof (octave_idx_type)); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
776 octave_idx_type nnz = bnda.nnz (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
777 if (nnz <= bnda.numel () / factor) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
778 rep = new idx_vector_rep (bnda, nnz); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
779 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
780 rep = new idx_mask_rep (bnda, nnz); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
781 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
782 |
10487 | 783 bool |
784 idx_vector::maybe_reduce (octave_idx_type n, const idx_vector& j, | |
785 octave_idx_type nj) | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
786 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
787 bool reduced = false; |
1560 | 788 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
789 // Empty index always reduces. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
790 if (rep->length (n) == 0) |
1560 | 791 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
792 *this = idx_vector (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
793 return true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
794 } |
1560 | 795 |
8972
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
796 // Possibly skip singleton dims. |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
797 if (n == 1 && rep->is_colon_equiv (n)) |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
798 { |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
799 *this = j; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
800 return true; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
801 } |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
802 |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
803 if (nj == 1 && j.is_colon_equiv (nj)) |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
804 return true; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
805 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
806 switch (j.idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
807 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
808 case class_colon: |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
809 switch (rep->idx_class ()) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
810 { |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
811 case class_colon: |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
812 // (:,:) reduces to (:) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
813 reduced = true; |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
814 break; |
10487 | 815 |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
816 case class_scalar: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
817 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
818 // (i,:) reduces to a range. |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
819 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
820 octave_idx_type k = r->get_data (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
821 *this = new idx_range_rep (k, nj, n, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
822 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
823 } |
10487 | 824 break; |
825 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
826 case class_range: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
827 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
828 // (i:k:end,:) reduces to a range if i <= k and k divides n. |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
829 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
830 octave_idx_type s = r->get_start (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
831 octave_idx_type l = r->length (n); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
832 octave_idx_type t = r->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
833 if (l*t == n) |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
834 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
835 *this = new idx_range_rep (s, l * nj, t, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
836 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
837 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
838 } |
10487 | 839 break; |
840 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
841 default: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
842 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
843 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
844 break; |
10487 | 845 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
846 case class_range: |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
847 switch (rep->idx_class ()) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
848 { |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
849 case class_colon: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
850 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
851 // (:,i:j) reduces to a range (the step must be 1) |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
852 idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.rep); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
853 if (rj->get_step () == 1) |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
854 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
855 octave_idx_type sj = rj->get_start (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
856 octave_idx_type lj = rj->length (nj); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
857 *this = new idx_range_rep (sj * n, lj * n, 1, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
858 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
859 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
860 } |
10487 | 861 break; |
862 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
863 case class_scalar: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
864 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
865 // (k,i:d:j) reduces to a range. |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
866 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep); |
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
867 idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.rep); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
868 octave_idx_type k = r->get_data (); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
869 octave_idx_type sj = rj->get_start (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
870 octave_idx_type lj = rj->length (nj); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
871 octave_idx_type tj = rj->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
872 *this = new idx_range_rep (n * sj + k, lj, n * tj, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
873 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
874 } |
10487 | 875 break; |
876 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
877 case class_range: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
878 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
879 // (i:k:end,p:q) reduces to a range if i <= k and k divides n. |
10042
b7915ebe8acf
implement index reduction rule for multiple constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9894
diff
changeset
|
880 // (ones (1, m), ones (1, n)) reduces to (ones (1, m*n)) |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
881 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
882 octave_idx_type s = r->get_start (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
883 octave_idx_type l = r->length (n); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
884 octave_idx_type t = r->get_step (); |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
885 idx_range_rep *rj = dynamic_cast<idx_range_rep *> (j.rep); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
886 octave_idx_type sj = rj->get_start (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
887 octave_idx_type lj = rj->length (nj); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
888 octave_idx_type tj = rj->get_step (); |
10042
b7915ebe8acf
implement index reduction rule for multiple constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9894
diff
changeset
|
889 if ((l*t == n && tj == 1) || (t == 0 && tj == 0)) |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
890 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
891 *this = new idx_range_rep (s + n * sj, l * lj, t, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
892 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
893 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
894 } |
10487 | 895 break; |
896 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
897 default: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
898 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
899 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
900 break; |
10487 | 901 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
902 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
903 switch (rep->idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
904 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
905 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
906 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
907 // (i,j) reduces to a single index. |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
908 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep); |
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
909 idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.rep); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
910 octave_idx_type k = r->get_data () + n * rj->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
911 *this = new idx_scalar_rep (k, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
912 reduced = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
913 } |
10487 | 914 break; |
915 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
916 case class_range: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
917 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
918 // (i:d:j,k) reduces to a range. |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
919 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep); |
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
920 idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.rep); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
921 octave_idx_type s = r->get_start (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
922 octave_idx_type l = r->length (nj); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
923 octave_idx_type t = r->get_step (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
924 octave_idx_type k = rj->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
925 *this = new idx_range_rep (n * k + s, l, t, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
926 reduced = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
927 } |
10487 | 928 break; |
929 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
930 case class_colon: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
931 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
932 // (:,k) reduces to a range. |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
933 idx_scalar_rep *rj = dynamic_cast<idx_scalar_rep *> (j.rep); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
934 octave_idx_type k = rj->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
935 *this = new idx_range_rep (n * k, n, 1, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
936 reduced = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
937 } |
10487 | 938 break; |
939 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
940 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
941 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
942 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
943 break; |
10487 | 944 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
945 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
946 break; |
1560 | 947 } |
948 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
949 return reduced; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
950 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
951 |
8333 | 952 bool |
953 idx_vector::is_cont_range (octave_idx_type n, | |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10285
diff
changeset
|
954 octave_idx_type& l, octave_idx_type& u) const |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
955 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
956 bool res = false; |
10487 | 957 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
958 switch (rep->idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
959 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
960 case class_colon: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
961 l = 0; u = n; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
962 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
963 break; |
10487 | 964 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
965 case class_range: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
966 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
967 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
968 if (r->get_step () == 1) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
969 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
970 l = r->get_start (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
971 u = l + r->length (n); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
972 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
973 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
974 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
975 break; |
10487 | 976 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
977 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
978 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
979 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
980 l = r->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
981 u = l + 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
982 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
983 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
984 break; |
10487 | 985 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
986 case class_mask: |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
987 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
988 idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
989 octave_idx_type ext = r->extent (0); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
990 octave_idx_type len = r->length (0); |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
991 if (ext == len) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
992 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
993 l = 0; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
994 u = len; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
995 res = true; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
996 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
997 } |
10487 | 998 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
999 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1000 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1001 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1002 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1003 return res; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1004 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1005 |
9725 | 1006 octave_idx_type |
1007 idx_vector::increment (void) const | |
1008 { | |
1009 octave_idx_type retval = 0; | |
10487 | 1010 |
9725 | 1011 switch (rep->idx_class ()) |
1012 { | |
1013 case class_colon: | |
1014 retval = 1; | |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1015 break; |
10487 | 1016 |
9725 | 1017 case class_range: |
1018 retval = dynamic_cast<idx_range_rep *> (rep) -> get_step (); | |
1019 break; | |
10487 | 1020 |
9725 | 1021 case class_vector: |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1022 case class_mask: |
9725 | 1023 { |
1024 if (length (0) > 1) | |
1025 retval = elem (1) - elem (0); | |
1026 } | |
10487 | 1027 break; |
1028 | |
9757
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1029 default: |
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1030 break; |
9725 | 1031 } |
10487 | 1032 |
9725 | 1033 return retval; |
1034 } | |
1035 | |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1036 const octave_idx_type * |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1037 idx_vector::raw (void) |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1038 { |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1039 if (rep->idx_class () != class_vector) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10475
diff
changeset
|
1040 *this = idx_vector (as_array (), extent (0)); |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1041 |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
1042 idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep); |
10487 | 1043 |
23795
980f39c3ab90
Use C++11 nullptr rather than 0 in code (bug #51565).
Rik <rik@octave.org>
parents:
23592
diff
changeset
|
1044 assert (r != nullptr); |
10487 | 1045 |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1046 return r->get_data (); |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1047 } |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1048 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1049 void |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1050 idx_vector::copy_data (octave_idx_type *data) const |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1051 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1052 octave_idx_type len = rep->length (0); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1053 |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1054 switch (rep->idx_class ()) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1055 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1056 case class_colon: |
21019
8a65589d1a42
maint: Dereference current_liboctave_error_handler before calling.
Rik <rik@octave.org>
parents:
20955
diff
changeset
|
1057 (*current_liboctave_error_handler) ("colon not allowed"); |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1058 break; |
10487 | 1059 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1060 case class_range: |
10487 | 1061 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
1062 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1063 octave_idx_type start = r->get_start (); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1064 octave_idx_type step = r->get_step (); |
10487 | 1065 octave_idx_type i, j; |
1066 if (step == 1) | |
1067 for (i = start, j = start + len; i < j; i++) *data++ = i; | |
1068 else if (step == -1) | |
1069 for (i = start, j = start - len; i > j; i--) *data++ = i; | |
1070 else | |
1071 for (i = 0, j = start; i < len; i++, j += step) *data++ = j; | |
1072 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1073 break; |
10487 | 1074 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1075 case class_scalar: |
10487 | 1076 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
1077 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep); |
10487 | 1078 *data = r->get_data (); |
1079 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1080 break; |
10487 | 1081 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1082 case class_vector: |
10487 | 1083 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
1084 idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep); |
10487 | 1085 const octave_idx_type *rdata = r->get_data (); |
23420
1fee389bd04b
Use std::copy_n rather than std::copy for clarity in liboctave/array.
Rik <rik@octave.org>
parents:
23408
diff
changeset
|
1086 std::copy_n (rdata, len, data); |
10487 | 1087 } |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1088 break; |
10487 | 1089 |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1090 case class_mask: |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1091 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
1092 idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep); |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1093 const bool *mask = r->get_data (); |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1094 octave_idx_type ext = r->extent (0); |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1095 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1096 if (mask[i]) |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1097 data[j++] = i; |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1098 } |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1099 break; |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1100 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1101 default: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1102 assert (false); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1103 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1104 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1105 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1106 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1107 idx_vector |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1108 idx_vector::complement (octave_idx_type n) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1109 { |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1110 idx_vector retval; |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1111 if (extent (n) > n) |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1112 (*current_liboctave_error_handler) |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1113 ("internal error: out of range complement index requested"); |
3680 | 1114 |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1115 if (idx_class () == class_mask) |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1116 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
1117 idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1118 octave_idx_type nz = r->length (0); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1119 octave_idx_type ext = r->extent (0); |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1120 Array<bool> mask (dim_vector (n, 1)); |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1121 const bool *data = r->get_data (); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1122 bool *ndata = mask.fortran_vec (); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1123 for (octave_idx_type i = 0; i < ext; i++) |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1124 ndata[i] = ! data[i]; |
23408
0af9a1ae0912
maint: Use std::copy_n and std::fill_n for dim_vectors and idx_vectors.
Rik <rik@octave.org>
parents:
23401
diff
changeset
|
1125 std::fill_n (ndata + ext, n - ext, true); |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1126 retval = new idx_mask_rep (mask, n - nz); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1127 } |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1128 else |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1129 { |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1130 Array<bool> mask (dim_vector (n, 1), true); |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1131 fill (false, length (n), mask.fortran_vec ()); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1132 retval = idx_vector (mask); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1133 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1134 |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1135 return retval; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1136 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1137 |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1138 bool |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1139 idx_vector::is_permutation (octave_idx_type n) const |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1140 { |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1141 bool retval = false; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1142 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1143 if (is_colon_equiv (n)) |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1144 retval = true; |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14138
diff
changeset
|
1145 else if (length(n) == n && extent(n) == n) |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1146 { |
8379
ad8ed668e0a4
allow initialized local buffers
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
1147 OCTAVE_LOCAL_BUFFER_INIT (bool, left, n, true); |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1148 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1149 retval = true; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1150 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1151 for (octave_idx_type i = 0, len = length (); i < len; i++) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1152 { |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1153 octave_idx_type k = xelem (i); |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1154 if (left[k]) |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1155 left[k] = false; |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1156 else |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1157 { |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1158 retval = false; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1159 break; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1160 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1161 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1162 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1163 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1164 return retval; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1165 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1166 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1167 idx_vector |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1168 idx_vector::inverse_permutation (octave_idx_type n) const |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1169 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1170 assert (n == length (n)); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1171 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1172 idx_vector retval; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1173 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1174 switch (idx_class ()) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1175 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1176 case class_range: |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1177 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1178 if (increment () == -1) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1179 retval = sorted (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1180 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1181 retval = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1182 break; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1183 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1184 case class_vector: |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1185 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1186 idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1187 const octave_idx_type *ri = r->get_data (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1188 Array<octave_idx_type> idx (orig_dimensions ()); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1189 for (octave_idx_type i = 0; i < n; i++) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14138
diff
changeset
|
1190 idx.xelem (ri[i]) = i; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1191 retval = new idx_vector_rep (idx, r->extent (0), DIRECT); |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1192 break; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1193 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1194 default: |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1195 retval = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1196 break; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1197 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1198 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1199 return retval; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1200 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1201 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1202 idx_vector |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1203 idx_vector::unmask (void) const |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1204 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1205 if (idx_class () == class_mask) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1206 { |
23432
e35a5c1233d0
maint: Use convention 'int *x' for naming pointers.
Rik <rik@octave.org>
parents:
23420
diff
changeset
|
1207 idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep); |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1208 const bool *data = r->get_data (); |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1209 octave_idx_type ext = r->extent (0); |
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
1210 octave_idx_type len = r->length (0); |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
1211 octave_idx_type *idata = new octave_idx_type [len]; |
10487 | 1212 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1213 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1214 if (data[i]) |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1215 idata[j++] = i; |
10487 | 1216 |
23450
855122b993da
maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents:
23432
diff
changeset
|
1217 ext = (len > 0 ? idata[len - 1] + 1 : 0); |
10487 | 1218 |
1219 return new idx_vector_rep (idata, len, ext, r->orig_dimensions (), | |
1220 DIRECT); | |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1221 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1222 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1223 return *this; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1224 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1225 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1226 void idx_vector::unconvert (idx_class_type& iclass, |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1227 double& scalar, Range& range, |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1228 Array<double>& array, Array<bool>& mask) const |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1229 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1230 iclass = idx_class (); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1231 switch (iclass) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1232 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1233 case class_colon: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1234 break; |
10487 | 1235 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1236 case class_range: |
10487 | 1237 { |
1238 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep); | |
1239 range = r->unconvert (); | |
1240 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1241 break; |
10487 | 1242 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1243 case class_scalar: |
10487 | 1244 { |
1245 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep); | |
1246 scalar = r->unconvert (); | |
1247 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1248 break; |
10487 | 1249 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1250 case class_vector: |
10487 | 1251 { |
1252 idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep); | |
1253 array = r->unconvert (); | |
1254 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1255 break; |
10487 | 1256 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1257 case class_mask: |
10487 | 1258 { |
1259 idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep); | |
1260 mask = r->unconvert (); | |
1261 } | |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1262 break; |
10487 | 1263 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1264 default: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1265 assert (false); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1266 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1267 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1268 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1269 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1270 Array<octave_idx_type> |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1271 idx_vector::as_array (void) const |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1272 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1273 return rep->as_array (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1274 } |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1275 |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1276 bool |
23592
80e3bfb7bd5a
maint: Deprecate is_vector and replace with isvector.
Rik <rik@octave.org>
parents:
23450
diff
changeset
|
1277 idx_vector::isvector (void) const |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1278 { |
23592
80e3bfb7bd5a
maint: Deprecate is_vector and replace with isvector.
Rik <rik@octave.org>
parents:
23450
diff
changeset
|
1279 return idx_class () != class_vector || orig_dimensions ().isvector (); |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1280 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1281 |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1282 octave_idx_type |
8677
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8384
diff
changeset
|
1283 idx_vector::freeze (octave_idx_type z_len, const char *, bool resize_ok) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1284 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1285 if (! resize_ok && extent (z_len) > z_len) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1286 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1287 (*current_liboctave_error_handler) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1288 ("invalid matrix index = %d", extent (z_len)); |
21136
7cac4e7458f2
maint: clean up code around calls to current_liboctave_error_handler.
Rik <rik@octave.org>
parents:
21129
diff
changeset
|
1289 // FIXME: Should we call this before calling error_handler? |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1290 rep->err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1291 chkerr (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1292 } |
1560 | 1293 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1294 return length (z_len); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1295 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1296 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1297 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1298 idx_vector::ones_count () const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1299 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1300 octave_idx_type n = 0; |
10487 | 1301 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1302 if (is_colon ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1303 n = 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1304 else |
10487 | 1305 { |
1306 for (octave_idx_type i = 0; i < length (1); i++) | |
1307 if (xelem (i) == 0) | |
1308 n++; | |
1309 } | |
1310 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1311 return n; |
1 | 1312 } |
1313 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1314 // Instantiate the octave_int constructors we want. |
22197
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
1315 #define INSTANTIATE_SCALAR_VECTOR_REP_CONST(T) \ |
e43d83253e28
refill multi-line macro definitions
John W. Eaton <jwe@octave.org>
parents:
22022
diff
changeset
|
1316 template OCTAVE_API idx_vector::idx_scalar_rep::idx_scalar_rep (T); \ |
8319
c374691576f6
Fix for MSVC compilation
Michael Goffioul <michael.goffioul@gmail.com>
parents:
8301
diff
changeset
|
1317 template OCTAVE_API idx_vector::idx_vector_rep::idx_vector_rep (const Array<T>&); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1318 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1319 INSTANTIATE_SCALAR_VECTOR_REP_CONST (float) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1320 INSTANTIATE_SCALAR_VECTOR_REP_CONST (double) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1321 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int8) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1322 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int16) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1323 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int32) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1324 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int64) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1325 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint8) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1326 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint16) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1327 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint32) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1328 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint64) |
10620
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1329 |
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1330 /* |
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1331 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14138
diff
changeset
|
1332 %!error id=Octave:index-out-of-bounds 1(find ([1,1] != 0)) |
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14138
diff
changeset
|
1333 %!assert ((1:3)(find ([1,0,1] != 0)), [1,3]) |
10620
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1334 |
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1335 */ |