Mercurial > octave-nkf
annotate liboctave/idx-vector.cc @ 10486:4e64fbbd5c58
allow non-integer values in ranges used for array indexing
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Fri, 02 Apr 2010 14:28:34 -0400 |
parents | ded9beac7582 |
children | 942386d6d1a5 |
rev | line source |
---|---|
1 | 1 /* |
2 | |
8920 | 3 Copyright (C) 2008, 2009 Jaroslav Hajek |
7017 | 4 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, |
5 2003, 2004, 2005, 2006, 2007 John W. Eaton | |
10277
703038d648f1
update some copyright notices
Jaroslav Hajek <highegg@gmail.com>
parents:
10273
diff
changeset
|
6 Copyright (C) 2009, 2010 VZLU Prague |
1 | 7 |
8 This file is part of Octave. | |
9 | |
10 Octave is free software; you can redistribute it and/or modify it | |
11 under the terms of the GNU General Public License as published by the | |
7016 | 12 Free Software Foundation; either version 3 of the License, or (at your |
13 option) any later version. | |
1 | 14 |
15 Octave is distributed in the hope that it will be useful, but WITHOUT | |
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
18 for more details. | |
19 | |
20 You should have received a copy of the GNU General Public License | |
7016 | 21 along with Octave; see the file COPYING. If not, see |
22 <http://www.gnu.org/licenses/>. | |
1 | 23 |
24 */ | |
25 | |
240 | 26 #ifdef HAVE_CONFIG_H |
1192 | 27 #include <config.h> |
1 | 28 #endif |
29 | |
1343 | 30 #include <cstdlib> |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
31 #include <memory> |
1343 | 32 |
3503 | 33 #include <iostream> |
164 | 34 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
35 #include "idx-vector.h" |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
36 #include "Array.h" |
10370
9c4daf174387
implement IDs for common liboctave exceptions
Jaroslav Hajek <highegg@gmail.com>
parents:
10339
diff
changeset
|
37 #include "Array-util.h" |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
38 #include "Sparse.h" |
1352 | 39 #include "Range.h" |
40 | |
8379
ad8ed668e0a4
allow initialized local buffers
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
41 #include "oct-locbuf.h" |
1560 | 42 #include "lo-error.h" |
2500 | 43 #include "lo-mappers.h" |
1 | 44 |
8333 | 45 static void |
46 gripe_invalid_range (void) | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
47 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
48 (*current_liboctave_error_handler) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
49 ("invalid range used as index."); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
50 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
51 |
8333 | 52 static void |
53 gripe_index_out_of_range (void) | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
54 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
55 (*current_liboctave_error_handler) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
56 ("internal error: idx_vector index out of range."); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
57 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
58 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
59 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
60 idx_vector::idx_base_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
61 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
62 (*current_liboctave_error_handler) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
63 ("internal error: as_array not allowed for this index class."); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
64 |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
65 return Array<octave_idx_type> (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
66 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
67 |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
68 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
|
69 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
70 idx_vector::idx_colon_rep::idx_colon_rep (char c) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
71 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
72 if (c != ':') |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
73 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
74 (*current_liboctave_error_handler) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
75 ("internal error: invalid character converted to idx_vector. Must be ':'."); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
76 err = true; |
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 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
80 octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
81 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
|
82 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
83 if (i < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
84 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
85 gripe_index_out_of_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
86 return 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
87 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
88 else |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
89 return i; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
90 } |
1560 | 91 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
92 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
93 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
|
94 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
95 (*current_liboctave_error_handler) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
96 ("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
|
97 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
98 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
99 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
100 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
101 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
102 std::ostream& |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
103 idx_vector::idx_colon_rep::print (std::ostream& os) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
104 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
105 return os << ":"; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
106 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
107 |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
108 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
|
109 |
10258 | 110 idx_vector::idx_range_rep::idx_range_rep (octave_idx_type _start, |
111 octave_idx_type _limit, | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
112 octave_idx_type _step) |
10258 | 113 : 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
|
114 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
115 if (len < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
116 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
117 gripe_invalid_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
118 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
119 } |
9757
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
120 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
|
121 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
122 gripe_invalid_index (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
123 err = true; |
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 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
127 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
|
128 : start (0), len (r.nelem ()), step (1) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
129 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
130 if (len < 0) |
1 | 131 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
132 gripe_invalid_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
133 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
134 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
135 else if (len > 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
136 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
137 if (r.all_elements_are_ints ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
138 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
139 start = static_cast<octave_idx_type> (r.base ()) - 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
140 step = static_cast<octave_idx_type> (r.inc ()); |
9124
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
141 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
|
142 { |
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
143 gripe_invalid_index (); |
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
144 err = true; |
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
145 } |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
146 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
147 else |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
148 { |
9124
47f19c11b558
fix checking valid range subscripts
Jaroslav Hajek <highegg@gmail.com>
parents:
9045
diff
changeset
|
149 gripe_invalid_index (); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
150 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
151 } |
1 | 152 } |
153 } | |
154 | |
5275 | 155 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
156 idx_vector::idx_range_rep::checkelem (octave_idx_type i) const |
1 | 157 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
158 if (i < 0 || i >= len) |
4732 | 159 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
160 gripe_index_out_of_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
161 return 0; |
4732 | 162 } |
163 else | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
164 return start + i*step; |
3928 | 165 } |
166 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
167 idx_vector::idx_base_rep * |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
168 idx_vector::idx_range_rep::sort_uniq_clone (bool) |
2500 | 169 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
170 if (step < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
171 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
|
172 else |
2500 | 173 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
174 count++; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
175 return this; |
2500 | 176 } |
1 | 177 } |
178 | |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
179 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
180 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
|
181 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
182 if (step < 0 && len > 0) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
183 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
184 idx.clear (1, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
185 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
|
186 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
|
187 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
|
188 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
189 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
190 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
191 idx.clear (1, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
192 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
|
193 idx.xelem (i) = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
194 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
195 return this; |
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 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
198 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
199 std::ostream& |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
200 idx_vector::idx_range_rep::print (std::ostream& os) const |
1 | 201 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
202 os << start << ':' << step << ':' << start + len*step; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
203 return os; |
1560 | 204 } |
205 | |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
206 Range |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
207 idx_vector::idx_range_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
208 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
209 return Range (static_cast<double> (start+1), |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
210 static_cast<double> (step), len); |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
211 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
212 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
213 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
214 idx_vector::idx_range_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
215 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
216 Array<octave_idx_type> retval (dim_vector (1, len)); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
217 for (octave_idx_type i = 0; i < len; i++) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10475
diff
changeset
|
218 retval.xelem (i) = start + i*step; |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
219 |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
220 return retval; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
221 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
222 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
223 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
224 convert_index (octave_idx_type i, bool& conv_error, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
225 octave_idx_type& ext) |
1560 | 226 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
227 if (i <= 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
228 conv_error = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
229 if (ext < i) ext = i; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
230 return i - 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
231 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
232 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
233 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
234 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
|
235 { |
9007
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
236 octave_idx_type i = static_cast<octave_idx_type> (x); |
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
237 if (static_cast<double> (i) != x) |
7e31df9a0334
simplify double->int conversion in indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8972
diff
changeset
|
238 conv_error = true; |
1 | 239 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
240 return convert_index (i, conv_error, ext); |
1 | 241 } |
242 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
243 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
244 convert_index (float x, bool& conv_error, octave_idx_type& ext) |
1 | 245 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
246 return convert_index (static_cast<double> (x), conv_error, ext); |
1 | 247 } |
248 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
249 template <class T> |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
250 inline octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
251 convert_index (octave_int<T> x, bool& conv_error, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
252 octave_idx_type& ext) |
3928 | 253 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
254 octave_idx_type i = octave_int<octave_idx_type> (x).value (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
255 return convert_index (i, conv_error, ext); |
3928 | 256 } |
257 | |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
258 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
|
259 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
260 template <class T> |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
261 idx_vector::idx_scalar_rep::idx_scalar_rep (T x) |
3928 | 262 { |
10101
b51848e95e4b
cleanups to avoid valgrind warnings
John W. Eaton <jwe@octave.org>
parents:
10042
diff
changeset
|
263 octave_idx_type dummy = 0; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
264 data = convert_index (x, err, dummy); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
265 if (err) gripe_invalid_index (); |
3928 | 266 } |
267 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
268 idx_vector::idx_scalar_rep::idx_scalar_rep (octave_idx_type i) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
269 : data (i) |
1560 | 270 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
271 if (data < 0) |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
272 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
273 gripe_invalid_index (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
274 err = true; |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
275 } |
2828 | 276 } |
277 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
278 octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
279 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
|
280 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
281 if (i != 0) gripe_index_out_of_range (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
282 return data; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
283 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
284 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
285 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
286 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
|
287 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
288 idx.clear (1, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
289 idx.fill (0); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
290 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
291 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
292 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
293 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
294 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
|
295 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
296 return os << data; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
297 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
298 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
299 double |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
300 idx_vector::idx_scalar_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
301 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
302 return data + 1; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
303 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
304 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
305 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
306 idx_vector::idx_scalar_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
307 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
308 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
|
309 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
310 |
8680
a2bcd96b9344
use allocators for idx_vector_rep subclasses
Jaroslav Hajek <highegg@gmail.com>
parents:
8677
diff
changeset
|
311 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
|
312 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
313 template <class T> |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
314 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
|
315 : 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
|
316 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
317 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
318 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
319 octave_idx_type *d = new octave_idx_type[len]; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
320 for (octave_idx_type i = 0; i < len; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
321 d[i] = convert_index (nda.xelem (i), err, ext); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
322 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
323 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
324 if (err) gripe_invalid_index (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
325 } |
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 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
328 // 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
|
329 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
330 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
331 : data (inda.data ()), len (inda.numel ()), ext (0), |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
332 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ()) |
2828 | 333 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
334 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
335 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
336 octave_idx_type max = -1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
337 for (octave_idx_type i = 0; i < len; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
338 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
339 octave_idx_type k = inda.xelem (i); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
340 if (k < 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
341 err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
342 else if (k > max) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
343 max = k; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
344 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
345 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
346 ext = max + 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
347 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
348 if (err) gripe_invalid_index (); |
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 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
351 |
10285
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
352 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
|
353 octave_idx_type _ext, direct) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
354 : data (inda.data ()), len (inda.numel ()), ext (_ext), |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
355 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ()) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
356 { |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
357 // No checking. |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
358 if (ext < 0) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
359 { |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
360 octave_idx_type max = -1; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
361 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
|
362 if (data[i] > max) |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
363 max = data[i]; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
364 |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
365 ext = max + 1; |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
366 } |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
367 } |
22a7913bbeb5
optimize return values of find and sort
Jaroslav Hajek <highegg@gmail.com>
parents:
10277
diff
changeset
|
368 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
369 idx_vector::idx_vector_rep::idx_vector_rep (bool b) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
370 : 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
|
371 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
372 if (len != 0) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
373 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
374 octave_idx_type *d = new octave_idx_type [1]; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
375 d[0] = 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
376 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
377 ext = 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
378 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
379 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
380 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
381 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
|
382 octave_idx_type nnz) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
383 : 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
|
384 { |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
385 if (nnz < 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
386 len = bnda.nnz (); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
387 |
9045
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
388 const dim_vector dv = bnda.dims (); |
7774
ce52af0e4a10
all false logical indexing fix
David Bateman <dbateman@free.fr>
parents:
7727
diff
changeset
|
389 |
9045
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
390 if (! dv.all_zero ()) |
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
391 orig_dims = ((dv.length () == 2 && dv(0) == 1) |
ac0a23e9f5c5
more compatible indexing by logical empty matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9007
diff
changeset
|
392 ? dim_vector (1, len) : dim_vector (len, 1)); |
7774
ce52af0e4a10
all false logical indexing fix
David Bateman <dbateman@free.fr>
parents:
7727
diff
changeset
|
393 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
394 if (len != 0) |
2828 | 395 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
396 octave_idx_type *d = new octave_idx_type [len]; |
2828 | 397 |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
398 octave_idx_type ntot = bnda.length (); |
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
399 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
400 octave_idx_type k = 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
401 for (octave_idx_type i = 0; i < ntot; i++) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10285
diff
changeset
|
402 if (bnda.xelem (i)) d[k++] = i; |
7572
85da2ab0c6fd
logical indexing compatibility fixes
John W. Eaton <jwe@octave.org>
parents:
7425
diff
changeset
|
403 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
404 data = d; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
405 |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
406 ext = d[k-1] + 1; |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
407 } |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
408 } |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
409 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
410 idx_vector::idx_vector_rep::idx_vector_rep (const Sparse<bool>& bnda) |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
411 : data (0), len (0), ext (0), aowner (0), orig_dims () |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
412 { |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
413 for (octave_idx_type i = 0, l = bnda.nnz (); i < l; i++) |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
414 if (bnda.data (i)) len++; |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
415 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
416 dim_vector dv = bnda.dims (); |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
417 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
418 orig_dims = ((dv.length () == 2 && dv(0) == 1) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10285
diff
changeset
|
419 ? dim_vector (1, len) : orig_dims = dim_vector (len, 1)); |
8384
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
420 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
421 if (len != 0) |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
422 { |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
423 octave_idx_type *d = new octave_idx_type [len]; |
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 octave_idx_type nnz = bnda.nnz (); |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
426 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
427 octave_idx_type k = 0; |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
428 // FIXME: I hope this is OK, i.e. the element iterated this way are correctly ordered. |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
429 for (octave_idx_type i = 0; i < nnz; i++) |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
430 { |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
431 if (bnda.data (i)) |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
432 d[k++] = bnda.cidx (i) + bnda.rows () * bnda.ridx (i); |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
433 } |
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 data = d; |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
436 |
a99b9113c58c
optimize sparse bool indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8379
diff
changeset
|
437 ext = d[k-1] + 1; |
2828 | 438 } |
439 } | |
440 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
441 idx_vector::idx_vector_rep::~idx_vector_rep (void) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
442 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
443 if (aowner) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
444 delete aowner; |
1 | 445 else |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
446 delete [] data; |
1560 | 447 } |
448 | |
5275 | 449 octave_idx_type |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
450 idx_vector::idx_vector_rep::checkelem (octave_idx_type n) const |
227 | 451 { |
452 if (n < 0 || n >= len) | |
453 { | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
454 gripe_invalid_index (); |
227 | 455 return 0; |
456 } | |
457 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
458 return xelem (n); |
1560 | 459 } |
460 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
461 idx_vector::idx_base_rep * |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
462 idx_vector::idx_vector_rep::sort_uniq_clone (bool uniq) |
1560 | 463 { |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
464 if (len == 0) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
465 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
466 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
467 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
468 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
469 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
470 // 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
|
471 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
|
472 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
|
473 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
474 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
|
475 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
476 // 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
|
477 octave_idx_type *new_data = new octave_idx_type[len]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
478 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
479 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
480 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
|
481 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
|
482 lsort.set_compare (ASCENDING); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
483 lsort.sort (new_data, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
484 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
485 if (uniq) |
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 octave_idx_type new_len = std::unique (new_data, new_data + len) - new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
488 new_rep->len = new_len; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
489 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
|
490 new_rep->orig_dims = dim_vector (1, new_len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
491 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
492 new_rep->orig_dims = dim_vector (new_len, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
493 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
494 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
495 else if (uniq) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
496 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
497 // Use two-pass bucket sort (only a mask array needed). |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
498 OCTAVE_LOCAL_BUFFER_INIT (bool, has, ext, false); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
499 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
500 has[data[i]] = true; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
501 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
502 octave_idx_type new_len = 0; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
503 for (octave_idx_type i = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
504 new_len += has[i]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
505 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
506 new_rep->len = new_len; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
507 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
|
508 new_rep->orig_dims = dim_vector (1, new_len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
509 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
510 new_rep->orig_dims = dim_vector (new_len, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
511 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
512 octave_idx_type *new_data = new octave_idx_type[new_len]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
513 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
514 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
515 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
516 if (has[i]) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
517 new_data[j++] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
518 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
519 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
520 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
521 // Use two-pass bucket sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
522 OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, ext, 0); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
523 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
524 cnt[data[i]]++; |
2966 | 525 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
526 octave_idx_type *new_data = new octave_idx_type[len]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
527 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
528 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
529 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
530 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
531 for (octave_idx_type k = 0; k < cnt[i]; k++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
532 new_data[j++] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
533 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
534 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
535 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
536 return new_rep.release (); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
537 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
538 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
539 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
540 idx_vector::idx_vector_rep::sort_idx (Array<octave_idx_type>& idx) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
541 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
542 // 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
|
543 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
|
544 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
|
545 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
546 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
|
547 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
548 // Use standard sort via octave_sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
549 idx.clear (orig_dims); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
550 octave_idx_type *idx_data = idx.fortran_vec (); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
551 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
552 idx_data[i] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
553 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
554 octave_idx_type *new_data = new octave_idx_type [len]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
555 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
556 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
|
557 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
558 octave_sort<octave_idx_type> lsort; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
559 lsort.set_compare (ASCENDING); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
560 lsort.sort (new_data, idx_data, len); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
561 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
562 else |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
563 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
564 // Use two-pass bucket sort. |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
565 OCTAVE_LOCAL_BUFFER_INIT (octave_idx_type, cnt, ext, 0); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
566 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
567 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
568 cnt[data[i]]++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
569 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
570 idx.clear (orig_dims); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
571 octave_idx_type *idx_data = idx.fortran_vec (); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
572 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
573 octave_idx_type *new_data = new octave_idx_type [len]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
574 new_rep->data = new_data; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
575 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
576 for (octave_idx_type i = 0, k = 0; i < ext; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
577 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
578 octave_idx_type j = cnt[i]; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
579 cnt[i] = k; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
580 k += j; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
581 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
582 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
583 for (octave_idx_type i = 0; i < len; i++) |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
584 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
585 octave_idx_type j = data[i], k = cnt[j]++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
586 new_data[k] = j; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
587 idx_data[k] = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
588 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
589 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
590 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
591 return new_rep.release (); |
209 | 592 } |
593 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
594 std::ostream& |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
595 idx_vector::idx_vector_rep::print (std::ostream& os) const |
3079 | 596 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
597 os << '['; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
598 for (octave_idx_type ii = 0; ii < len - 1; ii++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
599 os << data[ii] << ',' << ' '; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
600 if (len > 0) os << data[len-1]; os << ']'; |
7425 | 601 |
1560 | 602 return os; |
603 } | |
604 | |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
605 Array<double> |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
606 idx_vector::idx_vector_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
607 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
608 Array<double> retval (orig_dims); |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
609 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
|
610 retval.xelem (i) = data[i] + 1; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
611 return retval; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
612 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
613 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
614 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
615 idx_vector::idx_vector_rep::as_array (void) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
616 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
617 if (aowner) |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
618 return *aowner; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
619 else |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
620 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
621 Array<octave_idx_type> retval (orig_dims); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
622 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
|
623 // 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
|
624 delete [] data; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
625 data = retval.fortran_vec (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
626 aowner = new Array<octave_idx_type> (retval); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
627 return retval; |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
628 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
629 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
630 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
631 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_mask_rep); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
632 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
633 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
|
634 : 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
|
635 aowner (0), orig_dims (len, len) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
636 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
637 if (len != 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
638 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
639 bool *d = new bool [1]; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
640 d[0] = true; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
641 data = d; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
642 ext = 1; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
643 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
644 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
645 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
646 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
|
647 octave_idx_type nnz) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
648 : 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
|
649 aowner (0), orig_dims () |
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 if (nnz < 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
652 len = bnda.nnz (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
653 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
654 // 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
|
655 // 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
|
656 while (ext > 0 && ! bnda(ext-1)) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
657 ext--; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
658 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
659 const dim_vector dv = bnda.dims (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
660 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
661 if (! dv.all_zero ()) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
662 orig_dims = ((dv.length () == 2 && dv(0) == 1) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
663 ? dim_vector (1, len) : dim_vector (len, 1)); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
664 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
665 aowner = new Array<bool> (bnda); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
666 data = bnda.data (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
667 } |
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 idx_vector::idx_mask_rep::~idx_mask_rep (void) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
670 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
671 if (aowner) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
672 delete aowner; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
673 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
674 delete [] data; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
675 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
676 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
677 octave_idx_type |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
678 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
|
679 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
680 if (n == lsti + 1) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
681 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
682 lsti = n; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
683 while (! data[++lste]) ; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
684 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
685 else |
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 lsti = n++; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
688 lste = -1; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
689 while (n > 0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
690 if (data[++lste]) --n; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
691 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
692 return lste; |
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::checkelem (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 < 0 || n >= len) |
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 gripe_invalid_index (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
701 return 0; |
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 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
704 return xelem (n); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
705 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
706 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
707 std::ostream& |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
708 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
|
709 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
710 os << '['; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
711 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
|
712 os << data[ii] << ',' << ' '; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
713 if (ext > 0) os << data[ext-1]; os << ']'; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
714 |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
715 return os; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
716 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
717 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
718 Array<bool> |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
719 idx_vector::idx_mask_rep::unconvert (void) const |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
720 { |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
721 if (aowner) |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
722 return *aowner; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
723 else |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
724 { |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
725 Array<bool> retval (ext, 1); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
726 for (octave_idx_type i = 0; i < ext; i++) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
727 retval.xelem (i) = data[i]; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
728 return retval; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
729 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
730 } |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
731 |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
732 Array<octave_idx_type> |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
733 idx_vector::idx_mask_rep::as_array (void) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
734 { |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
735 if (aowner) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
736 return aowner->find ().reshape (orig_dims); |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
737 else |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
738 { |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
739 Array<bool> retval (orig_dims); |
10425
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
740 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
|
741 if (data[i]) |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
742 retval.xelem (j++) = i; |
0677c5d80b77
rewrite 1D sparse indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
10370
diff
changeset
|
743 |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
744 return retval; |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
745 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
746 } |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
747 |
10273
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
748 idx_vector::idx_base_rep * |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
749 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
|
750 { |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
751 idx.clear (len, 1); |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
752 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
|
753 idx.xelem (i) = i; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
754 |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
755 count++; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
756 return this; |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
757 } |
3a8c13b71612
implement special-case optimization for sort of index vectors
Jaroslav Hajek <highegg@gmail.com>
parents:
10258
diff
changeset
|
758 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
759 const idx_vector idx_vector::colon (new idx_vector::idx_colon_rep ()); |
1560 | 760 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
761 idx_vector::idx_vector (const Array<bool>& bnda) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
762 : rep (0) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
763 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
764 // 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
|
765 static const int factor = (2 * sizeof (octave_idx_type)); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
766 octave_idx_type nnz = bnda.nnz (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
767 if (nnz <= bnda.numel () / factor) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
768 rep = new idx_vector_rep (bnda, nnz); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
769 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
770 rep = new idx_mask_rep (bnda, nnz); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
771 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
772 |
10486
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
773 idx_vector::idx_vector (const Range& r) |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
774 : rep (0) |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
775 { |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
776 if (r.nelem () > 0 && ! r.all_elements_are_ints ()) |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
777 { |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
778 gripe_invalid_index (false); |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
779 |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
780 Matrix m = r.matrix_value (); |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
781 |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
782 rep = new idx_vector_rep (m.map (xround)); |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
783 } |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
784 else |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
785 rep = new idx_range_rep (r); |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
786 |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
787 chkerr (); |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
788 } |
4e64fbbd5c58
allow non-integer values in ranges used for array indexing
John W. Eaton <jwe@octave.org>
parents:
10479
diff
changeset
|
789 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
790 bool idx_vector::maybe_reduce (octave_idx_type n, const idx_vector& j, |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
791 octave_idx_type nj) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
792 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
793 bool reduced = false; |
1560 | 794 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
795 // Empty index always reduces. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
796 if (rep->length (n) == 0) |
1560 | 797 { |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
798 *this = idx_vector (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
799 return true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
800 } |
1560 | 801 |
8972
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
802 // Possibly skip singleton dims. |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
803 if (n == 1 && rep->is_colon_equiv (n)) |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
804 { |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
805 *this = j; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
806 return true; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
807 } |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
808 |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
809 if (nj == 1 && j.is_colon_equiv (nj)) |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
810 return true; |
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
811 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
812 switch (j.idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
813 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
814 case class_colon: |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
815 switch (rep->idx_class ()) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
816 { |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
817 case class_colon: |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
818 // (:,:) reduces to (:) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
819 reduced = true; |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
820 break; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
821 case class_scalar: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
822 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
823 // (i,:) reduces to a range. |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
824 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
825 octave_idx_type k = r->get_data (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
826 *this = new idx_range_rep (k, nj, n, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
827 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
828 break; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
829 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
830 case class_range: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
831 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
832 // (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
|
833 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
834 octave_idx_type s = r->get_start (), l = r->length (n); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
835 octave_idx_type t = r->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
836 if (l*t == n) |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
837 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
838 *this = new idx_range_rep (s, l * nj, t, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
839 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
840 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
841 break; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
842 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
843 default: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
844 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
845 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
846 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
847 case class_range: |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
848 switch (rep->idx_class ()) |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
849 { |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
850 case class_colon: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
851 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
852 // (:,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
|
853 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
|
854 if (rj->get_step () == 1) |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
855 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
856 octave_idx_type sj = rj->get_start (), lj = rj->length (nj); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
857 *this = new idx_range_rep (sj * n, lj * n, 1, DIRECT); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
858 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
859 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
860 break; |
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 case class_scalar: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
863 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
864 // (k,i:d:j) reduces to a range. |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
865 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
866 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
|
867 octave_idx_type k = r->get_data (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
868 octave_idx_type sj = rj->get_start (), lj = rj->length (nj); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
869 octave_idx_type tj = rj->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
870 *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
|
871 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
872 break; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
873 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
874 case class_range: |
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 // (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
|
877 // (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
|
878 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
879 octave_idx_type s = r->get_start (), l = r->length (n); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
880 octave_idx_type t = r->get_step (); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
881 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
|
882 octave_idx_type sj = rj->get_start (), lj = rj->length (nj); |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
883 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
|
884 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
|
885 { |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
886 *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
|
887 reduced = true; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
888 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
889 break; |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
890 } |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
891 default: |
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
892 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
893 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
894 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
895 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
896 switch (rep->idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
897 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
898 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
899 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
900 // (i,j) reduces to a single index. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
901 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
902 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
|
903 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
|
904 *this = new idx_scalar_rep (k, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
905 reduced = true; |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
906 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
907 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
908 case class_range: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
909 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
910 // (i:d:j,k) reduces to a range. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
911 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
912 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
|
913 octave_idx_type s = r->get_start (), l = r->length (nj); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
914 octave_idx_type t = r->get_step (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
915 octave_idx_type k = rj->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
916 *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
|
917 reduced = true; |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
918 break; |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
919 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
920 case class_colon: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
921 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
922 // (:,k) reduces to a range. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
923 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
|
924 octave_idx_type k = rj->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
925 *this = new idx_range_rep (n * k, n, 1, DIRECT); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
926 reduced = true; |
9772
3ac8ea48279b
improve index reduction rules
Jaroslav Hajek <highegg@gmail.com>
parents:
9757
diff
changeset
|
927 break; |
8290
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 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
930 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
931 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
932 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
933 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
934 break; |
1560 | 935 } |
936 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
937 return reduced; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
938 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
939 |
8333 | 940 bool |
941 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
|
942 octave_idx_type& l, octave_idx_type& u) const |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
943 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
944 bool res = false; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
945 switch (rep->idx_class ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
946 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
947 case class_colon: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
948 l = 0; u = n; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
949 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
950 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
951 case class_range: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
952 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
953 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
954 if (r->get_step () == 1) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
955 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
956 l = r->get_start (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
957 u = l + r->length (n); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
958 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
959 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
960 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
961 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
962 case class_scalar: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
963 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
964 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
965 l = r->get_data (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
966 u = l + 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
967 res = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
968 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
969 break; |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
970 case class_mask: |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
971 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
972 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
|
973 octave_idx_type ext = r->extent (0), len = r->length (0); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
974 if (ext == len) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
975 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
976 l = 0; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
977 u = len; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
978 res = true; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
979 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
980 } |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
981 default: |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
982 break; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
983 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
984 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
985 return res; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
986 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
987 |
9725 | 988 octave_idx_type |
989 idx_vector::increment (void) const | |
990 { | |
991 octave_idx_type retval = 0; | |
992 switch (rep->idx_class ()) | |
993 { | |
994 case class_colon: | |
995 retval = 1; | |
996 case class_range: | |
997 retval = dynamic_cast<idx_range_rep *> (rep) -> get_step (); | |
998 break; | |
999 case class_vector: | |
1000 { | |
1001 if (length (0) > 1) | |
1002 retval = elem (1) - elem (0); | |
1003 } | |
9757
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1004 default: |
95ad9c2a27e2
fix idx_vector construction checks
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1005 break; |
9725 | 1006 } |
1007 return retval; | |
1008 } | |
1009 | |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1010 const octave_idx_type * |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1011 idx_vector::raw (void) |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1012 { |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1013 if (rep->idx_class () != class_vector) |
10479
ded9beac7582
optimize sparse matrix assembly
Jaroslav Hajek <highegg@gmail.com>
parents:
10475
diff
changeset
|
1014 *this = idx_vector (as_array (), extent (0)); |
10475
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1015 |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1016 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1017 assert (r != 0); |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1018 return r->get_data (); |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1019 } |
739109ef88ee
helper idx_vector methods
Jaroslav Hajek <highegg@gmail.com>
parents:
10425
diff
changeset
|
1020 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1021 void |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1022 idx_vector::copy_data (octave_idx_type *data) const |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1023 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1024 octave_idx_type len = rep->length (0); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1025 |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1026 switch (rep->idx_class ()) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1027 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1028 case class_colon: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1029 current_liboctave_error_handler ("colon not allowed"); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1030 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1031 case class_range: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1032 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1033 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1034 octave_idx_type start = r->get_start (), step = r->get_step (); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1035 octave_idx_type i, j; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1036 if (step == 1) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1037 for (i = start, j = start + len; i < j; i++) *data++ = i; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1038 else if (step == -1) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1039 for (i = start, j = start - len; i > j; i--) *data++ = i; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1040 else |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1041 for (i = 0, j = start; i < len; i++, j += step) *data++ = j; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1042 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1043 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1044 case class_scalar: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1045 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1046 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1047 *data = r->get_data (); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1048 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1049 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1050 case class_vector: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1051 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1052 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1053 const octave_idx_type *rdata = r->get_data (); |
9780
6dafc60dde31
rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9773
diff
changeset
|
1054 copy_or_memcpy (len, rdata, data); |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1055 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1056 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1057 default: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1058 assert (false); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1059 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1060 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1061 |
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 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1064 idx_vector |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1065 idx_vector::complement (octave_idx_type n) const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1066 { |
8379
ad8ed668e0a4
allow initialized local buffers
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
1067 OCTAVE_LOCAL_BUFFER_INIT (bool, left, n, true); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1068 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1069 octave_idx_type cnt = n; |
3680 | 1070 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1071 for (octave_idx_type i = 0, len = length (); i < len; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1072 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1073 octave_idx_type k = xelem (i); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1074 if (k < n && left[k]) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1075 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1076 left[k] = false; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1077 cnt--; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1078 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1079 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1080 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1081 octave_idx_type len = cnt, *data = new octave_idx_type[len]; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1082 for (octave_idx_type i = 0, j = 0; i < n; i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1083 if (left[i]) data[j++] = i; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1084 |
8301
f7d44b6a74df
fix out-of-bounds checks in null assignments
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
1085 return new idx_vector_rep (data, len, |
f7d44b6a74df
fix out-of-bounds checks in null assignments
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
1086 len ? data[len-1]+1 : 0, |
f7d44b6a74df
fix out-of-bounds checks in null assignments
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
1087 dim_vector (1, len), DIRECT); |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1088 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1089 |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1090 bool |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1091 idx_vector::is_permutation (octave_idx_type n) const |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1092 { |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1093 bool retval = false; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1094 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1095 if (is_colon_equiv (n)) |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1096 retval = true; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1097 else if (length (n) == n && extent(n) == n) |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1098 { |
8379
ad8ed668e0a4
allow initialized local buffers
Jaroslav Hajek <highegg@gmail.com>
parents:
8375
diff
changeset
|
1099 OCTAVE_LOCAL_BUFFER_INIT (bool, left, n, true); |
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1100 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1101 retval = true; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1102 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1103 for (octave_idx_type i = 0, len = length (); i < len; i++) |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1104 { |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1105 octave_idx_type k = xelem (i); |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1106 if (left[k]) |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1107 left[k] = false; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1108 else |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1109 { |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1110 retval = false; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1111 break; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1112 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1113 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1114 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1115 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1116 |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1117 return retval; |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1118 } |
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8333
diff
changeset
|
1119 |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1120 idx_vector |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1121 idx_vector::unmask (void) const |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1122 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1123 if (idx_class () == class_mask) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1124 { |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1125 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
|
1126 const bool *data = r->get_data (); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1127 octave_idx_type ext = r->extent (0), len = r->length (0); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1128 octave_idx_type *idata = new octave_idx_type [len]; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1129 for (octave_idx_type i = 0, j = 0; i < ext; i++) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1130 if (data[i]) |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1131 idata[j++] = i; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1132 ext = len > 0 ? idata[len - 1] : 0; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1133 return new idx_vector_rep (idata, len, ext, r->orig_dimensions (), DIRECT); |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1134 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1135 else |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1136 return *this; |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1137 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1138 |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1139 void idx_vector::unconvert (idx_class_type& iclass, |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1140 double& scalar, Range& range, |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1141 Array<double>& array, Array<bool>& mask) const |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1142 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1143 iclass = idx_class (); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1144 switch (iclass) |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1145 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1146 case class_colon: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1147 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1148 case class_range: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1149 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1150 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1151 range = r->unconvert (); |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1152 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1153 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1154 case class_scalar: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1155 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1156 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1157 scalar = r->unconvert (); |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1158 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1159 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1160 case class_vector: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1161 { |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1162 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1163 array = r->unconvert (); |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1164 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1165 break; |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1166 case class_mask: |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1167 { |
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1168 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep); |
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1169 mask = r->unconvert (); |
9879
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1170 } |
034677ab6865
smarter treatment of mask indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
9780
diff
changeset
|
1171 break; |
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1172 default: |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1173 assert (false); |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1174 break; |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1175 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1176 } |
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9124
diff
changeset
|
1177 |
10339
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1178 Array<octave_idx_type> |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1179 idx_vector::as_array (void) const |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1180 { |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1181 return rep->as_array (); |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1182 } |
de2d43bcb083
optimize some lazy index operations
Jaroslav Hajek <highegg@gmail.com>
parents:
10314
diff
changeset
|
1183 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1184 octave_idx_type |
8677
095ae5e0a831
eliminte some compiler warnings
John W. Eaton <jwe@octave.org>
parents:
8384
diff
changeset
|
1185 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
|
1186 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1187 if (! resize_ok && extent (z_len) > z_len) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1188 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1189 (*current_liboctave_error_handler) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1190 ("invalid matrix index = %d", extent (z_len)); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1191 rep->err = true; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1192 chkerr (); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1193 } |
1560 | 1194 |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1195 return length (z_len); |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1196 } |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1197 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1198 octave_idx_type |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1199 idx_vector::ones_count () const |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1200 { |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1201 octave_idx_type n = 0; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1202 if (is_colon ()) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1203 n = 1; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1204 else |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1205 for (octave_idx_type i = 0; i < length (1); i++) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1206 if (xelem (i) == 0) n++; |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1207 return n; |
1 | 1208 } |
1209 | |
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1210 // Instantiate the octave_int constructors we want. |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1211 #define INSTANTIATE_SCALAR_VECTOR_REP_CONST(T) \ |
8319
c374691576f6
Fix for MSVC compilation
Michael Goffioul <michael.goffioul@gmail.com>
parents:
8301
diff
changeset
|
1212 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
|
1213 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
|
1214 |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1215 INSTANTIATE_SCALAR_VECTOR_REP_CONST (float) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1216 INSTANTIATE_SCALAR_VECTOR_REP_CONST (double) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1217 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int8) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1218 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int16) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1219 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int32) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1220 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_int64) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1221 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint8) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1222 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint16) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1223 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint32) |
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7774
diff
changeset
|
1224 INSTANTIATE_SCALAR_VECTOR_REP_CONST (octave_uint64) |