Mercurial > octave

annotate liboctave/array/dim-vector.h @ 22222:8a50ab960ae6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
dim-vector.h: remove duplicated code.
author Carnë Draug <carandraug@octave.org>
date Mon, 08 Aug 2016 20:46:12 +0100
parents 1723063e65f3
children 7a6279f4018f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
1 /*
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
2
19697
4197fc428c7d maint: Update copyright notices for 2015.
John W. Eaton <jwe@octave.org>
parents: 19326
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
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
5
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
6 This file is part of Octave.
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
7
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
8 Octave is free software; you can redistribute it and/or modify it
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
9 under the terms of the GNU General Public License as published by the
7016
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe]
jwe
parents: 6216
diff changeset
10 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe]
jwe
parents: 6216
diff changeset
11 option) any later version.
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
12
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
13 Octave is distributed in the hope that it will be useful, but WITHOUT
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
16 for more details.
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
17
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
18 You should have received a copy of the GNU General Public License
7016
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe]
jwe
parents: 6216
diff changeset
19 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe]
jwe
parents: 6216
diff changeset
20 <http://www.gnu.org/licenses/>.
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
21
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
22 */
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
23
20791
f7084eae3318 maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents: 20236
diff changeset
24 #if ! defined (octave_dim_vector_h)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
25 #define octave_dim_vector_h 1
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
26
21244
1473547f50f5 include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents: 21229
diff changeset
27 #include "octave-config.h"
1473547f50f5 include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents: 21229
diff changeset
28
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
29 #include <cassert>
8950
d865363208d6 include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents: 8920
diff changeset
30
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
31 #include <string>
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
32
6216
74ca56e4414c [project @ 2006-12-22 17:45:47 by jwe]
jwe
parents: 5765
diff changeset
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
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
36
20236
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
37 //! Vector representing the dimensions (size) of an Array.
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
38 /*!
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
39 A dim_vector is used to represent dimensions of an Array. It is used
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
40 on its constructor to specify its size, or when reshaping it.
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
41
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
42 @code{.cc}
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
43 // Matrix with 10 rows and 20 columns.
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
44 Matrix m Matrix (dim_vector (10, 20));
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
45
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
46 // Change its size to 5 rows and 40 columns.
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
47 Matrix m2 = m.reshape (dim_vector (5, 40));
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
48
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
49 // Five dimensional Array of length 10, 20, 3, 8, 7 on each dimension.
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
50 NDArray a (dim_vector (10, 20, 3, 8, 7));
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
51
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
52 // Uninitialized array of same size as other.
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
53 NDArray b (a.dims ());
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
54 @endcode
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
55
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
56 The main thing to understand about this class, is that methods such as
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
57 ndims() and numel(), return the value for an Array of these dimensions,
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
58 not the actual number of elements in the dim_vector.
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
59
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
60 @code{.cc}
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
61 dim_vector d (10, 5, 3);
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
62 octave_idx_type n = d.numel (); // returns 150
22059
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
63 octave_idx_type nd = d.ndims (); // returns 3
20236
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
64 @endcode
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
65
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
66 ## Implementation details ##
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
67
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
68 This implementation is more tricky than Array, but the big plus is that
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
69 dim_vector requires only one allocation instead of two. It is (slightly)
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
70 patterned after GCC's basic_string implementation. rep is a pointer to an
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
71 array of memory, comprising count, length, and the data:
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
72
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
73 @verbatim
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
74 <count>
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
75 <ndims>
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
76 rep --> <dims[0]>
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
77 <dims[1]>
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
78 ...
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
79 @endverbatim
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
80
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
81 The inlines count(), ndims() recover this data from the rep. Note
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
82 that rep points to the beginning of dims to grant faster access
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
83 (reinterpret_cast is assumed to be an inexpensive operation).
a3bf35bd5b44 doc: doxygen documentation for dim_vector header.
Carnë Draug <carandraug@octave.org>
parents: 20230
diff changeset
84 */
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
85
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
86 class
11173
298a75c128ad Additional exported symbols [MSVC]
Michael Goffioul <michael.goffioul@gmail.com>
parents: 10830
diff changeset
87 OCTAVE_API
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
88 dim_vector
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
89 {
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
90 private:
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
91
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
92 octave_idx_type *rep;
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
93
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
94 octave_idx_type& count (void) const { return rep[-2]; }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
95
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
96 //! Construct a new rep with count = 1 and ndims given.
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
97
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
98 static octave_idx_type *newrep (int ndims)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
99 {
15020
560317fd5977 maint: Cuddle open bracket used for indexing C++ arrays in source code.
Rik <rik@octave.org>
parents: 14951
diff changeset
100 octave_idx_type *r = new octave_idx_type [ndims + 2];
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
101
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
102 *r++ = 1;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
103 *r++ = ndims;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
104
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
105 return r;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
106 }
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
107
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
108 //! Clone this->rep.
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
109
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
110 octave_idx_type *clonerep (void)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
111 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
112 int l = ndims ();
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
113
22222
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
114 octave_idx_type* r = newrep (l);
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
115
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
116 for (int i = 0; i < l; i++)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
117 r[i] = rep[i];
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
118
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
119 return r;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
120 }
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
121
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
122 //! Clone and resize this->rep to length n, filling by given value.
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
123
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
124 octave_idx_type *resizerep (int n, octave_idx_type fill_value)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
125 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
126 int l = ndims ();
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
127
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
128 if (n < 2)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
129 n = 2;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
130
22222
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
131 octave_idx_type* r = newrep (n);
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
132
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
133 if (l > n)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
134 l = n;
4673
6639c2574023 [project @ 2003-12-10 16:11:54 by jwe]
jwe
parents: 4655
diff changeset
135
22222
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
136 int j = 0;
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
137 for (; j < l; j++)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
138 r[j] = rep[j];
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
139 for (; j < n; j++)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
140 r[j] = fill_value;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
141
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
142 return r;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
143 }
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
144
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
145 //! Free the rep.
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
146
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
147 void freerep (void)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
148 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
149 assert (count () == 0);
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
150 delete [] (rep - 2);
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
151 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
152
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
153 void make_unique (void)
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
154 {
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
155 if (count () > 1)
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
156 {
14445
b50654a09ba7 maint: untabify sources
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
157 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
158
14445
b50654a09ba7 maint: untabify sources
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
159 if (OCTREFCOUNT_ATOMIC_DECREMENT(&(count())) == 0)
b50654a09ba7 maint: untabify sources
John W. Eaton <jwe@octave.org>
parents: 14138
diff changeset
160 freerep ();
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
161
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
162 rep = new_rep;
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
163 }
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
164 }
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
165
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
166 public:
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
167
22059
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
168 //! Construct dim_vector for a N dimensional array.
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
169 /*!
10419
afe44ee90cbd implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents: 10418
diff changeset
170
22059
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
171 Each argument to constructor defines the length of an additional
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
172 dimension. A dim_vector always represents a minimum of 2 dimensions
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
173 (just like an Array has at least 2 dimensions) and there is no
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
174 upper limit on the number of dimensions.
20208
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
175
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
176 @code{.cc}
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
177 dim_vector dv (7, 5);
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
178 Matrix mat (dv);
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
179 @endcode
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
180
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
181 The constructed dim_vector @c dv will have two elements, @f$[7, 5]@f$,
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
182 one for each dimension. It can then be used to construct a Matrix
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
183 with such dimensions, i.e., 7 rows and 5 columns.
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
184
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
185 @code{.cc}
22059
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
186 NDArray x (dim_vector (7, 5, 10));
20208
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
187 @endcode
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
188
22059
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
189 This will construct a 3 dimensional NDArray of lengths 7, 5, and 10,
20208
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
190 on the first, second, and third dimension (rows, columns, and pages)
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
191 respectively.
22059
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
192
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
193 Note that that there is no constructor that accepts only one
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
194 dimension length to avoid confusion. The source for such confusion
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
195 is that constructor could mean:
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
196 - a column vector, i.e., assume @f$[N, 1]@f$;
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
197 - a square matrix, i.e., as is common in Octave interpreter;
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
198 - support for a 1 dimensional Array (does not exist);
20208
f638a61af5a8 doxygen: improve dim_vector constructor documentation (bug #45105)
Piotr Held <pjheld@gmail.com>
parents: 19861
diff changeset
199 */
22059
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
200 template <typename... Ints>
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
201 dim_vector (const octave_idx_type r, const octave_idx_type c,
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
202 Ints... lengths) : rep (newrep (2 + sizeof... (Ints)))
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
203 {
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
204 // Using r, c, and lengths, makes sure that there's always a min of
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
205 // 2 dimensions specified, and that lengths are ints (since otherwise
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
206 // they can't form a list.
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
207 for (const auto l: {r, c, lengths...})
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
208 *rep++ = l;
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
209 rep -= (2 + sizeof... (Ints));
b1256fb38777 dim_vector: replace 7 constructors with single variadic template (patch #9030).
Carnë Draug <carandraug@octave.org>
parents: 22022
diff changeset
210 }
10419
afe44ee90cbd implement generic macro magic for repeated decls
Jaroslav Hajek <highegg@gmail.com>
parents: 10418
diff changeset
211
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
212 octave_idx_type& elem (int i)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
213 {
21724
aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents: 21660
diff changeset
214 #if defined (OCTAVE_ENABLE_BOUNDS_CHECK)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
215 assert (i >= 0 && i < ndims ());
10366
e5ae13b8b2c2 improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents: 10350
diff changeset
216 #endif
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
217 make_unique ();
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
218 return rep[i];
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
219 }
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
220
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
221 octave_idx_type elem (int i) const
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
222 {
21724
aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents: 21660
diff changeset
223 #if defined (OCTAVE_ENABLE_BOUNDS_CHECK)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
224 assert (i >= 0 && i < ndims ());
10366
e5ae13b8b2c2 improve Array indexing error messages
Jaroslav Hajek <highegg@gmail.com>
parents: 10350
diff changeset
225 #endif
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
226 return rep[i];
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
227 }
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
228
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
229 void chop_trailing_singletons (void)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
230 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
231 int l = ndims ();
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
232 if (l > 2 && rep[l-1] == 1)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
233 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
234 make_unique ();
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
235 do
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
236 l--;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
237 while (l > 2 && rep[l-1] == 1);
22212
2b487dbe419d dim-vector.h (ndims): do not return a reference to the rep.
Carnë Draug <carandraug@octave.org>
parents: 22059
diff changeset
238 rep[-1] = l;
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
239 }
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
240 }
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
241
10681
0ba9bd294421 make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10645
diff changeset
242 void chop_all_singletons (void);
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
243
14951
4c9fd3e31436 Start of jit support for double matricies
Max Brister <max@2bass.com>
parents: 14625
diff changeset
244 // WARNING: Only call by jit
4c9fd3e31436 Start of jit support for double matricies
Max Brister <max@2bass.com>
parents: 14625
diff changeset
245 octave_idx_type *to_jit (void) const
4c9fd3e31436 Start of jit support for double matricies
Max Brister <max@2bass.com>
parents: 14625
diff changeset
246 {
4c9fd3e31436 Start of jit support for double matricies
Max Brister <max@2bass.com>
parents: 14625
diff changeset
247 return rep;
4c9fd3e31436 Start of jit support for double matricies
Max Brister <max@2bass.com>
parents: 14625
diff changeset
248 }
4c9fd3e31436 Start of jit support for double matricies
Max Brister <max@2bass.com>
parents: 14625
diff changeset
249
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
250 private:
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11523
diff changeset
251
21573
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372)
John W. Eaton <jwe@octave.org>
parents: 20208
diff changeset
252 static octave_idx_type *nil_rep (void);
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
253
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
254 public:
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
255
10830
b4ebfd675321 avoid static initialization disaster in dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 10810
diff changeset
256 static octave_idx_type dim_max (void);
10810
6683f0c9d742 make the maximum extent externally accessible
Jaroslav Hajek <highegg@gmail.com>
parents: 10715
diff changeset
257
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
258 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
259 { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); }
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
260
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
261 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
262 { OCTREFCOUNT_ATOMIC_INCREMENT (&(count())); }
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
263
14951
4c9fd3e31436 Start of jit support for double matricies
Max Brister <max@2bass.com>
parents: 14625
diff changeset
264 // 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
265 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
266
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
267 static dim_vector alloc (int n)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
268 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
269 return dim_vector (newrep (n < 2 ? 2 : n));
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
270 }
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
271
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
272 dim_vector& operator = (const dim_vector& dv)
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
273 {
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
274 if (&dv != this)
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
275 {
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
276 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0)
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
277 freerep ();
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
278
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
279 rep = dv.rep;
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
280 OCTREFCOUNT_ATOMIC_INCREMENT (&(count()));
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
281 }
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
282
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
283 return *this;
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
284 }
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
285
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
286 ~dim_vector (void)
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
287 {
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
288 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0)
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
289 freerep ();
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
290 }
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
291
21509
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
292 //! Number of dimensions.
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
293 /*!
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
294 Returns the number of dimensions of the dim_vector. This is number of
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
295 elements in the dim_vector including trailing singetons. It is also
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
296 the number of dimensions an Array with this dim_vector would have.
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
297 */
22212
2b487dbe419d dim-vector.h (ndims): do not return a reference to the rep.
Carnë Draug <carandraug@octave.org>
parents: 22059
diff changeset
298 octave_idx_type ndims (void) const { return rep[-1]; }
21509
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
299
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
300 //! Number of dimensions.
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
301 //! Synonymous with ndims().
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
302 /*!
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
303 While this method is not officially deprecated, consider using ndims()
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
304 instead to avoid confusion. Array does not have length because of its
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
305 odd definition as length of the longest dimension.
dcee67d28570 doc: doxygen documentation for dim_vector::ndims and dim_vector::length.
Carnë Draug <carandraug@octave.org>
parents: 21244
diff changeset
306 */
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
307 int length (void) const { return ndims (); }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
308
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5105
diff changeset
309 octave_idx_type& operator () (int i) { return elem (i); }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
310
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5105
diff changeset
311 octave_idx_type operator () (int i) const { return elem (i); }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
312
4887
bbddd4339cf2 [project @ 2004-04-30 17:08:55 by jwe]
jwe
parents: 4735
diff changeset
313 void resize (int n, int fill_value = 0)
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
314 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
315 int len = ndims ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
316
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
317 if (n != len)
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
318 {
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
319 octave_idx_type *r = resizerep (n, fill_value);
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
320
13985
43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC).
Michael Goffioul <michael.goffioul@gmail.com>
parents: 11586
diff changeset
321 if (OCTREFCOUNT_ATOMIC_DECREMENT (&(count())) == 0)
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
322 freerep ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
323
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9420
diff changeset
324 rep = r;
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
325 }
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
326 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
327
10681
0ba9bd294421 make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10645
diff changeset
328 std::string str (char sep = 'x') const;
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
329
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
330 bool all_zero (void) const
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
331 {
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
332 bool retval = true;
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
333
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
334 for (int i = 0; i < ndims (); i++)
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
335 {
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
336 if (elem (i) != 0)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
337 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
338 retval = false;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
339 break;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
340 }
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
341 }
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
342
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
343 return retval;
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4543
diff changeset
344 }
4559
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
345
10715
53253f796351 make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10681
diff changeset
346 bool empty_2d (void) const
53253f796351 make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10681
diff changeset
347 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
348 return ndims () == 2 && (elem (0) == 0 || elem (1) == 0);
10715
53253f796351 make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10681
diff changeset
349 }
53253f796351 make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10681
diff changeset
350
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
351 bool zero_by_zero (void) const
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
352 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
353 return ndims () == 2 && elem (0) == 0 && elem (1) == 0;
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
354 }
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
355
4559
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
356 bool any_zero (void) const
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
357 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
358 bool retval = false;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
359
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
360 for (int i = 0; i < ndims (); i++)
4559
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
361 {
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
362 if (elem (i) == 0)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
363 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
364 retval = true;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
365 break;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
366 }
4559
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
367 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
368
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
369 return retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe]
jwe
parents: 4548
diff changeset
370 }
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
371
10681
0ba9bd294421 make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10645
diff changeset
372 int num_ones (void) const;
4635
f2cd320cbf6e [project @ 2003-11-20 01:48:23 by jwe]
jwe
parents: 4567
diff changeset
373
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
374 bool all_ones (void) const
4655
c8829691db47 [project @ 2003-11-24 21:24:37 by jwe]
jwe
parents: 4635
diff changeset
375 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
376 return (num_ones () == ndims ());
4655
c8829691db47 [project @ 2003-11-24 21:24:37 by jwe]
jwe
parents: 4635
diff changeset
377 }
c8829691db47 [project @ 2003-11-24 21:24:37 by jwe]
jwe
parents: 4635
diff changeset
378
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
379 //! Number of elements that a matrix with this dimensions would have.
19861
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents: 19697
diff changeset
380 /*!
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents: 19697
diff changeset
381 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: 19697
diff changeset
382 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: 19697
diff changeset
383 dimension vector).
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
384 */
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
385
9027
9a46ba093db4 generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents: 8950
diff changeset
386 octave_idx_type numel (int n = 0) const
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
387 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
388 int n_dims = ndims ();
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
389
9027
9a46ba093db4 generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents: 8950
diff changeset
390 octave_idx_type retval = 1;
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
391
9027
9a46ba093db4 generalize dim_vector::numel
Jaroslav Hajek <highegg@gmail.com>
parents: 8950
diff changeset
392 for (int i = n; i < n_dims; i++)
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
393 retval *= elem (i);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
394
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
395 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4565
diff changeset
396 }
4673
6639c2574023 [project @ 2003-12-10 16:11:54 by jwe]
jwe
parents: 4655
diff changeset
397
19861
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents: 19697
diff changeset
398 /*!
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents: 19697
diff changeset
399 The following function will throw a std::bad_alloc ()
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents: 19697
diff changeset
400 exception if the requested size is larger than can be indexed by
21751
b571fc85953f maint: Use two spaces after period to indicate sentence break.
Rik <rik@octave.org>
parents: 21724
diff changeset
401 octave_idx_type. This may be smaller than the actual amount of
19861
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions.
Rik <rik@octave.org>
parents: 19697
diff changeset
402 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: 19697
diff changeset
403 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: 19697
diff changeset
404 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: 19697
diff changeset
405 indices.
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
406 */
9840
c0b54271904b improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9743
diff changeset
407
10681
0ba9bd294421 make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10645
diff changeset
408 octave_idx_type safe_numel (void) const;
9840
c0b54271904b improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9743
diff changeset
409
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
410 bool any_neg (void) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
411 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
412 int n_dims = ndims ();
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
413 int i;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
414
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
415 for (i = 0; i < n_dims; i++)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
416 if (elem (i) < 0)
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
417 break;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
418
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
419 return i < n_dims;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
420 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
421
10681
0ba9bd294421 make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10645
diff changeset
422 dim_vector squeeze (void) const;
10498
8615b55b5caf fix & improve cat (bug #29465)
Jaroslav Hajek <highegg@gmail.com>
parents: 10420
diff changeset
423
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
424 //! This corresponds to cat().
10715
53253f796351 make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10681
diff changeset
425 bool concat (const dim_vector& dvb, int dim);
53253f796351 make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10681
diff changeset
426
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
427 //! 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
428 // The rules are more relaxed here.
53253f796351 make [] (hopefully) more Matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10681
diff changeset
429 bool hvcat (const dim_vector& dvb, int dim);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 7017
diff changeset
430
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
431 /*!
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
432 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
433 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
434 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
435 (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
436 */
10681
0ba9bd294421 make cat() (hopefully) more matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents: 10645
diff changeset
437 dim_vector redim (int n) const;
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8290
diff changeset
438
10350
12884915a8e4 merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents: 10150
diff changeset
439 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
440 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
441 if (ndims () == 2 && elem (1) == 1)
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
442 return *this;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
443 else
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
444 return dim_vector (numel (), 1);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
445 }
10350
12884915a8e4 merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents: 10150
diff changeset
446
12884915a8e4 merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents: 10150
diff changeset
447 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
448 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
449 if (ndims () == 2 && elem (0) == 1)
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
450 return *this;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
451 else
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
452 return dim_vector (1, numel ());
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
453 }
10350
12884915a8e4 merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents: 10150
diff changeset
454
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8290
diff changeset
455 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
456 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
457 return (ndims () == 2 && (elem (0) == 1 || elem (1) == 1));
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
458 }
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8290
diff changeset
459
9511
cc1fd3084cb2 implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
460 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
461 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
462 for (int i = 0; i < ndims (); i++)
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
463 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
464 if (elem (i) != 1)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
465 return i;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
466 }
9511
cc1fd3084cb2 implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
467
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
468 return def;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
469 }
9511
cc1fd3084cb2 implement dim_vector::first_non_singleton
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
470
22222
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
471 //! Linear index from an index tuple.
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
472 octave_idx_type compute_index (const octave_idx_type* idx) const
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
473 { return compute_index (idx, ndims ()); }
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
474
22222
8a50ab960ae6 dim-vector.h: remove duplicated code.
Carnë Draug <carandraug@octave.org>
parents: 22213
diff changeset
475 //! Linear index from an incomplete index tuple (nidx < length ()).
10645
8645b7087859 abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents: 10586
diff changeset
476 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
477 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
478 octave_idx_type k = 0;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
479 for (int i = nidx - 1; i >= 0; i--)
20230
e914b5399c67 Use in-place operators in C++ code where possible.
Rik <rik@octave.org>
parents: 20208
diff changeset
480 k = rep[i] * k + idx[i];
10645
8645b7087859 abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents: 10586
diff changeset
481
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
482 return k;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
483 }
10645
8645b7087859 abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents: 10586
diff changeset
484
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
485 /*/!
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
486 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
487 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
488 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
489 */
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
490
10645
8645b7087859 abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents: 10586
diff changeset
491 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
492 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
493 int i;
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
494 for (i = start; i < ndims (); i++)
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
495 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
496 if (++(*idx) == rep[i])
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
497 *idx++ = 0;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
498 else
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
499 break;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
500 }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
501 return i;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
502 }
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
503
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
504 //! Return cumulative dimensions.
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
505
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
506 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
507 {
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
508 int nd = ndims ();
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
509 dim_vector retval = alloc (nd);
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
510
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
511 octave_idx_type k = 1;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
512 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
513 retval.rep[i] = k *= rep[i];
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
514
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
515 return retval;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
516 }
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
517
19199
3a6fd52e1458 liboctave/array/dim-vector.h: convert comments to doxygen
Carnë Draug <carandraug@octave.org>
parents: 17769
diff changeset
518 //! 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
519 //! required to be cumulative.
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
520
10645
8645b7087859 abstract scalar index checking off Array<T> (prep for struct optimizations)
Jaroslav Hajek <highegg@gmail.com>
parents: 10586
diff changeset
521 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
522 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
523 octave_idx_type k = idx[0];
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
524
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
525 for (int i = 1; i < ndims (); i++)
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
526 k += rep[i-1] * idx[i];
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
527
17769
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
528 return k;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents: 17744
diff changeset
529 }
9739
13b57eec9440 a few handy methods for dim_vector
Jaroslav Hajek <highegg@gmail.com>
parents: 9694
diff changeset
530
9694
50db3c5175b5 allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents: 9666
diff changeset
531 friend bool operator == (const dim_vector& a, const dim_vector& b);
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
532 };
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
533
9694
50db3c5175b5 allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents: 9666
diff changeset
534 inline bool
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
535 operator == (const dim_vector& a, const dim_vector& b)
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
536 {
9694
50db3c5175b5 allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents: 9666
diff changeset
537 // Fast case.
50db3c5175b5 allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents: 9666
diff changeset
538 if (a.rep == b.rep)
50db3c5175b5 allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents: 9666
diff changeset
539 return true;
50db3c5175b5 allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents: 9666
diff changeset
540
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
541 bool retval = true;
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
542
21660
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
543 int a_len = a.ndims ();
53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors.
Rik <rik@octave.org>
parents: 21574
diff changeset
544 int b_len = b.ndims ();
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
545
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
546 if (a_len != b_len)
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
547 retval = false;
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
548 else
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
549 {
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
550 for (int i = 0; i < a_len; i++)
10150
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
551 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
552 if (a(i) != b(i))
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
553 {
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
554 retval = false;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
555 break;
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
556 }
3778ea95adea style fixes
John W. Eaton <jwe@octave.org>
parents: 10095
diff changeset
557 }
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
558 }
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
559
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
560 return retval;
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
561 }
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
562
9694
50db3c5175b5 allow unpacked form of LU
Jaroslav Hajek <highegg@gmail.com>
parents: 9666
diff changeset
563 inline bool
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
564 operator != (const dim_vector& a, const dim_vector& b)
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
565 {
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
566 return ! operator == (a, b);
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
567 }
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4532
diff changeset
568
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents:
diff changeset
569 #endif