Mercurial > octave

annotate liboctave/array/idx-vector.cc @ 29568:a7cbd0e54e7a

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