Mercurial > hg > octave-nkf
annotate liboctave/array/dim-vector.h @ 20068:19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Try to wrap long lines to < 80 characters.
Use GNU style and don't indent first brace of function definition.
"case" statement is aligned flush left with brace of switch stmt.
Remove trailing '\' line continuation from the end of #define macros.
Use 2 spaces for indent.
* files-dock-widget.cc, history-dock-widget.cc, main-window.cc, octave-cmd.cc,
octave-dock-widget.cc, octave-gui.cc, resource-manager.cc, settings-dialog.cc,
shortcut-manager.cc, welcome-wizard.cc, workspace-view.cc, cellfun.cc, data.cc,
debug.cc, debug.h, dirfns.cc, error.h, file-io.cc, gl-render.cc, gl-render.h,
gl2ps-renderer.h, graphics.cc, graphics.in.h, help.cc, input.cc, load-path.cc,
load-path.h, lookup.cc, lu.cc, oct-stream.cc, octave-default-image.h,
ordschur.cc, pr-output.cc, qz.cc, strfns.cc, symtab.cc, symtab.h, sysdep.cc,
variables.cc, zfstream.h, __fltk_uigetfile__.cc, __init_fltk__.cc,
__magick_read__.cc, __osmesa_print__.cc, audiodevinfo.cc, ov-classdef.cc,
ov-classdef.h, ov-fcn.h, ov-float.cc, ov-flt-complex.cc, ov-java.cc,
ov-range.cc, ov-re-mat.cc, ov-usr-fcn.h, ov.cc, op-int.h, options-usage.h,
pt-eval.cc, Array-C.cc, Array-fC.cc, Array.cc, Array.h, PermMatrix.cc,
Sparse.cc, chMatrix.h, dSparse.cc, dim-vector.h, bsxfun-decl.h, bsxfun-defs.cc,
oct-norm.cc, Sparse-op-defs.h, oct-inttypes.cc, oct-inttypes.h, main.in.cc,
mkoctfile.in.cc: Cleanup C++ code to follow Octave coding conventions.
| author | Rik <rik@octave.org> |
|---|---|
| date | Wed, 25 Feb 2015 11:55:49 -0800 |
| parents | 4197fc428c7d |
| children | f638a61af5a8 |
| rev | line source |
|---|---|
| 4513 | 1 /* |
| 2 | |
|
19898
4197fc428c7d
maint: Update copyright notices for 2015.
John W. Eaton <jwe@octave.org>
parents:
19519
diff
changeset
|
3 Copyright (C) 2003-2015 John W. Eaton |
|
10521
4d1fc073fbb7
add some missing copyright stmts
Jaroslav Hajek <highegg@gmail.com>
parents:
10498
diff
changeset
|
4 Copyirght (C) 2009, 2010 VZLU Prague |
| 4513 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 4513 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 4513 | 21 |
| 22 */ | |
| 23 | |
| 24 #if !defined (octave_dim_vector_h) | |
| 25 #define octave_dim_vector_h 1 | |
| 26 | |
| 27 #include <cassert> | |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
28 #include <limits> |
|
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
29 |
| 5765 | 30 #include <sstream> |
| 4543 | 31 #include <string> |
| 32 | |
| 6216 | 33 #include "lo-error.h" |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
34 #include "lo-macros.h" |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
35 #include "oct-refcount.h" |
| 4513 | 36 |
| 10150 | 37 // Rationale: This implementation is more tricky than Array, but the |
| 38 // big plus is that dim_vector requires only one allocation instead of | |
| 39 // two. It is (slightly) patterned after GCC's basic_string | |
| 40 // implementation. rep is a pointer to an array of memory, comprising | |
| 41 // count, length, and the data: | |
| 42 // | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
43 // <count> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
44 // <ndims> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
45 // rep --> <dims[0]> |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
46 // <dims[1]> |
| 10150 | 47 // ... |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
48 // |
| 10150 | 49 // The inlines count(), ndims() recover this data from the rep. Note |
| 50 // that rep points to the beginning of dims to grant faster access | |
| 51 // (reinterpret_cast is assumed to be an inexpensive operation). | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
52 |
| 4513 | 53 class |
|
11173
298a75c128ad
Additional exported symbols [MSVC]
Michael Goffioul <michael.goffioul@gmail.com>
parents:
10830
diff
changeset
|
54 OCTAVE_API |
| 4513 | 55 dim_vector |
| 56 { | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
57 private: |
| 4513 | 58 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
59 octave_idx_type *rep; |
| 4548 | 60 |
| 10150 | 61 octave_idx_type& ndims (void) const { return rep[-1]; } |
| 4513 | 62 |
| 10150 | 63 octave_idx_type& count (void) const { return rep[-2]; } |
| 4513 | 64 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
65 //! Construct a new rep with count = 1 and ndims given. |
| 10150 | 66 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
67 static octave_idx_type *newrep (int ndims) |
| 10150 | 68 { |
|
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
14951
diff
changeset
|
69 octave_idx_type *r = new octave_idx_type [ndims + 2]; |
| 10150 | 70 |
| 71 *r++ = 1; | |
| 72 *r++ = ndims; | |
| 4513 | 73 |
| 10150 | 74 return r; |
| 75 } | |
| 76 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
77 //! Clone this->rep. |
| 10150 | 78 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
79 octave_idx_type *clonerep (void) |
| 10150 | 80 { |
| 81 int l = ndims (); | |
| 82 | |
|
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
14951
diff
changeset
|
83 octave_idx_type *r = new octave_idx_type [l + 2]; |
| 10150 | 84 |
| 85 *r++ = 1; | |
| 86 *r++ = l; | |
| 4513 | 87 |
| 10150 | 88 for (int i = 0; i < l; i++) |
| 89 r[i] = rep[i]; | |
| 90 | |
| 91 return r; | |
| 92 } | |
| 93 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
94 //! Clone and resize this->rep to length n, filling by given value. |
| 10150 | 95 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
96 octave_idx_type *resizerep (int n, octave_idx_type fill_value) |
| 10150 | 97 { |
| 98 int l = ndims (); | |
| 99 | |
| 100 if (n < 2) | |
| 101 n = 2; | |
| 102 | |
|
15020
560317fd5977
maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents:
14951
diff
changeset
|
103 octave_idx_type *r = new octave_idx_type [n + 2]; |
| 10150 | 104 |
| 105 *r++ = 1; | |
| 106 *r++ = n; | |
| 107 | |
| 108 if (l > n) | |
| 109 l = n; | |
| 4673 | 110 |
| 10150 | 111 int j; |
| 112 for (j = 0; j < l; j++) | |
| 113 r[j] = rep[j]; | |
| 114 for (; j < n; j++) | |
| 115 r[j] = fill_value; | |
| 116 | |
| 117 return r; | |
| 118 } | |
| 119 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
120 //! Free the rep. |
| 10150 | 121 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
122 void freerep (void) |
| 10150 | 123 { |
| 124 assert (count () == 0); | |
| 125 delete [] (rep - 2); | |
| 126 } | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
127 |
| 4548 | 128 void make_unique (void) |
| 129 { | |
| 10150 | 130 if (count () > 1) |
| 4548 | 131 { |
| 14445 | 132 octave_idx_type *new_rep = clonerep (); |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
133 |
| 14445 | 134 if (OCTREFCOUNT_ATOMIC_DECREMENT(&(count())) == 0) |
| 135 freerep (); | |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
136 |
|
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
137 rep = new_rep; |
| 4548 | 138 } |
| 139 } | |
| 140 | |
| 141 public: | |
| 142 | |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
143 #define ASSIGN_REP(i) rep[i] = d ## i; |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
144 #define DIM_VECTOR_CTOR(N) \ |
|
10420
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
145 dim_vector (OCT_MAKE_DECL_LIST (octave_idx_type, d, N)) \ |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
146 : rep (newrep (N)) \ |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
147 { \ |
|
10420
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
148 OCT_ITERATE_MACRO (ASSIGN_REP, N) \ |
|
10418
6c19d6fcd7e5
up to 7th-order dim_vector constructors
Jaroslav Hajek <highegg@gmail.com>
parents:
10403
diff
changeset
|
149 } |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
150 |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
151 // Add more if needed. |
|
10420
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
152 DIM_VECTOR_CTOR (2) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
153 DIM_VECTOR_CTOR (3) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
154 DIM_VECTOR_CTOR (4) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
155 DIM_VECTOR_CTOR (5) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
156 DIM_VECTOR_CTOR (6) |
|
3373fdc0b14a
use macro for 2 and 3 arg dim_vector constructors
John W. Eaton <jwe@octave.org>
parents:
10419
diff
changeset
|
157 DIM_VECTOR_CTOR (7) |
|
10419
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
158 |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
159 #undef ASSIGN_REP |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
160 #undef DIM_VECTOR_CTOR |
|
afe44ee90cbd
implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents:
10418
diff
changeset
|
161 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
162 octave_idx_type& elem (int i) |
| 10150 | 163 { |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
164 #ifdef BOUNDS_CHECKING |
| 10150 | 165 assert (i >= 0 && i < ndims ()); |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
166 #endif |
| 10150 | 167 make_unique (); |
| 168 return rep[i]; | |
| 169 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
170 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
171 octave_idx_type elem (int i) const |
| 10150 | 172 { |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
173 #ifdef BOUNDS_CHECKING |
| 10150 | 174 assert (i >= 0 && i < ndims ()); |
|
10366
e5ae13b8b2c2
improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents:
10350
diff
changeset
|
175 #endif |
| 10150 | 176 return rep[i]; |
| 177 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
178 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
179 void chop_trailing_singletons (void) |
| 10150 | 180 { |
| 181 int l = ndims (); | |
| 182 if (l > 2 && rep[l-1] == 1) | |
| 183 { | |
| 184 make_unique (); | |
| 185 do | |
| 186 l--; | |
| 187 while (l > 2 && rep[l-1] == 1); | |
| 188 ndims () = l; | |
| 189 } | |
| 190 } | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
191 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
192 void chop_all_singletons (void); |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
193 |
|
14951
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
194 // WARNING: Only call by jit |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
195 octave_idx_type *to_jit (void) const |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
196 { |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
197 return rep; |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
198 } |
|
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
199 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
200 private: |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
201 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
202 static octave_idx_type *nil_rep (void) |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
203 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
204 static dim_vector zv (0, 0); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
205 return zv.rep; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
206 } |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
207 |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
208 public: |
|
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
209 |
|
10830
b4ebfd675321
avoid static initialization disaster in dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
10810
diff
changeset
|
210 static octave_idx_type dim_max (void); |
|
10810
6683f0c9d742
make the maximum extent externally accessible
Jaroslav Hajek <highegg@gmail.com>
parents:
10715
diff
changeset
|
211 |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
212 explicit dim_vector (void) : rep (nil_rep ()) |
|
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
213 { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); } |
| 4548 | 214 |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
215 dim_vector (const dim_vector& dv) : rep (dv.rep) |
|
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
216 { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); } |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
217 |
|
14951
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
218 // FIXME: Should be private, but required by array constructor for jit |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
219 explicit dim_vector (octave_idx_type *r) : rep (r) { } |
|
14951
4c9fd3e31436
Start of jit support for double matricies
Max Brister <max@2bass.com>
parents:
14625
diff
changeset
|
220 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
221 static dim_vector alloc (int n) |
| 10150 | 222 { |
| 223 return dim_vector (newrep (n < 2 ? 2 : n)); | |
| 224 } | |
| 4548 | 225 |
| 226 dim_vector& operator = (const dim_vector& dv) | |
| 227 { | |
| 228 if (&dv != this) | |
| 229 { | |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
230 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
231 freerep (); |
| 4548 | 232 |
| 10150 | 233 rep = dv.rep; |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
234 OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); |
| 4548 | 235 } |
| 236 | |
| 237 return *this; | |
| 238 } | |
| 239 | |
| 240 ~dim_vector (void) | |
| 241 { | |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
242 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
243 freerep (); |
| 4548 | 244 } |
| 245 | |
| 10150 | 246 int length (void) const { return ndims (); } |
| 4513 | 247 |
| 5275 | 248 octave_idx_type& operator () (int i) { return elem (i); } |
| 4513 | 249 |
| 5275 | 250 octave_idx_type operator () (int i) const { return elem (i); } |
| 4513 | 251 |
| 4887 | 252 void resize (int n, int fill_value = 0) |
| 4548 | 253 { |
| 254 int len = length (); | |
| 4513 | 255 |
| 4548 | 256 if (n != len) |
| 257 { | |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
258 octave_idx_type *r = resizerep (n, fill_value); |
| 4513 | 259 |
|
13985
43cc49c7abd1
Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents:
11586
diff
changeset
|
260 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0) |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
261 freerep (); |
| 4513 | 262 |
|
9507
b096d11237be
dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9420
diff
changeset
|
263 rep = r; |
| 4548 | 264 } |
| 265 } | |
| 4513 | 266 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
267 std::string str (char sep = 'x') const; |
| 4543 | 268 |
| 269 bool all_zero (void) const | |
| 4548 | 270 { |
| 271 bool retval = true; | |
| 4543 | 272 |
| 4548 | 273 for (int i = 0; i < length (); i++) |
| 274 { | |
| 10150 | 275 if (elem (i) != 0) |
| 276 { | |
| 277 retval = false; | |
| 278 break; | |
| 279 } | |
| 4548 | 280 } |
| 4543 | 281 |
| 4548 | 282 return retval; |
| 283 } | |
| 4559 | 284 |
|
10715
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
285 bool empty_2d (void) const |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
286 { |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
287 return length () == 2 && (elem (0) == 0 || elem (1) == 0); |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
288 } |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
289 |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
290 |
|
9886
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
291 bool zero_by_zero (void) const |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
292 { |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
293 return length () == 2 && elem (0) == 0 && elem (1) == 0; |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
294 } |
|
cddd5c3d5f04
fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9840
diff
changeset
|
295 |
| 4559 | 296 bool any_zero (void) const |
| 297 { | |
| 298 bool retval = false; | |
| 299 | |
| 300 for (int i = 0; i < length (); i++) | |
| 301 { | |
| 10150 | 302 if (elem (i) == 0) |
| 303 { | |
| 304 retval = true; | |
| 305 break; | |
| 306 } | |
| 4559 | 307 } |
| 308 | |
| 309 return retval; | |
| 310 } | |
| 4567 | 311 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
312 int num_ones (void) const; |
| 4635 | 313 |
| 10150 | 314 bool all_ones (void) const |
| 4655 | 315 { |
| 316 return (num_ones () == length ()); | |
| 317 } | |
| 318 | |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
319 //! Number of elements that a matrix with this dimensions would have. |
|
20068
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
320 /*! |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
321 Return the number of elements that a matrix with this dimension |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
322 vector would have, NOT the number of dimensions (elements in the |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
323 dimension vector). |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
324 */ |
| 4567 | 325 |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
326 octave_idx_type numel (int n = 0) const |
| 4567 | 327 { |
| 328 int n_dims = length (); | |
| 329 | |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
330 octave_idx_type retval = 1; |
| 4567 | 331 |
|
9027
9a46ba093db4
generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
332 for (int i = n; i < n_dims; i++) |
| 4567 | 333 retval *= elem (i); |
| 334 | |
| 335 return retval; | |
| 336 } | |
| 4673 | 337 |
|
20068
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
338 /*! |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
339 The following function will throw a std::bad_alloc () |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
340 exception if the requested size is larger than can be indexed by |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
341 octave_idx_type. This may be smaller than the actual amount of |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
342 memory that can be safely allocated on a system. However, if we |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
343 don't fail here, we can end up with a mysterious crash inside a |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
344 function that is iterating over an array using octave_idx_type |
|
19755f4fc851
maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents:
19898
diff
changeset
|
345 indices. |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
346 */ |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
347 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
348 octave_idx_type safe_numel (void) const; |
|
9840
c0b54271904b
improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
349 |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
350 bool any_neg (void) const |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
351 { |
| 10150 | 352 int n_dims = length (); |
| 353 int i; | |
| 354 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
355 for (i = 0; i < n_dims; i++) |
| 10150 | 356 if (elem (i) < 0) |
| 357 break; | |
| 358 | |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
359 return i < n_dims; |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
360 } |
|
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
361 |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
362 dim_vector squeeze (void) const; |
|
10498
8615b55b5caf
fix & improve cat (bug #29465)
Jaroslav Hajek <highegg@gmail.com>
parents:
10420
diff
changeset
|
363 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
364 //! This corresponds to cat(). |
|
10715
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
365 bool concat (const dim_vector& dvb, int dim); |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
366 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
367 //! This corresponds to [,] (horzcat, dim = 0) and [;] (vertcat, dim = 1). |
|
10715
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
368 // The rules are more relaxed here. |
|
53253f796351
make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10681
diff
changeset
|
369 bool hvcat (const dim_vector& dvb, int dim); |
|
8290
7cbe01c21986
improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
7017
diff
changeset
|
370 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
371 /*! |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
372 Force certain dimensionality, preserving numel (). Missing |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
373 dimensions are set to 1, redundant are folded into the trailing |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
374 one. If n = 1, the result is 2d and the second dim is 1 |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
375 (dim_vectors are always at least 2D). |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
376 */ |
|
10681
0ba9bd294421
make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
10645
diff
changeset
|
377 dim_vector redim (int n) const; |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
378 |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
379 dim_vector as_column (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
380 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
381 if (length () == 2 && elem (1) == 1) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
382 return *this; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
383 else |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
384 return dim_vector (numel (), 1); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
385 } |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
386 |
|
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
387 dim_vector as_row (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
388 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
389 if (length () == 2 && elem (0) == 1) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
390 return *this; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
391 else |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
392 return dim_vector (1, numel ()); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
393 } |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10150
diff
changeset
|
394 |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
395 bool is_vector (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
396 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
397 return (length () == 2 && (elem (0) == 1 || elem (1) == 1)); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
398 } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8290
diff
changeset
|
399 |
|
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
400 int first_non_singleton (int def = 0) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
401 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
402 for (int i = 0; i < length (); i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
403 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
404 if (elem (i) != 1) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
405 return i; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
406 } |
|
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
407 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
408 return def; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
409 } |
|
9511
cc1fd3084cb2
implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents:
9507
diff
changeset
|
410 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
411 //! Compute a linear index from an index tuple. |
| 10150 | 412 |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
413 octave_idx_type compute_index (const octave_idx_type *idx) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
414 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
415 octave_idx_type k = 0; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
416 for (int i = length () - 1; i >= 0; i--) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
417 k = k * rep[i] + idx[i]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
418 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
419 return k; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
420 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
421 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
422 //! Ditto, but the tuple may be incomplete (nidx < length ()). |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
423 |
|
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
424 octave_idx_type compute_index (const octave_idx_type *idx, int nidx) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
425 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
426 octave_idx_type k = 0; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
427 for (int i = nidx - 1; i >= 0; i--) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
428 k = k * rep[i] + idx[i]; |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
429 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
430 return k; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
431 } |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
432 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
433 /*/! |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
434 Increment a multi-dimensional index tuple, optionally starting |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
435 from an offset position and return the index of the last index |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
436 position that was changed, or length () if just cycled over. |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
437 */ |
| 10150 | 438 |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
439 int increment_index (octave_idx_type *idx, int start = 0) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
440 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
441 int i; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
442 for (i = start; i < length (); i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
443 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
444 if (++(*idx) == rep[i]) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
445 *idx++ = 0; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
446 else |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
447 break; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
448 } |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
449 return i; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
450 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
451 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
452 //! Return cumulative dimensions. |
| 10150 | 453 |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
454 dim_vector cumulative (void) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
455 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
456 int nd = length (); |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
457 dim_vector retval = alloc (nd); |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
458 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
459 octave_idx_type k = 1; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
460 for (int i = 0; i < nd; i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
461 retval.rep[i] = k *= rep[i]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
462 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
463 return retval; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
464 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
465 |
|
19391
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
466 //! Compute a linear index from an index tuple. Dimensions are |
|
3a6fd52e1458
liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents:
17769
diff
changeset
|
467 //! required to be cumulative. |
| 10150 | 468 |
|
10645
8645b7087859
abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents:
10586
diff
changeset
|
469 octave_idx_type cum_compute_index (const octave_idx_type *idx) const |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
470 { |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
471 octave_idx_type k = idx[0]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
472 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
473 for (int i = 1; i < length (); i++) |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
474 k += rep[i-1] * idx[i]; |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
475 |
|
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
476 return k; |
|
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
477 } |
|
9739
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
478 |
|
13b57eec9440
a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents:
9694
diff
changeset
|
479 |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
480 friend bool operator == (const dim_vector& a, const dim_vector& b); |
| 4513 | 481 }; |
| 482 | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
483 inline bool |
| 4543 | 484 operator == (const dim_vector& a, const dim_vector& b) |
| 485 { | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
486 // Fast case. |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
487 if (a.rep == b.rep) |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
488 return true; |
|
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
489 |
| 4543 | 490 bool retval = true; |
| 491 | |
| 492 int a_len = a.length (); | |
| 493 int b_len = b.length (); | |
| 494 | |
| 495 if (a_len != b_len) | |
| 496 retval = false; | |
| 497 else | |
| 498 { | |
| 499 for (int i = 0; i < a_len; i++) | |
| 10150 | 500 { |
| 501 if (a(i) != b(i)) | |
| 502 { | |
| 503 retval = false; | |
| 504 break; | |
| 505 } | |
| 506 } | |
| 4543 | 507 } |
| 508 | |
| 509 return retval; | |
| 510 } | |
| 511 | |
|
9694
50db3c5175b5
allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents:
9666
diff
changeset
|
512 inline bool |
| 4543 | 513 operator != (const dim_vector& a, const dim_vector& b) |
| 514 { | |
| 515 return ! operator == (a, b); | |
| 516 } | |
| 517 | |
| 4513 | 518 #endif |