Mercurial > octave-dspies
annotate liboctave/util/nz-iterators.h @ 19010:3fb030666878 draft default tip dspies
Added special-case logical-indexing function
* logical-index.h (New file) : Logical-indexing function. May be called on
octave_value types via call_bool_index
* nz-iterators.h : Add base-class nz_iterator for iterator types. Array has
template bool for whether to internally store row-col or compute on the fly
Add skip_ahead method which skips forward to the next nonzero after its
argument
Add flat_index for computing octave_idx_type index of current position (with
assertion failure in the case of overflow)
Move is_zero to separate file
* ov-base-diag.cc, ov-base-mat.cc, ov-base-sparse.cc, ov-perm.cc
(do_index_op): Add call to call_bool_index in logical-index.h
* Array.h : Move forward-declaration for array_iterator to separate header file
* dim-vector.cc (dim_max): Refers to idx-bounds.h (max_idx)
* array-iter-decl.h (New file): Header file for forward declaration of
array-iterator
* direction.h : Add constants fdirc and bdirc to avoid having to reconstruct
them
* dv-utils.h, dv-utils.cc (New files) :
Utility functions for querying and constructing dim-vectors
* idx-bounds.h (New file) :
Utility constants and functions for determining whether things will overflow
the maximum allowed bounds
* interp-idx.h (New function : to_flat_idx) : Converts row-col pair to linear
index of octave_idx_type
* is-zero.h (New file) : Function for determining whether an element is zero
* logical-index.tst : Add tests for correct return-value dimensions and large
sparse matrix behavior
author | David Spies <dnspies@gmail.com> |
---|---|
date | Fri, 25 Jul 2014 13:39:31 -0600 |
parents | 8d47ce2053f2 |
children |
rev | line source |
---|---|
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
1 /* |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
2 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
3 Copyright (C) 2014 David Spies |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
4 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
5 This file is part of Octave. |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
6 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
7 Octave is free software; you can redistribute it and/or modify it |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
8 under the terms of the GNU General Public License as published by the |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
9 Free Software Foundation; either version 3 of the License, or (at your |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
10 option) any later version. |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
11 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
12 Octave is distributed in the hope that it will be useful, but WITHOUT |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
15 for more details. |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
16 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
17 You should have received a copy of the GNU General Public License |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
18 along with Octave; see the file COPYING. If not, see |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
19 <http://www.gnu.org/licenses/>. |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
20 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
21 */ |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
22 #if !defined (octave_nz_iterators_h) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
23 #define octave_nz_iterators_h 1 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
24 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
25 #include <cassert> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
26 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
27 #include "array-iter-decl.h" |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
28 #include "interp-idx.h" |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
29 #include "oct-inttypes.h" |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
30 #include "Array.h" |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
31 #include "DiagArray2.h" |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
32 #include "PermMatrix.h" |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
33 #include "Sparse.h" |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
34 #include "direction.h" |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
35 #include "is-zero.h" |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
36 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
37 // This file contains generic column-major iterators over |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
38 // the nonzero elements of any array or matrix. If you have a matrix mat |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
39 // of type M, you can construct the proper iterator type using |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
40 // M::iter_type iter(mat) and iter will iterate efficiently (forwards |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
41 // or backwards) over the nonzero elements of mat. |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
42 // |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
43 // The parameter T is the element-type except for PermMatrix where |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
44 // the element type is always bool |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
45 // |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
46 // Use a dir_handler to indicate which direction you intend to iterate. |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
47 // (see step-dir.h). begin() resets the iterator to the beginning or |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
48 // end of the matrix (for dir_handler<FORWARD> and <BACKWARD> respectively). |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
49 // finished(dirc) indicates whether the iterators has finished traversing |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
50 // the nonzero elements. step(dirc) steps from one element to the next. |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
51 // |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
52 // You can, for instance, use a for-loop as follows: |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
53 // |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
54 // typedef M::iter_type iter_t; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
55 // typedef M::element_type T; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
56 // |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
57 // iter_t iter(mat); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
58 // dir_handler<1> dirc; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
59 // |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
60 // for(iter.begin (dirc); !iter.finished (dirc); iter.step (dirc)) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
61 // { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
62 // octave_idx_type row = iter.row(); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
63 // octave_idx_type col = iter.col(); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
64 // double doub_index = iter.interp_index (); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
65 // T elem = iter.data(); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
66 // // ... Do something with these |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
67 // } |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
68 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
69 struct rowcol |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
70 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
71 rowcol (void) { } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
72 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
73 rowcol (octave_idx_type i, const dim_vector& dims) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
74 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
75 #if defined(BOUNDS_CHECKING) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
76 check_index(i, dims); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
77 #endif |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
78 row = i % dims(0); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
79 col = i / dims(0); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
80 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
81 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
82 rowcol (octave_idx_type rowj, octave_idx_type coli, const dim_vector& dims) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
83 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
84 #if defined(BOUNDS_CHECKING) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
85 check_index(rowj, coli, dims); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
86 #endif |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
87 row = rowj; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
88 col = coli; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
89 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
90 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
91 octave_idx_type row; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
92 octave_idx_type col; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
93 }; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
94 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
95 // Default (non-linear) implementation of nz_iterator.interp_idx |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
96 template <typename Iter> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
97 inline double |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
98 default_interp_idx(const Iter& it) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
99 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
100 return to_interp_idx (it.row (), it.col (), it.dims); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
101 } |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
102 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
103 // Default (non-linear) implementation of nz_iterator.flat_idx |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
104 template <typename Iter> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
105 inline octave_idx_type |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
106 default_flat_idx (const Iter& it) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
107 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
108 return to_flat_idx (it.row (), it.col (), it.dims); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
109 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
110 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
111 // Default (non-linear) implementation of |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
112 // nz_iterator.skip_ahead(octave_idx_type) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
113 template <typename Iter> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
114 inline bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
115 default_skip_ahead (Iter& it, octave_idx_type i) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
116 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
117 return it.skip_ahead (i % it.dims(0), i / it.dims(0)); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
118 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
119 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
120 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
121 template <typename M> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
122 class nz_iterator |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
123 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
124 protected: |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
125 const M mat; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
126 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
127 public: |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
128 const dim_vector dims; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
129 nz_iterator (const M& arg_mat) : mat (arg_mat), dims (arg_mat.dims ()) { } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
130 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
131 // Because of the abundance of templates, this interface cannot be specified |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
132 // using pure virtual methods. But here's what each method does: |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
133 // |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
134 // begin(dirc): moves the iterator to the beginning or the end |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
135 // finished(dirc): checks whether the iterator has advanced to the end or the |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
136 // beginning |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
137 // row, col, and data: return the current row, column, and element |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
138 // interp_idx and flat_idx: return the current linear index (interp_idx as |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
139 // a double the way the interpreter sees it and flat_idx as an |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
140 // octave_idx_type) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
141 // step(dirc): steps forward to the next nonzero element |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
142 // skip_ahead(args): skips forward to the nearest nonzero element after |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
143 // (including) args. Returns true iff the position at args is nonzero |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
144 }; |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
145 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
146 // An iterator over full arrays. When the number of dimensions exceeds |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
147 // 2, calls to iter.col() may exceed mat.cols() up to mat.dims().numel(1) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
148 // |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
149 // This mimics the behavior of the "find" method (both in Octave and Matlab) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
150 // on many-dimensional matrices. |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
151 // |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
152 // userc indicates whether to (true) track row and column values or (false) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
153 // compute them on the fly as needed |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
154 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
155 template<typename T, bool userc> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
156 class array_iterator : public nz_iterator<Array<T> > |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
157 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
158 private: |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
159 typedef nz_iterator<Array<T> > Base; |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
160 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
161 const octave_idx_type totcols; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
162 const octave_idx_type numels; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
163 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
164 rowcol myrc; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
165 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
166 octave_idx_type my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
167 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
168 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
169 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
170 step_once (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
171 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
172 my_idx += dir; |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
173 if (userc) |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
174 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
175 myrc.row += dir; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
176 if (dirc.is_ended (myrc.row, Base::mat.rows ())) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
177 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
178 myrc.row = dirc.begin (Base::mat.rows ()); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
179 myrc.col += dir; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
180 } |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
181 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
182 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
183 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
184 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
185 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
186 move_to_nz (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
187 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
188 while (!finished (dirc) && is_zero (data ())) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
189 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
190 step_once (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
191 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
192 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
193 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
194 template <direction dir> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
195 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
196 next_nz (dir_handler<dir> dirc) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
197 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
198 if (is_zero (data ())) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
199 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
200 step (dirc); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
201 return false; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
202 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
203 else |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
204 return true; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
205 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
206 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
207 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
208 skip_ahead (octave_idx_type i, const rowcol& rc) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
209 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
210 if (i < my_idx) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
211 return false; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
212 my_idx = i; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
213 if (userc) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
214 myrc = rc; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
215 return next_nz (fdirc); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
216 } |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
217 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
218 public: |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
219 array_iterator (const Array<T>& arg_mat) |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
220 : nz_iterator<Array<T> > (arg_mat), totcols (Base::dims.numel (1)), numels ( |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
221 totcols * arg_mat.rows ()) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
222 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
223 begin (fdirc); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
224 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
225 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
226 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
227 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
228 begin (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
229 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
230 if(userc) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
231 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
232 myrc.col = dirc.begin (totcols); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
233 myrc.row = dirc.begin (Base::mat.rows ()); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
234 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
235 my_idx = dirc.begin (Base::mat.numel ()); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
236 move_to_nz (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
237 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
238 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
239 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
240 col (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
241 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
242 if (userc) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
243 return myrc.col; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
244 else |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
245 return my_idx / Base::mat.rows (); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
246 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
247 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
248 row (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
249 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
250 if (userc) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
251 return myrc.row; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
252 else |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
253 return my_idx % Base::mat.rows (); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
254 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
255 double |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
256 interp_idx (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
257 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
258 return to_interp_idx (my_idx); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
259 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
260 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
261 flat_idx (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
262 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
263 return my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
264 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
265 T |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
266 data (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
267 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
268 return Base::mat.elem (my_idx); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
269 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
270 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
271 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
272 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
273 step (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
274 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
275 step_once (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
276 move_to_nz (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
277 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
278 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
279 bool |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
280 finished (dir_handler<dir> dirc) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
281 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
282 return dirc.is_ended (my_idx, numels); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
283 } |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
284 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
285 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
286 skip_ahead (octave_idx_type i) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
287 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
288 return skip_ahead (i, rowcol (i, Base::dims)); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
289 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
290 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
291 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
292 skip_ahead (octave_idx_type rowj, octave_idx_type coli) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
293 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
294 return skip_ahead (coli * Base::mat.rows () + rowj, |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
295 rowcol (rowj, coli, Base::dims)); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
296 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
297 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
298 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
299 skip_ahead (const Array<octave_idx_type>& idxs) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
300 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
301 //TODO Check bounds |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
302 octave_idx_type rowj = idxs(0); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
303 octave_idx_type coli = 0; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
304 for(int i = idxs.numel () - 1; i > 1; --i) { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
305 coli += idxs(i); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
306 coli *= Base::dims(i); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
307 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
308 coli += idxs(1); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
309 return skip_ahead (rowj, coli); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
310 } |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
311 }; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
312 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
313 template<typename T> |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
314 class sparse_iterator : public nz_iterator<Sparse<T> > |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
315 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
316 private: |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
317 typedef nz_iterator<Sparse<T> > Base; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
318 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
319 octave_idx_type coli; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
320 octave_idx_type my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
321 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
322 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
323 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
324 adjust_col (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
325 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
326 while (!finished (dirc) |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
327 && dirc.is_ended (my_idx, Base::mat.cidx (coli), Base::mat.cidx (coli + 1))) |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
328 coli += dir; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
329 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
330 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
331 void jump_to_row (octave_idx_type rowj); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
332 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
333 public: |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
334 sparse_iterator (const Sparse<T>& arg_mat) : |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
335 nz_iterator<Sparse<T> > (arg_mat) |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
336 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
337 begin (fdirc); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
338 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
339 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
340 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
341 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
342 begin (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
343 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
344 coli = dirc.begin (Base::mat.cols ()); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
345 my_idx = dirc.begin (Base::mat.nnz ()); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
346 adjust_col (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
347 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
348 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
349 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
350 col (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
351 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
352 return coli; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
353 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
354 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
355 row (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
356 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
357 return Base::mat.ridx (my_idx); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
358 } |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
359 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
360 T |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
361 data (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
362 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
363 return Base::mat.data (my_idx); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
364 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
365 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
366 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
367 step (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
368 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
369 my_idx += dir; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
370 adjust_col (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
371 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
372 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
373 bool |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
374 finished (dir_handler<dir> dirc) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
375 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
376 return dirc.is_ended (coli, Base::mat.cols ()); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
377 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
378 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
379 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
380 skip_ahead (octave_idx_type rowj, octave_idx_type arg_coli) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
381 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
382 //TODO Check bounds |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
383 if (arg_coli < coli || (arg_coli == coli && rowj < this->row ())) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
384 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
385 return false; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
386 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
387 else if (arg_coli > coli) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
388 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
389 coli = arg_coli; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
390 my_idx = Base::mat.cidx (arg_coli); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
391 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
392 jump_to_row (rowj); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
393 return coli == arg_coli && this->row () == rowj; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
394 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
395 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
396 double |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
397 interp_idx (void) const |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
398 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
399 return default_interp_idx(*this); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
400 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
401 octave_idx_type |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
402 flat_idx (void) const |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
403 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
404 return default_flat_idx(*this); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
405 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
406 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
407 skip_ahead (octave_idx_type i) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
408 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
409 return default_skip_ahead (*this, i); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
410 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
411 }; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
412 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
413 template<typename T> |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
414 class diag_iterator : public nz_iterator <DiagArray2<T> > |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
415 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
416 private: |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
417 typedef nz_iterator <DiagArray2<T> > Base; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
418 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
419 octave_idx_type my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
420 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
421 template <direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
422 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
423 move_to_nz (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
424 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
425 while (!finished (dirc) && is_zero (data ())) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
426 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
427 my_idx += dir; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
428 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
429 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
430 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
431 public: |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
432 diag_iterator (const DiagArray2<T>& arg_mat) : |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
433 nz_iterator<DiagArray2<T> > (arg_mat) |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
434 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
435 begin (fdirc); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
436 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
437 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
438 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
439 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
440 begin (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
441 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
442 my_idx = dirc.begin (Base::mat.diag_length ()); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
443 move_to_nz (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
444 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
445 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
446 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
447 col (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
448 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
449 return my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
450 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
451 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
452 row (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
453 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
454 return my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
455 } |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
456 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
457 T |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
458 data (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
459 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
460 return Base::mat.dgelem (my_idx); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
461 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
462 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
463 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
464 step (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
465 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
466 my_idx += dir; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
467 move_to_nz (dirc); |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
468 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
469 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
470 bool |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
471 finished (dir_handler<dir> dirc) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
472 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
473 return dirc.is_ended (my_idx, Base::mat.diag_length ()); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
474 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
475 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
476 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
477 skip_ahead (octave_idx_type rowj, octave_idx_type coli) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
478 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
479 if (coli < my_idx) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
480 return false; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
481 my_idx = coli + (rowj > coli); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
482 move_to_nz (fdirc); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
483 return rowj == coli && coli == my_idx; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
484 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
485 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
486 double |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
487 interp_idx (void) const |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
488 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
489 return default_interp_idx(*this); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
490 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
491 octave_idx_type |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
492 flat_idx (void) const |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
493 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
494 return default_flat_idx(*this); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
495 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
496 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
497 skip_ahead (octave_idx_type i) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
498 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
499 return default_skip_ahead (*this, i); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
500 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
501 }; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
502 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
503 class perm_iterator : public nz_iterator<PermMatrix> |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
504 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
505 private: |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
506 typedef nz_iterator<PermMatrix> Base; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
507 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
508 octave_idx_type my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
509 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
510 public: |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
511 perm_iterator (const PermMatrix& arg_mat) : |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
512 nz_iterator<PermMatrix> (arg_mat) |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
513 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
514 begin (fdirc); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
515 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
516 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
517 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
518 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
519 begin (dir_handler<dir> dirc) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
520 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
521 my_idx = dirc.begin (Base::mat.cols ()); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
522 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
523 |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
524 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
525 col (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
526 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
527 return my_idx; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
528 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
529 octave_idx_type |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
530 row (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
531 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
532 return Base::mat.perm_elem (my_idx); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
533 } |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
534 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
535 bool |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
536 data (void) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
537 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
538 return true; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
539 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
540 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
541 void |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
542 step (dir_handler<dir>) |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
543 { |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
544 my_idx += dir; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
545 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
546 template<direction dir> |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
547 bool |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
548 finished (dir_handler<dir> dirc) const |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
549 { |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
550 return dirc.is_ended (my_idx, Base::mat.rows ()); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
551 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
552 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
553 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
554 skip_ahead (octave_idx_type rowj, octave_idx_type coli) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
555 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
556 //TODO Check bounds |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
557 if (coli < my_idx || rowj < this->row ()) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
558 return false; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
559 my_idx = coli + (rowj > Base::mat.perm_elem (coli)); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
560 return my_idx == coli && rowj == this->row (); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
561 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
562 |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
563 double |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
564 interp_idx (void) const |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
565 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
566 return default_interp_idx(*this); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
567 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
568 octave_idx_type |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
569 flat_idx (void) const |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
570 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
571 return default_flat_idx(*this); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
572 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
573 bool |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
574 skip_ahead (octave_idx_type i) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
575 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
576 return default_skip_ahead (*this, i); |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
577 } |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
578 }; |
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
579 |
19010
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
580 // Uses a one-sided binary search to move to the next element in this column |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
581 // whose row is at least rowj. The one-sided binary search guarantees |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
582 // O(log(rowj - currentRow)) time to find it. |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
583 template<typename T> |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
584 void |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
585 sparse_iterator<T>::jump_to_row (octave_idx_type rowj) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
586 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
587 octave_idx_type ub = Base::mat.cidx (coli + 1); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
588 octave_idx_type lo = my_idx - 1; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
589 octave_idx_type hi = my_idx; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
590 octave_idx_type hidiff = 1; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
591 while (Base::mat.ridx (hi) < rowj) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
592 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
593 lo = hi; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
594 hidiff *= 2; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
595 hi += hidiff; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
596 if (hi >= ub) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
597 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
598 hi = ub; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
599 break; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
600 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
601 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
602 while (hi - lo > 1) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
603 { |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
604 octave_idx_type mid = (lo + hi) / 2; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
605 if (Base::mat.ridx (mid) < rowj) |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
606 lo = mid; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
607 else |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
608 hi = mid; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
609 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
610 my_idx = hi; |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
611 adjust_col (fdirc); |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
612 } |
3fb030666878
Added special-case logical-indexing function
David Spies <dnspies@gmail.com>
parents:
19009
diff
changeset
|
613 |
19006
2e0613dadfee
All calls to "find" use the same generic implementation (bug #42408, 42421)
David Spies <dnspies@gmail.com>
parents:
diff
changeset
|
614 #endif |