Mercurial > octave-dspies
annotate liboctave/array/idx-vector.cc @ 19006:2e0613dadfee draft
All calls to "find" use the same generic implementation (bug #42408, 42421)
* find.cc: Rewrite.
Move generic "find" logic to find.h
(Ffind) : Changed calls to find_nonzero_elem_idx to find_templated
Added unit test for bug #42421
* Array.cc (and .h) (Array::find): Deleted function. Replaced with find::find(Array)
from find.h
* Array.h: Added typedef for array_iterator (in nz-iterators.h) as
Array::iter_type
* DiagArray2.h: Added typedef for diag_iterator (in nz-iterators.h) as
DiagArray2::iter_type
* PermMatrix.h: Added typedef for perm_iterator (in nz-iterators.h) as
PermMatrix::iter_type
Also added typedef for bool as PermMatrix::element_type
(not octave_idx_type)
Added an nnz() function (which is an alias for perm_length) and a
perm_elem(i) function for retrieving the ith element of the permutation
* Sparse.h: Added typedef for sparse_iterator (in nz-iterators.h) as
Sparse::iter_type
Added a short comment documenting the the argument to the numel
function
* idx-vector.cc (idx_vector::idx_mask_rep::as_array): Changed Array.find to
find::find(Array) (in find.h)
* (new file) find.h
* (new file) interp-idx.h: Simple methods for converting between interpreter
index type and internal octave_idx_type/row-col pair
* (new file) min-with-nnz.h: Fast methods for taking an arbitrary matrix M and
an octave_idx_type n and finding min(M.nnz(), n)
* (new file) nz-iterators.h: Iterators for traversing (in column-major order)
the nonzero elements of any array or matrix backwards or forwards
* (new file) direction.h: Generic methods for simplifying code has to deal with
a "backwards or forwards" template argument
* build-sparse-tests.sh: Removed 5-return-value calls to "find" in unit-tests;
Admittedly this commit breaks this "feature" which was undocumented and only
partially supported to begin with (ie never worked for full matrices,
permutation matrices, or diagonal matrices)
author | David Spies <dnspies@gmail.com> |
---|---|
date | Tue, 17 Jun 2014 16:41:11 -0600 |
parents | 8e056300994b |
children |
rev | line source |
---|---|
1 | 1 /* |
2 | |
17744
d63878346099
maint: Update copyright notices for release.
John W. Eaton <jwe@octave.org>
parents:
16779
diff
changeset
|
3 Copyright (C) 1993-2013 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 | |
10 under the terms of the GNU General Public License as published by the | |
7016 | 11 Free Software Foundation; either version 3 of the License, or (at your |
12 option) any later version. | |
1 | 13 |
14 Octave is distributed in the hope that it will be useful, but WITHOUT | |
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
17 for more details. | |
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 | |
240 | 25 #ifdef HAVE_CONFIG_H |
1192 | 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" |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
18084
diff
changeset
|
42 #include "find.h" |
1 | 43 |
8333 | 44 static void |
45 gripe_invalid_range (void) | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
46 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
47 (*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
|
48 ("invalid range used as index"); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
49 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
50 |
8333 | 51 static void |
52 gripe_index_out_of_range (void) | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
53 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
54 (*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
|
55 ("internal error: idx_vector index out of range"); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
56 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
57 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
58 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
59 idx_vector::idx_base_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
60 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
61 (*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
|
62 ("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
|
63 |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
64 return Array<octave_idx_type> (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
65 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
66 |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
67 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_colon_rep); |
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
68 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
69 idx_vector::idx_colon_rep::idx_colon_rep (char c) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
70 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
71 if (c != ':') |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
72 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
73 (*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
|
74 ("internal error: invalid character converted to idx_vector; must be ':'"); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
75 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
76 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
77 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
78 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
79 octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
80 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
|
81 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
82 if (i < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
83 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
84 gripe_index_out_of_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
85 return 0; |
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 else |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
88 return i; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
89 } |
1560 | 90 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
91 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
92 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
|
93 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
94 (*current_liboctave_error_handler) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
95 ("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
|
96 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
97 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
98 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
99 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
100 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
101 std::ostream& |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
102 idx_vector::idx_colon_rep::print (std::ostream& os) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
103 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
104 return os << ":"; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
105 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
106 |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
107 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_range_rep); |
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
108 |
10258 | 109 idx_vector::idx_range_rep::idx_range_rep (octave_idx_type _start, |
110 octave_idx_type _limit, | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
111 octave_idx_type _step) |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14138
diff
changeset
|
112 : start(_start), len (_step ? std::max ((_limit - _start) / _step, static_cast<octave_idx_type> (0)) : -1), step (_step) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
113 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
114 if (len < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
115 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
116 gripe_invalid_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
117 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
118 } |
9757
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
119 else if (start < 0 || (step < 0 && start + (len-1)*step < 0)) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
120 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
121 gripe_invalid_index (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
122 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
123 } |
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 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
126 idx_vector::idx_range_rep::idx_range_rep (const Range& r) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
127 : start (0), len (r.nelem ()), step (1) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
128 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
129 if (len < 0) |
1 | 130 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
131 gripe_invalid_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
132 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
133 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
134 else if (len > 0) |
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 (r.all_elements_are_ints ()) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
137 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
138 start = static_cast<octave_idx_type> (r.base ()) - 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
139 step = static_cast<octave_idx_type> (r.inc ()); |
9124
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
140 if (start < 0 || (step < 0 && start + (len-1)*step < 0)) |
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
141 { |
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
142 gripe_invalid_index (); |
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
143 err = true; |
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
144 } |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
145 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
146 else |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
147 { |
9124
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
148 gripe_invalid_index (); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
149 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
150 } |
1 | 151 } |
152 } | |
153 | |
5275 | 154 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
155 idx_vector::idx_range_rep::checkelem (octave_idx_type i) const |
1 | 156 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
157 if (i < 0 || i >= len) |
4732 | 158 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
159 gripe_index_out_of_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
160 return 0; |
4732 | 161 } |
162 else | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
163 return start + i*step; |
3928 | 164 } |
165 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
166 idx_vector::idx_base_rep * |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
167 idx_vector::idx_range_rep::sort_uniq_clone (bool) |
2500 | 168 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
169 if (step < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
170 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
|
171 else |
2500 | 172 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
173 count++; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
174 return this; |
2500 | 175 } |
1 | 176 } |
177 | |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
178 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
179 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
|
180 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
181 if (step < 0 && len > 0) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
182 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
183 idx.clear (1, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
184 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
|
185 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
|
186 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
|
187 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
188 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
189 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
190 idx.clear (1, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
191 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
|
192 idx.xelem (i) = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
193 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
194 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
195 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
196 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
197 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
198 std::ostream& |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
199 idx_vector::idx_range_rep::print (std::ostream& os) const |
1 | 200 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
201 os << start << ':' << step << ':' << start + len*step; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
202 return os; |
1560 | 203 } |
204 | |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
205 Range |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
206 idx_vector::idx_range_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
207 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
208 return Range (static_cast<double> (start+1), |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
209 static_cast<double> (step), len); |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
210 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
211 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
212 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
213 idx_vector::idx_range_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
214 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
215 Array<octave_idx_type> retval (dim_vector (1, len)); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
216 for (octave_idx_type i = 0; i < len; i++) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10475
diff
changeset
|
217 retval.xelem (i) = start + i*step; |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
218 |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
219 return retval; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
220 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
221 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
222 inline octave_idx_type |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
223 convert_index (octave_idx_type i, bool& conv_error, |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
224 octave_idx_type& ext) |
1560 | 225 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
226 if (i <= 0) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
227 conv_error = true; |
10487 | 228 |
229 if (ext < i) | |
230 ext = i; | |
231 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
232 return i - 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
233 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
234 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
235 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
236 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
|
237 { |
9007
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
238 octave_idx_type i = static_cast<octave_idx_type> (x); |
10487 | 239 |
9007
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
240 if (static_cast<double> (i) != x) |
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
241 conv_error = true; |
1 | 242 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
243 return convert_index (i, conv_error, ext); |
1 | 244 } |
245 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
246 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
247 convert_index (float x, bool& conv_error, octave_idx_type& ext) |
1 | 248 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
249 return convert_index (static_cast<double> (x), conv_error, ext); |
1 | 250 } |
251 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
252 template <class T> |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
253 inline octave_idx_type |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
254 convert_index (octave_int<T> x, bool& conv_error, |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
255 octave_idx_type& ext) |
3928 | 256 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
257 octave_idx_type i = octave_int<octave_idx_type> (x).value (); |
10487 | 258 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
259 return convert_index (i, conv_error, ext); |
3928 | 260 } |
261 | |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
262 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_scalar_rep); |
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
263 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
264 template <class T> |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
265 idx_vector::idx_scalar_rep::idx_scalar_rep (T x) |
11503
b3f511c48b14
idx-vector.h, idx-vector.cc: data member initialization and constructor fixes
John W. Eaton <jwe@octave.org>
parents:
10702
diff
changeset
|
266 : data (0) |
3928 | 267 { |
10101
b51848e95e4b
cleanups to avoid valgrind warnings
John W. Eaton <jwe@octave.org>
parents:
10042
diff
changeset
|
268 octave_idx_type dummy = 0; |
10487 | 269 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
270 data = convert_index (x, err, dummy); |
10487 | 271 |
272 if (err) | |
273 gripe_invalid_index (); | |
3928 | 274 } |
275 | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
276 idx_vector::idx_scalar_rep::idx_scalar_rep (octave_idx_type i) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
277 : data (i) |
1560 | 278 { |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
279 if (data < 0) |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
280 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
281 gripe_invalid_index (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
282 err = true; |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
283 } |
2828 | 284 } |
285 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
286 octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
287 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
|
288 { |
10487 | 289 if (i != 0) |
290 gripe_index_out_of_range (); | |
291 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
292 return data; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
293 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
294 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
295 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
296 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
|
297 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
298 idx.clear (1, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
299 idx.fill (0); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
300 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
301 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
302 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
303 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
304 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
|
305 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
306 return os << data; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
307 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
308 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
309 double |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
310 idx_vector::idx_scalar_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
311 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
312 return data + 1; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
313 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
314 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
315 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
316 idx_vector::idx_scalar_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
317 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
318 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
|
319 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
320 |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
321 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_vector_rep); |
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
322 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
323 template <class T> |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
324 idx_vector::idx_vector_rep::idx_vector_rep (const Array<T>& nda) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
325 : data (0), len (nda.numel ()), ext (0), aowner (0), orig_dims (nda.dims ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
326 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
327 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
328 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
329 octave_idx_type *d = new octave_idx_type [len]; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
330 for (octave_idx_type i = 0; i < len; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
331 d[i] = convert_index (nda.xelem (i), err, ext); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
332 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
333 |
10487 | 334 if (err) |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
335 { |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
336 delete [] data; |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
337 gripe_invalid_index (); |
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
338 } |
8290
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 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
341 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
342 // 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
|
343 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
344 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
345 : 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
|
346 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ()) |
2828 | 347 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
348 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
349 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
350 octave_idx_type max = -1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
351 for (octave_idx_type i = 0; i < len; i++) |
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 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
|
354 if (k < 0) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
355 err = true; |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
356 else if (k > max) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
357 max = k; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
358 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
359 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
360 ext = max + 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
361 |
10487 | 362 if (err) |
363 gripe_invalid_index (); | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
364 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
365 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
366 |
10285
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
367 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
|
368 octave_idx_type _ext, direct) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
369 : data (inda.data ()), len (inda.numel ()), ext (_ext), |
10487 | 370 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
|
371 { |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
372 // No checking. |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
373 if (ext < 0) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
374 { |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
375 octave_idx_type max = -1; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
376 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
|
377 if (data[i] > max) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
378 max = data[i]; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
379 |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
380 ext = max + 1; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
381 } |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
382 } |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
383 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
384 idx_vector::idx_vector_rep::idx_vector_rep (bool b) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
385 : data (0), len (b ? 1 : 0), ext (0), aowner (0), orig_dims (len, len) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
386 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
387 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
388 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
389 octave_idx_type *d = new octave_idx_type [1]; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
390 d[0] = 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
391 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
392 ext = 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
393 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
394 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
395 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
396 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
|
397 octave_idx_type nnz) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
398 : data (0), len (nnz), ext (0), aowner (0), orig_dims () |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
399 { |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
400 if (nnz < 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
401 len = bnda.nnz (); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
402 |
9045
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
403 const dim_vector dv = bnda.dims (); |
7774
ce52af0e4a10
all false logical indexing fix
David Bateman <dbateman@free.fr>
parents:
7727
diff
changeset
|
404 |
9045
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
405 if (! dv.all_zero ()) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
406 orig_dims = ((dv.length () == 2 && dv(0) == 1) |
9045
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
407 ? dim_vector (1, len) : dim_vector (len, 1)); |
7774
ce52af0e4a10
all false logical indexing fix
David Bateman <dbateman@free.fr>
parents:
7727
diff
changeset
|
408 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
409 if (len != 0) |
2828 | 410 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
411 octave_idx_type *d = new octave_idx_type [len]; |
2828 | 412 |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
413 octave_idx_type ntot = bnda.length (); |
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
414 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
415 octave_idx_type k = 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
416 for (octave_idx_type i = 0; i < ntot; i++) |
10487 | 417 if (bnda.xelem (i)) |
418 d[k++] = i; | |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
419 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
420 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
421 |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
422 ext = d[k-1] + 1; |
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 } |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
425 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
426 idx_vector::idx_vector_rep::idx_vector_rep (const Sparse<bool>& bnda) |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
427 : data (0), len (bnda.nnz ()), ext (0), aowner (0), orig_dims () |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
428 { |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
429 const dim_vector dv = bnda.dims (); |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
430 |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
431 if (! dv.all_zero ()) |
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
432 orig_dims = ((dv.length () == 2 && dv(0) == 1) |
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
433 ? dim_vector (1, len) : dim_vector (len, 1)); |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
434 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
435 if (len != 0) |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
436 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
437 octave_idx_type *d = new octave_idx_type [len]; |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
438 |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
439 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
|
440 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
|
441 octave_idx_type nr = bnda.rows (); |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
442 |
16779
8fce0ed4894a
Specialize is_empty and numel methods for sparse matrices (debian bug #706376)
David Bateman <dbateman@free.fr>
parents:
15271
diff
changeset
|
443 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
|
444 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
|
445 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
|
446 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
|
447 |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
448 data = d; |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
449 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
450 ext = d[k-1] + 1; |
2828 | 451 } |
452 } | |
453 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
454 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
|
455 { |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
456 if (aowner) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
457 delete aowner; |
1 | 458 else |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
459 delete [] data; |
1560 | 460 } |
461 | |
5275 | 462 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
463 idx_vector::idx_vector_rep::checkelem (octave_idx_type n) const |
227 | 464 { |
465 if (n < 0 || n >= len) | |
466 { | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
467 gripe_invalid_index (); |
227 | 468 return 0; |
469 } | |
470 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
471 return xelem (n); |
1560 | 472 } |
473 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
474 idx_vector::idx_base_rep * |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
475 idx_vector::idx_vector_rep::sort_uniq_clone (bool uniq) |
1560 | 476 { |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
477 if (len == 0) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
478 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
479 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
480 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
481 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
482 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
483 // This is wrapped in auto_ptr so that we don't leak on out-of-memory. |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
484 std::auto_ptr<idx_vector_rep> new_rep ( |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
485 new idx_vector_rep (0, len, ext, orig_dims, DIRECT)); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
486 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
487 if (ext > len*xlog2 (1.0 + len)) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
488 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
489 // 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
|
490 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
|
491 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
492 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
493 std::copy (data, data + len, new_data); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
494 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
|
495 lsort.set_compare (ASCENDING); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
496 lsort.sort (new_data, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
497 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
498 if (uniq) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
499 { |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
500 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
|
501 - new_data; |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
502 new_rep->len = new_len; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
503 if (new_rep->orig_dims.length () == 2 && new_rep->orig_dims(0) == 1) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
504 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
|
505 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
506 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
|
507 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
508 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
509 else if (uniq) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
510 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
511 // 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
|
512 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
|
513 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
|
514 has[data[i]] = true; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
515 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
516 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
|
517 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
|
518 new_len += has[i]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
519 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
520 new_rep->len = new_len; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
521 if (new_rep->orig_dims.length () == 2 && new_rep->orig_dims(0) == 1) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
522 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
|
523 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
524 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
|
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 [new_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 if (has[i]) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
531 new_data[j++] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
532 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
533 else |
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 // Use two-pass bucket sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
536 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
|
537 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
|
538 cnt[data[i]]++; |
2966 | 539 |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
540 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
|
541 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
542 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
543 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
|
544 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
545 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
|
546 new_data[j++] = i; |
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 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
549 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
550 return new_rep.release (); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
551 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
552 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
553 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
554 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
|
555 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
556 // This is wrapped in auto_ptr so that we don't leak on out-of-memory. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
557 std::auto_ptr<idx_vector_rep> new_rep ( |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
558 new idx_vector_rep (0, len, ext, orig_dims, DIRECT)); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
559 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
560 if (ext > len*xlog2 (1.0 + 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 // 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
|
563 idx.clear (orig_dims); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
564 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
|
565 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
|
566 idx_data[i] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
567 |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
568 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
|
569 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
570 std::copy (data, data + len, new_data); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
571 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
572 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
|
573 lsort.set_compare (ASCENDING); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
574 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
|
575 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
576 else |
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 // Use two-pass bucket sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
579 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
|
580 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
581 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
|
582 cnt[data[i]]++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
583 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
584 idx.clear (orig_dims); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
585 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
|
586 |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
587 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
|
588 new_rep->data = new_data; |
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 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
|
591 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
592 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
|
593 cnt[i] = k; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
594 k += j; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
595 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
596 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
597 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
|
598 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
599 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
|
600 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
|
601 new_data[k] = j; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
602 idx_data[k] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
603 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
604 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
605 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
606 return new_rep.release (); |
209 | 607 } |
608 | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
609 std::ostream& |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
610 idx_vector::idx_vector_rep::print (std::ostream& os) const |
3079 | 611 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
612 os << '['; |
10487 | 613 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
614 for (octave_idx_type ii = 0; ii < len - 1; ii++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
615 os << data[ii] << ',' << ' '; |
10487 | 616 |
617 if (len > 0) | |
618 os << data[len-1]; os << ']'; | |
7425 | 619 |
1560 | 620 return os; |
621 } | |
622 | |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
623 Array<double> |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
624 idx_vector::idx_vector_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
625 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
626 Array<double> retval (orig_dims); |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
627 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
|
628 retval.xelem (i) = data[i] + 1; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
629 return retval; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
630 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
631 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
632 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
633 idx_vector::idx_vector_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
634 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
635 if (aowner) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
636 return *aowner; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
637 else |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
638 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
639 Array<octave_idx_type> retval (orig_dims); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
640 std::memcpy (retval.fortran_vec (), data, len*sizeof (octave_idx_type)); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
641 // Delete the old copy and share the data instead to save memory. |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
642 delete [] data; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
643 data = retval.fortran_vec (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
644 aowner = new Array<octave_idx_type> (retval); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
645 return retval; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
646 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
647 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
648 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
649 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_mask_rep); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
650 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
651 idx_vector::idx_mask_rep::idx_mask_rep (bool b) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
652 : data (0), len (b ? 1 : 0), ext (0), lsti (-1), lste (-1), |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
653 aowner (0), orig_dims (len, len) |
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 if (len != 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
656 { |
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
15018
diff
changeset
|
657 bool *d = new bool [1]; |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
658 d[0] = true; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
659 data = d; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
660 ext = 1; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
661 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
662 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
663 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
664 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
|
665 octave_idx_type nnz) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
666 : data (0), len (nnz), ext (bnda.numel ()), lsti (-1), lste (-1), |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
667 aowner (0), orig_dims () |
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 if (nnz < 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
670 len = bnda.nnz (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
671 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
672 // We truncate the extent as much as possible. For Matlab |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
673 // 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
|
674 while (ext > 0 && ! bnda(ext-1)) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
675 ext--; |
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 const dim_vector dv = bnda.dims (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
678 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
679 if (! dv.all_zero ()) |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
680 orig_dims = ((dv.length () == 2 && dv(0) == 1) |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
681 ? dim_vector (1, len) : dim_vector (len, 1)); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
682 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
683 aowner = new Array<bool> (bnda); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
684 data = bnda.data (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
685 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
686 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
687 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
|
688 { |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
689 if (aowner) |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
690 delete aowner; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
691 else |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
692 delete [] data; |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
693 } |
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 octave_idx_type |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
696 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
|
697 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
698 if (n == lsti + 1) |
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 lsti = n; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
701 while (! data[++lste]) ; |
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 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
704 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
705 lsti = n++; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
706 lste = -1; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
707 while (n > 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
708 if (data[++lste]) --n; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
709 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
710 return lste; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
711 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
712 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
713 octave_idx_type |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
714 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
|
715 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
716 if (n < 0 || n >= len) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
717 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
718 gripe_invalid_index (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
719 return 0; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
720 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
721 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
722 return xelem (n); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
723 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
724 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
725 std::ostream& |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
726 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
|
727 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
728 os << '['; |
10487 | 729 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
730 for (octave_idx_type ii = 0; ii < ext - 1; ii++) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
731 os << data[ii] << ',' << ' '; |
10487 | 732 |
733 if (ext > 0) | |
734 os << data[ext-1]; os << ']'; | |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
735 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
736 return os; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
737 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
738 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
739 Array<bool> |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
740 idx_vector::idx_mask_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
741 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
742 if (aowner) |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
743 return *aowner; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
744 else |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
745 { |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
746 Array<bool> retval (dim_vector (ext, 1)); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
747 for (octave_idx_type i = 0; i < ext; i++) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
748 retval.xelem (i) = data[i]; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
749 return retval; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
750 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
751 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
752 |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
753 Array<octave_idx_type> |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
754 idx_vector::idx_mask_rep::as_array (void) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
755 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
756 if (aowner) |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
18084
diff
changeset
|
757 return find::find (*aowner).reshape (orig_dims); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
758 else |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
759 { |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
760 Array<bool> retval (orig_dims); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
761 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
|
762 if (data[i]) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
763 retval.xelem (j++) = i; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
764 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
765 return retval; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
766 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
767 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
768 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
769 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
770 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
|
771 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
772 idx.clear (len, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
773 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
|
774 idx.xelem (i) = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
775 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
776 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
777 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
778 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
779 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
780 const idx_vector idx_vector::colon (new idx_vector::idx_colon_rep ()); |
1560 | 781 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
782 idx_vector::idx_vector (const Array<bool>& bnda) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
783 : rep (0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
784 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
785 // 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
|
786 static const int factor = (2 * sizeof (octave_idx_type)); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
787 octave_idx_type nnz = bnda.nnz (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
788 if (nnz <= bnda.numel () / factor) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
789 rep = new idx_vector_rep (bnda, nnz); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
790 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
791 rep = new idx_mask_rep (bnda, nnz); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
792 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
793 |
10487 | 794 bool |
795 idx_vector::maybe_reduce (octave_idx_type n, const idx_vector& j, | |
796 octave_idx_type nj) | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
797 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
798 bool reduced = false; |
1560 | 799 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
800 // Empty index always reduces. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
801 if (rep->length (n) == 0) |
1560 | 802 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
803 *this = idx_vector (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
804 return true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
805 } |
1560 | 806 |
8972
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
807 // Possibly skip singleton dims. |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
808 if (n == 1 && rep->is_colon_equiv (n)) |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
809 { |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
810 *this = j; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
811 return true; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
812 } |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
813 |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
814 if (nj == 1 && j.is_colon_equiv (nj)) |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
815 return true; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
816 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
817 switch (j.idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
818 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
819 case class_colon: |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
820 switch (rep->idx_class ()) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
821 { |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
822 case class_colon: |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
823 // (:,:) reduces to (:) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
824 reduced = true; |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
825 break; |
10487 | 826 |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
827 case class_scalar: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
828 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
829 // (i,:) reduces to a range. |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
830 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
831 octave_idx_type k = r->get_data (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
832 *this = new idx_range_rep (k, nj, n, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
833 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
834 } |
10487 | 835 break; |
836 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
837 case class_range: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
838 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
839 // (i:k:end,:) reduces to a range if i <= k and k divides n. |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
840 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
|
841 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
|
842 octave_idx_type l = r->length (n); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
843 octave_idx_type t = r->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
844 if (l*t == n) |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
845 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
846 *this = new idx_range_rep (s, l * nj, t, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
847 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
848 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
849 } |
10487 | 850 break; |
851 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
852 default: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
853 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
854 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
855 break; |
10487 | 856 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
857 case class_range: |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
858 switch (rep->idx_class ()) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
859 { |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
860 case class_colon: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
861 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
862 // (:,i:j) reduces to a range (the step must be 1) |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
863 idx_range_rep * rj = dynamic_cast<idx_range_rep *> (j.rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
864 if (rj->get_step () == 1) |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
865 { |
18084
8e056300994b
Follow coding convention of defining and initializing only 1 variable per line in liboctave.
Rik <rik@octave.org>
parents:
18083
diff
changeset
|
866 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
|
867 octave_idx_type lj = rj->length (nj); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
868 *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
|
869 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
870 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
871 } |
10487 | 872 break; |
873 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
874 case class_scalar: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
875 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
876 // (k,i:d:j) reduces to a range. |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
877 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
878 idx_range_rep * rj = dynamic_cast<idx_range_rep *> (j.rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
879 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
|
880 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
|
881 octave_idx_type lj = rj->length (nj); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
882 octave_idx_type tj = rj->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
883 *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
|
884 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
885 } |
10487 | 886 break; |
887 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
888 case class_range: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
889 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
890 // (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
|
891 // (ones (1, m), ones (1, n)) reduces to (ones (1, m*n)) |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
892 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
|
893 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
|
894 octave_idx_type l = r->length (n); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
895 octave_idx_type t = r->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
896 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
|
897 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
|
898 octave_idx_type lj = rj->length (nj); |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
899 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
|
900 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
|
901 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
902 *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
|
903 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
904 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
905 } |
10487 | 906 break; |
907 | |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
908 default: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
909 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
910 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
911 break; |
10487 | 912 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
913 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
914 switch (rep->idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
915 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
916 case class_scalar: |
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,j) reduces to a single index. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
919 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
920 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
921 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
|
922 *this = new idx_scalar_rep (k, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
923 reduced = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
924 } |
10487 | 925 break; |
926 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
927 case class_range: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
928 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
929 // (i:d:j,k) reduces to a range. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
930 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
931 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
|
932 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
|
933 octave_idx_type l = r->length (nj); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
934 octave_idx_type t = r->get_step (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
935 octave_idx_type k = rj->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
936 *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
|
937 reduced = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
938 } |
10487 | 939 break; |
940 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
941 case class_colon: |
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 // (:,k) reduces to a range. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
944 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
945 octave_idx_type k = rj->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
946 *this = new idx_range_rep (n * k, n, 1, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
947 reduced = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
948 } |
10487 | 949 break; |
950 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
951 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
952 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
953 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
954 break; |
10487 | 955 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
956 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
957 break; |
1560 | 958 } |
959 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
960 return reduced; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
961 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
962 |
8333 | 963 bool |
964 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
|
965 octave_idx_type& l, octave_idx_type& u) const |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
966 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
967 bool res = false; |
10487 | 968 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
969 switch (rep->idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
970 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
971 case class_colon: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
972 l = 0; u = n; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
973 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
974 break; |
10487 | 975 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
976 case class_range: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
977 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
978 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
979 if (r->get_step () == 1) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
980 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
981 l = r->get_start (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
982 u = l + r->length (n); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
983 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
984 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
985 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
986 break; |
10487 | 987 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
988 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
989 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
990 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
991 l = r->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
992 u = l + 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
993 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
994 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
995 break; |
10487 | 996 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
997 case class_mask: |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
998 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
999 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
|
1000 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
|
1001 octave_idx_type len = r->length (0); |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1002 if (ext == len) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1003 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1004 l = 0; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1005 u = len; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1006 res = true; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1007 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1008 } |
10487 | 1009 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1010 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1011 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1012 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1013 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1014 return res; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1015 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1016 |
9725 | 1017 octave_idx_type |
1018 idx_vector::increment (void) const | |
1019 { | |
1020 octave_idx_type retval = 0; | |
10487 | 1021 |
9725 | 1022 switch (rep->idx_class ()) |
1023 { | |
1024 case class_colon: | |
1025 retval = 1; | |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1026 break; |
10487 | 1027 |
9725 | 1028 case class_range: |
1029 retval = dynamic_cast<idx_range_rep *> (rep) -> get_step (); | |
1030 break; | |
10487 | 1031 |
9725 | 1032 case class_vector: |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1033 case class_mask: |
9725 | 1034 { |
1035 if (length (0) > 1) | |
1036 retval = elem (1) - elem (0); | |
1037 } | |
10487 | 1038 break; |
1039 | |
9757
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1040 default: |
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1041 break; |
9725 | 1042 } |
10487 | 1043 |
9725 | 1044 return retval; |
1045 } | |
1046 | |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1047 const octave_idx_type * |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1048 idx_vector::raw (void) |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1049 { |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1050 if (rep->idx_class () != class_vector) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10475
diff
changeset
|
1051 *this = idx_vector (as_array (), extent (0)); |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1052 |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1053 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); |
10487 | 1054 |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1055 assert (r != 0); |
10487 | 1056 |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1057 return r->get_data (); |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1058 } |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1059 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1060 void |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1061 idx_vector::copy_data (octave_idx_type *data) const |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1062 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1063 octave_idx_type len = rep->length (0); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1064 |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1065 switch (rep->idx_class ()) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1066 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1067 case class_colon: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1068 current_liboctave_error_handler ("colon not allowed"); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1069 break; |
10487 | 1070 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1071 case class_range: |
10487 | 1072 { |
1073 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
|
1074 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
|
1075 octave_idx_type step = r->get_step (); |
10487 | 1076 octave_idx_type i, j; |
1077 if (step == 1) | |
1078 for (i = start, j = start + len; i < j; i++) *data++ = i; | |
1079 else if (step == -1) | |
1080 for (i = start, j = start - len; i > j; i--) *data++ = i; | |
1081 else | |
1082 for (i = 0, j = start; i < len; i++, j += step) *data++ = j; | |
1083 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1084 break; |
10487 | 1085 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1086 case class_scalar: |
10487 | 1087 { |
1088 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); | |
1089 *data = r->get_data (); | |
1090 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1091 break; |
10487 | 1092 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1093 case class_vector: |
10487 | 1094 { |
1095 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); | |
1096 const octave_idx_type *rdata = r->get_data (); | |
1097 copy_or_memcpy (len, rdata, data); | |
1098 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1099 break; |
10487 | 1100 |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1101 case class_mask: |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1102 { |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1103 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep); |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1104 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
|
1105 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
|
1106 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
|
1107 if (mask[i]) |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1108 data[j++] = i; |
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1109 } |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1110 break; |
10702
c49911ab7ac7
implement missing copy_data case in idx_vector (bug #30099)
Jaroslav Hajek <highegg@gmail.com>
parents:
10620
diff
changeset
|
1111 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1112 default: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1113 assert (false); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1114 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1115 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1116 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1117 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1118 idx_vector |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1119 idx_vector::complement (octave_idx_type n) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1120 { |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1121 idx_vector retval; |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1122 if (extent (n) > n) |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1123 (*current_liboctave_error_handler) |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1124 ("internal error: out of range complement index requested"); |
3680 | 1125 |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1126 if (idx_class () == class_mask) |
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 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
|
1129 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
|
1130 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
|
1131 Array<bool> mask (dim_vector (n, 1)); |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1132 const bool *data = r->get_data (); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1133 bool *ndata = mask.fortran_vec (); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1134 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
|
1135 ndata[i] = ! data[i]; |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1136 for (octave_idx_type i = ext; i < n; i++) |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1137 ndata[i] = true; |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1138 retval = new idx_mask_rep (mask, n - nz); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1139 } |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1140 else |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1141 { |
11570
57632dea2446
attempt better backward compatibility for Array constructors
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1142 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
|
1143 fill (false, length (n), mask.fortran_vec ()); |
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1144 retval = idx_vector (mask); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1145 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1146 |
10491
077fef5da460
optimize null assignment with bool masks
Jaroslav Hajek <highegg@gmail.com>
parents:
10489
diff
changeset
|
1147 return retval; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1148 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1149 |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1150 bool |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1151 idx_vector::is_permutation (octave_idx_type n) const |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1152 { |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1153 bool retval = false; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1154 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1155 if (is_colon_equiv (n)) |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1156 retval = true; |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14138
diff
changeset
|
1157 else if (length(n) == n && extent(n) == n) |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1158 { |
8379
ad8ed668e0a4
allow initialized local buffers
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
1159 OCTAVE_LOCAL_BUFFER_INIT (bool, left, n, true); |
8367
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 retval = true; |
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 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
|
1164 { |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1165 octave_idx_type k = xelem (i); |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1166 if (left[k]) |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
1167 left[k] = false; |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1168 else |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1169 { |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1170 retval = false; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1171 break; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1172 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1173 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1174 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1175 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1176 return retval; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1177 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1178 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1179 idx_vector |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1180 idx_vector::inverse_permutation (octave_idx_type n) const |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1181 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1182 assert (n == length (n)); |
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 idx_vector retval; |
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 switch (idx_class ()) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1187 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1188 case class_range: |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1189 { |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1190 if (increment () == -1) |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1191 retval = sorted (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1192 else |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1193 retval = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1194 break; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1195 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1196 case class_vector: |
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 idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1199 const octave_idx_type *ri = r->get_data (); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1200 Array<octave_idx_type> idx (orig_dimensions ()); |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1201 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
|
1202 idx.xelem (ri[i]) = i; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1203 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
|
1204 break; |
10512
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1205 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1206 default: |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1207 retval = *this; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1208 break; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1209 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1210 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1211 return retval; |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1212 } |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1213 |
aac9f4265048
rewrite sparse indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
10491
diff
changeset
|
1214 idx_vector |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1215 idx_vector::unmask (void) const |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1216 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1217 if (idx_class () == class_mask) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1218 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1219 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1220 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
|
1221 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
|
1222 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
|
1223 octave_idx_type *idata = new octave_idx_type [len]; |
10487 | 1224 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1225 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
|
1226 if (data[i]) |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1227 idata[j++] = i; |
10487 | 1228 |
10620
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1229 ext = len > 0 ? idata[len - 1] + 1 : 0; |
10487 | 1230 |
1231 return new idx_vector_rep (idata, len, ext, r->orig_dimensions (), | |
1232 DIRECT); | |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1233 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1234 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1235 return *this; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1236 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1237 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1238 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
|
1239 double& scalar, Range& range, |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1240 Array<double>& array, Array<bool>& mask) const |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1241 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1242 iclass = idx_class (); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1243 switch (iclass) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1244 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1245 case class_colon: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1246 break; |
10487 | 1247 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1248 case class_range: |
10487 | 1249 { |
1250 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep); | |
1251 range = r->unconvert (); | |
1252 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1253 break; |
10487 | 1254 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1255 case class_scalar: |
10487 | 1256 { |
1257 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep); | |
1258 scalar = r->unconvert (); | |
1259 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1260 break; |
10487 | 1261 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1262 case class_vector: |
10487 | 1263 { |
1264 idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep); | |
1265 array = r->unconvert (); | |
1266 } | |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1267 break; |
10487 | 1268 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1269 case class_mask: |
10487 | 1270 { |
1271 idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep); | |
1272 mask = r->unconvert (); | |
1273 } | |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1274 break; |
10487 | 1275 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1276 default: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1277 assert (false); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1278 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1279 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1280 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1281 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1282 Array<octave_idx_type> |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1283 idx_vector::as_array (void) const |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1284 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1285 return rep->as_array (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1286 } |
10516
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1287 |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1288 bool |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1289 idx_vector::is_vector (void) const |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1290 { |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1291 return idx_class () != class_vector || orig_dimensions ().is_vector (); |
f0266ee4aabe
optimize some special indexing & assignment cases
Jaroslav Hajek <highegg@gmail.com>
parents:
10512
diff
changeset
|
1292 } |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1293 |
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1294 octave_idx_type |
8677
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8384
diff
changeset
|
1295 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
|
1296 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1297 if (! resize_ok && extent (z_len) > z_len) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1298 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1299 (*current_liboctave_error_handler) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1300 ("invalid matrix index = %d", extent (z_len)); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1301 rep->err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1302 chkerr (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1303 } |
1560 | 1304 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1305 return length (z_len); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1306 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1307 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11570
diff
changeset
|
1308 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1309 idx_vector::ones_count () const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1310 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1311 octave_idx_type n = 0; |
10487 | 1312 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1313 if (is_colon ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1314 n = 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1315 else |
10487 | 1316 { |
1317 for (octave_idx_type i = 0; i < length (1); i++) | |
1318 if (xelem (i) == 0) | |
1319 n++; | |
1320 } | |
1321 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1322 return n; |
1 | 1323 } |
1324 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1325 // Instantiate the octave_int constructors we want. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1326 #define INSTANTIATE_SCALAR_VECTOR_REP_CONST(T) \ |
8319
c374691576f6
Fix for MSVC compilation
Michael Goffioul <michael.goffioul@gmail.com>
parents:
8301
diff
changeset
|
1327 template OCTAVE_API idx_vector::idx_scalar_rep::idx_scalar_rep (T); \ |
c374691576f6
Fix for MSVC compilation
Michael Goffioul <michael.goffioul@gmail.com>
parents:
8301
diff
changeset
|
1328 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
|
1329 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1330 INSTANTIATE_SCALAR_VECTOR_REP_CONST (float) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1331 INSTANTIATE_SCALAR_VECTOR_REP_CONST (double) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1332 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int8) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1333 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int16) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1334 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int32) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1335 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int64) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1336 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint8) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1337 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint16) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1338 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint32) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1339 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
|
1340 |
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1341 /* |
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1342 |
15018
3d8ace26c5b4
maint: Use Octave coding conventions for cuddled parentheses in liboctave/.
Rik <rik@octave.org>
parents:
14138
diff
changeset
|
1343 %!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
|
1344 %!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
|
1345 |
6fb954475e21
fix off-by-1 error in idx_vector (bug #29851)
Jaroslav Hajek <highegg@gmail.com>
parents:
10516
diff
changeset
|
1346 */ |