Mercurial > hg > octave-nkf

annotate liboctave/Array.cc @ 10075:84b0725f4b09

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
return class types by reference in const Array element access functions
author Jaroslav Hajek <highegg@gmail.com>
date Fri, 08 Jan 2010 11:25:08 +0100
parents bb30843c4929
children eb8ac0eed9f1
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
1993
1b57120c997b [project @ 1996-03-03 01:16:15 by jwe]
jwe
parents: 1989
diff changeset
1 // Template array classes
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
2 /*
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
3
8920
eb63fbe60fab update copyright notices
John W. Eaton <jwe@octave.org>
parents: 8814
diff changeset
4 Copyright (C) 2008, 2009 Jaroslav Hajek
7017
a1dbe9d80eee [project @ 2007-10-12 21:27:11 by jwe]
jwe
parents: 7016
diff changeset
5 Copyright (C) 1993, 1994, 1995, 1996, 1997, 2000, 2002, 2003, 2004,
a1dbe9d80eee [project @ 2007-10-12 21:27:11 by jwe]
jwe
parents: 7016
diff changeset
6 2005, 2006, 2007 John W. Eaton
9601
a9b37bae1802 add a couple of missing copyright statements
Jaroslav Hajek <highegg@gmail.com>
parents: 9556
diff changeset
7 Copyright (C) 2009 VZLU Prague
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
8
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
9 This file is part of Octave.
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
10
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
11 Octave is free software; you can redistribute it and/or modify it
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
12 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: 6922
diff changeset
13 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe]
jwe
parents: 6922
diff changeset
14 option) any later version.
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
15
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
16 Octave is distributed in the hope that it will be useful, but WITHOUT
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
19 for more details.
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
20
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
21 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: 6922
diff changeset
22 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe]
jwe
parents: 6922
diff changeset
23 <http://www.gnu.org/licenses/>.
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
24
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
25 */
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
26
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
27 #ifdef HAVE_CONFIG_H
1192
b6360f2d4fa6 [project @ 1995-03-30 21:38:35 by jwe]
jwe
parents: 1011
diff changeset
28 #include <config.h>
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
29 #endif
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
30
1367
9f9131a8d706 [project @ 1995-09-06 00:07:03 by jwe]
jwe
parents: 1360
diff changeset
31 #include <cassert>
4518
382cb0ed8c14 [project @ 2003-09-20 18:08:40 by jwe]
jwe
parents: 4517
diff changeset
32 #include <climits>
449
3cef0ce5dd7d [project @ 1994-06-05 21:58:52 by jwe]
jwe
parents: 386
diff changeset
33
3503
d14c483b3c12 [project @ 2000-02-01 04:06:07 by jwe]
jwe
parents: 2847
diff changeset
34 #include <iostream>
5765
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe]
jwe
parents: 5632
diff changeset
35 #include <sstream>
5607
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
36 #include <vector>
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
37 #include <algorithm>
6674
e236f1b0a221 [project @ 2007-05-31 18:19:01 by jwe]
jwe
parents: 6553
diff changeset
38 #include <new>
1560
27a03373de41 [project @ 1995-10-12 07:22:26 by jwe]
jwe
parents: 1550
diff changeset
39
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
40 #include "Array.h"
4588
19bfd295f400 [project @ 2003-11-10 17:18:48 by jwe]
jwe
parents: 4587
diff changeset
41 #include "Array-util.h"
1560
27a03373de41 [project @ 1995-10-12 07:22:26 by jwe]
jwe
parents: 1550
diff changeset
42 #include "idx-vector.h"
27a03373de41 [project @ 1995-10-12 07:22:26 by jwe]
jwe
parents: 1550
diff changeset
43 #include "lo-error.h"
8377
25bc2d31e1bf improve OCTAVE_LOCAL_BUFFER
Jaroslav Hajek <highegg@gmail.com>
parents: 8333
diff changeset
44 #include "oct-locbuf.h"
1560
27a03373de41 [project @ 1995-10-12 07:22:26 by jwe]
jwe
parents: 1550
diff changeset
45
1360
7eb93d12654c [project @ 1995-09-05 21:51:54 by jwe]
jwe
parents: 1321
diff changeset
46 // One dimensional array class. Handles the reference counting for
7eb93d12654c [project @ 1995-09-05 21:51:54 by jwe]
jwe
parents: 1321
diff changeset
47 // all the derived classes.
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
48
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
49 template <class T>
4834
8f669cc5a901 [project @ 2004-03-11 18:49:17 by jwe]
jwe
parents: 4832
diff changeset
50 Array<T>::Array (const Array<T>& a, const dim_vector& dv)
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
51 : rep (a.rep), dimensions (dv),
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
52 slice_data (a.slice_data), slice_len (a.slice_len)
4834
8f669cc5a901 [project @ 2004-03-11 18:49:17 by jwe]
jwe
parents: 4832
diff changeset
53 {
9731
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
54 if (dv.numel () != a.numel ())
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
55 {
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
56 std::string dimensions_str = dimensions.str ();
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
57 std::string new_dims_str = dv.str ();
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
58
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
59 (*current_liboctave_error_handler)
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
60 ("reshape: can't reshape %s array to %s array",
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
61 dimensions_str.c_str (), new_dims_str.c_str ());
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
62 }
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
63
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
64 // This goes here because if an exception is thrown by the above,
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
65 // destructor will be never called.
4834
8f669cc5a901 [project @ 2004-03-11 18:49:17 by jwe]
jwe
parents: 4832
diff changeset
66 rep->count++;
8f669cc5a901 [project @ 2004-03-11 18:49:17 by jwe]
jwe
parents: 4832
diff changeset
67 }
8f669cc5a901 [project @ 2004-03-11 18:49:17 by jwe]
jwe
parents: 4832
diff changeset
68
8f669cc5a901 [project @ 2004-03-11 18:49:17 by jwe]
jwe
parents: 4832
diff changeset
69 template <class T>
8524
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
70 void
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
71 Array<T>::fill (const T& val)
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
72 {
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
73 if (rep->count > 1)
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
74 {
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
75 --rep->count;
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
76 rep = new ArrayRep (length (), val);
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
77 slice_data = rep->data;
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
78 }
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
79 else
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
80 fill_or_memset (slice_len, val, slice_data);
8524
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
81 }
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
82
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
83 template <class T>
9546
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
84 void
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
85 Array<T>::clear (void)
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
86 {
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
87 if (--rep->count <= 0)
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
88 delete rep;
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
89
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
90 rep = nil_rep ();
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
91 rep->count++;
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
92 slice_data = rep->data;
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
93 slice_len = rep->len;
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
94
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
95 dimensions = dim_vector ();
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
96 }
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
97
1beb23d2b892 optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents: 9507
diff changeset
98 template <class T>
9624
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
99 void
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
100 Array<T>::clear (const dim_vector& dv)
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
101 {
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
102 if (--rep->count <= 0)
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
103 delete rep;
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
104
9840
c0b54271904b improve safe numel() calculation for arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9839
diff changeset
105 rep = new ArrayRep (dv.safe_numel ());
9624
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
106 slice_data = rep->data;
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
107 slice_len = rep->len;
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
108
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
109 dimensions = dv;
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
110 }
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
111
3fc7272937ce implement Array<T>::clear overloads
Jaroslav Hajek <highegg@gmail.com>
parents: 9601
diff changeset
112 template <class T>
4532
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
113 Array<T>
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
114 Array<T>::squeeze (void) const
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
115 {
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
116 Array<T> retval = *this;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
117
4929
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
118 if (ndims () > 2)
4532
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
119 {
4929
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
120 bool dims_changed = false;
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
121
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
122 dim_vector new_dimensions = dimensions;
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
123
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
124 int k = 0;
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
125
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
126 for (int i = 0; i < ndims (); i++)
4759
364bbf35dbfa [project @ 2004-02-15 00:08:06 by jwe]
jwe
parents: 4757
diff changeset
127 {
4929
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
128 if (dimensions(i) == 1)
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
129 dims_changed = true;
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
130 else
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
131 new_dimensions(k++) = dimensions(i);
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
132 }
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
133
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
134 if (dims_changed)
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
135 {
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
136 switch (k)
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
137 {
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
138 case 0:
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
139 new_dimensions = dim_vector (1, 1);
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
140 break;
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
141
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
142 case 1:
4759
364bbf35dbfa [project @ 2004-02-15 00:08:06 by jwe]
jwe
parents: 4757
diff changeset
143 {
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
144 octave_idx_type tmp = new_dimensions(0);
4929
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
145
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
146 new_dimensions.resize (2);
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
147
4759
364bbf35dbfa [project @ 2004-02-15 00:08:06 by jwe]
jwe
parents: 4757
diff changeset
148 new_dimensions(0) = tmp;
364bbf35dbfa [project @ 2004-02-15 00:08:06 by jwe]
jwe
parents: 4757
diff changeset
149 new_dimensions(1) = 1;
364bbf35dbfa [project @ 2004-02-15 00:08:06 by jwe]
jwe
parents: 4757
diff changeset
150 }
4929
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
151 break;
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
152
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
153 default:
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
154 new_dimensions.resize (k);
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
155 break;
585e9a8c2ef8 [project @ 2004-08-03 20:45:34 by jwe]
jwe
parents: 4916
diff changeset
156 }
4759
364bbf35dbfa [project @ 2004-02-15 00:08:06 by jwe]
jwe
parents: 4757
diff changeset
157 }
4532
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
158
8524
937921654627 clean up Array and DiagArray2
Jaroslav Hajek <highegg@gmail.com>
parents: 8523
diff changeset
159 retval = Array<T> (*this, new_dimensions);
4532
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
160 }
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
161
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
162 return retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
163 }
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe]
jwe
parents: 4530
diff changeset
164
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
165 template <class T>
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
166 octave_idx_type
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
167 Array<T>::compute_index (const Array<octave_idx_type>& ra_idx) const
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
168 {
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
169 octave_idx_type retval = -1;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
170
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
171 int n = dimensions.length ();
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
172
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
173 if (n > 0 && n == ra_idx.length ())
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
174 {
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
175 retval = ra_idx(--n);
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
176
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
177 while (--n >= 0)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
178 {
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
179 retval *= dimensions(n);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
180 retval += ra_idx(n);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
181 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
182 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
183 else
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
184 (*current_liboctave_error_handler)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
185 ("Array<T>::compute_index: invalid ra_idxing operation");
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
186
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
187 return retval;
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
188 }
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
189
2049
468a96dd03fc [project @ 1996-03-29 20:09:05 by jwe]
jwe
parents: 2006
diff changeset
190 template <class T>
10075
84b0725f4b09 return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9987
diff changeset
191 T&
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
192 Array<T>::range_error (const char *fcn, octave_idx_type n) const
2049
468a96dd03fc [project @ 1996-03-29 20:09:05 by jwe]
jwe
parents: 2006
diff changeset
193 {
2109
356f70c8fcbd [project @ 1996-04-30 12:31:30 by jwe]
jwe
parents: 2049
diff changeset
194 (*current_liboctave_error_handler) ("%s (%d): range error", fcn, n);
2049
468a96dd03fc [project @ 1996-03-29 20:09:05 by jwe]
jwe
parents: 2006
diff changeset
195 static T foo;
468a96dd03fc [project @ 1996-03-29 20:09:05 by jwe]
jwe
parents: 2006
diff changeset
196 return foo;
468a96dd03fc [project @ 1996-03-29 20:09:05 by jwe]
jwe
parents: 2006
diff changeset
197 }
468a96dd03fc [project @ 1996-03-29 20:09:05 by jwe]
jwe
parents: 2006
diff changeset
198
3933
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe]
jwe
parents: 3657
diff changeset
199 template <class T>
10075
84b0725f4b09 return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9987
diff changeset
200 T&
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
201 Array<T>::range_error (const char *fcn, octave_idx_type i, octave_idx_type j) const
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
202 {
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
203 (*current_liboctave_error_handler)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
204 ("%s (%d, %d): range error", fcn, i, j);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
205 static T foo;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
206 return foo;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
207 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
208
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
209 template <class T>
10075
84b0725f4b09 return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9987
diff changeset
210 T&
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
211 Array<T>::range_error (const char *fcn, octave_idx_type i, octave_idx_type j, octave_idx_type k) const
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
212 {
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
213 (*current_liboctave_error_handler)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
214 ("%s (%d, %d, %d): range error", fcn, i, j, k);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
215 static T foo;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
216 return foo;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
217 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
218
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
219 template <class T>
10075
84b0725f4b09 return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9987
diff changeset
220 T&
6867
83619ae96c1d [project @ 2007-09-06 12:08:44 by dbateman]
dbateman
parents: 6674
diff changeset
221 Array<T>::range_error (const char *fcn, const Array<octave_idx_type>& ra_idx) const
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
222 {
5765
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe]
jwe
parents: 5632
diff changeset
223 std::ostringstream buf;
4661
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
224
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
225 buf << fcn << " (";
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
226
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
227 octave_idx_type n = ra_idx.length ();
4661
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
228
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
229 if (n > 0)
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
230 buf << ra_idx(0);
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
231
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
232 for (octave_idx_type i = 1; i < n; i++)
4661
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
233 buf << ", " << ra_idx(i);
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
234
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
235 buf << "): range error";
12b6fbd57436 [project @ 2003-11-25 05:41:35 by jwe]
jwe
parents: 4657
diff changeset
236
5765
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe]
jwe
parents: 5632
diff changeset
237 std::string buf_str = buf.str ();
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe]
jwe
parents: 5632
diff changeset
238
7ba9ad1fec11 [project @ 2006-04-17 05:05:15 by jwe]
jwe
parents: 5632
diff changeset
239 (*current_liboctave_error_handler) (buf_str.c_str ());
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
240
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
241 static T foo;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
242 return foo;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
243 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
244
9731
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
245
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
246 template <class T>
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
247 Array<T>
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
248 Array<T>::column (octave_idx_type k) const
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
249 {
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
250 octave_idx_type r = dimensions(0);
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
251 #ifdef BOUNDS_CHECKING
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
252 if (k < 0 || k * r >= numel ())
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
253 range_error ("column", k);
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
254 #endif
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
255
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
256 return Array<T> (*this, dim_vector (r, 1), k*r, k*r + r);
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
257 }
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
258
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
259 template <class T>
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4553
diff changeset
260 Array<T>
9731
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
261 Array<T>::page (octave_idx_type k) const
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
262 {
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
263 octave_idx_type r = dimensions(0), c = dimensions (1), p = r*c;
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
264 #ifdef BOUNDS_CHECKING
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
265 if (k < 0 || k * p >= numel ())
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
266 range_error ("page", k);
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
267 #endif
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
268
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
269 return Array<T> (*this, dim_vector (r, c), k*p, k*p + p);
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
270 }
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
271
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
272 template <class T>
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
273 Array<T>
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
274 Array<T>::linearize (void) const
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4553
diff changeset
275 {
9731
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
276 octave_idx_type n = numel ();
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
277 return Array<T> (*this, dim_vector (n, 1), 0, n);
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
278 }
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
279
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
280 template <class T>
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
281 Array<T>
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
282 Array<T>::linear_slice (octave_idx_type lo, octave_idx_type up) const
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
283 {
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
284 #ifdef BOUNDS_CHECKING
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
285 if (lo < 0 || up > numel ())
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
286 range_error ("linear_slice", lo, up);
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
287 #endif
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
288 if (up < lo) up = lo;
7b9cbaad68d6 extend Array<T>
Jaroslav Hajek <highegg@gmail.com>
parents: 9725
diff changeset
289 return Array<T> (*this, dim_vector (up - lo, 1), lo, up);
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4553
diff changeset
290 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4553
diff changeset
291
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
292 // Helper class for multi-d dimension permuting (generalized transpose).
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
293 class rec_permute_helper
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
294 {
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
295 octave_idx_type *dim, *stride;
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
296 bool use_blk;
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
297 int top;
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
298
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
299 public:
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
300 rec_permute_helper (const dim_vector& dv, const Array<octave_idx_type>& perm)
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
301 {
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
302 int n = dv.length ();
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
303 assert (n == perm.length ());
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
304
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
305 dim = new octave_idx_type [2*n];
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
306 // A hack to avoid double allocation
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
307 stride = dim + n;
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
308
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
309 // Get cumulative dimensions.
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
310 OCTAVE_LOCAL_BUFFER (octave_idx_type, cdim, n+1);
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
311 cdim[0] = 1;
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
312 for (int i = 1; i < n+1; i++) cdim[i] = cdim[i-1] * dv(i-1);
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
313
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
314 // Setup the permuted strides.
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
315 for (int k = 0; k < n; k++)
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
316 {
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
317 int kk = perm(k);
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
318 dim[k] = dv(kk);
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
319 stride[k] = cdim[kk];
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
320 }
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
321
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
322 // Reduce contiguous runs.
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
323 top = 0;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
324 for (int k = 1; k < n; k++)
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
325 {
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
326 if (stride[k] == stride[top]*dim[top])
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
327 dim[top] *= dim[k];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
328 else
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
329 {
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
330 top++;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
331 dim[top] = dim[k];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
332 stride[top] = stride[k];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
333 }
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
334 }
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
335
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
336 // Determine whether we can use block transposes.
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
337 use_blk = top >= 1 && stride[1] == 1 && stride[0] == dim[1];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
338
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
339 }
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
340
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
341 ~rec_permute_helper (void) { delete [] dim; }
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
342
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
343 // Helper method for fast blocked transpose.
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
344 template <class T>
9121
bb62bc406ea7 reuse fast blocked transpose implementation from rec_permute_helper in Array<T>::transpose
Jaroslav Hajek <highegg@gmail.com>
parents: 9100
diff changeset
345 static T *
bb62bc406ea7 reuse fast blocked transpose implementation from rec_permute_helper in Array<T>::transpose
Jaroslav Hajek <highegg@gmail.com>
parents: 9100
diff changeset
346 blk_trans (const T *src, T *dest, octave_idx_type nr, octave_idx_type nc)
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
347 {
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
348 static const octave_idx_type m = 8;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
349 OCTAVE_LOCAL_BUFFER (T, blk, m*m);
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
350 for (octave_idx_type kr = 0; kr < nr; kr += m)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
351 for (octave_idx_type kc = 0; kc < nc; kc += m)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
352 {
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
353 octave_idx_type lr = std::min (m, nr - kr);
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
354 octave_idx_type lc = std::min (m, nc - kc);
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
355 if (lr == m && lc == m)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
356 {
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
357 const T *ss = src + kc * nr + kr;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
358 for (octave_idx_type j = 0; j < m; j++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
359 for (octave_idx_type i = 0; i < m; i++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
360 blk[j*m+i] = ss[j*nr + i];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
361 T *dd = dest + kr * nc + kc;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
362 for (octave_idx_type j = 0; j < m; j++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
363 for (octave_idx_type i = 0; i < m; i++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
364 dd[j*nc+i] = blk[i*m+j];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
365 }
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
366 else
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
367 {
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
368 const T *ss = src + kc * nr + kr;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
369 for (octave_idx_type j = 0; j < lc; j++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
370 for (octave_idx_type i = 0; i < lr; i++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
371 blk[j*m+i] = ss[j*nr + i];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
372 T *dd = dest + kr * nc + kc;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
373 for (octave_idx_type j = 0; j < lr; j++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
374 for (octave_idx_type i = 0; i < lc; i++)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
375 dd[j*nc+i] = blk[i*m+j];
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
376 }
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
377 }
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
378
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
379 return dest + nr*nc;
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
380 }
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
381 private:
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
382
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
383 // Recursive N-d generalized transpose
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
384 template <class T>
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
385 T *do_permute (const T *src, T *dest, int lev) const
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
386 {
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
387 if (lev == 0)
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
388 {
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
389 octave_idx_type step = stride[0], len = dim[0];
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
390 if (step == 1)
9773
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
391 {
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
392 copy_or_memcpy (len, src, dest);
9773
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
393 dest += len;
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
394 }
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
395 else
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
396 {
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
397 for (octave_idx_type i = 0, j = 0; i < len; i++, j += step)
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
398 dest[i] = src[j];
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
399
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
400 dest += len;
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
401 }
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
402 }
9012
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
403 else if (use_blk && lev == 1)
9f5e095555fc smarter algorithm for permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8920
diff changeset
404 dest = blk_trans (src, dest, dim[1], dim[0]);
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
405 else
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
406 {
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
407 octave_idx_type step = stride[lev], len = dim[lev];
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
408 for (octave_idx_type i = 0, j = 0; i < len; i++, j+= step)
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
409 dest = do_permute (src + i * step, dest, lev-1);
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
410 }
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
411
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
412 return dest;
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
413 }
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
414
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
415 public:
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
416
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
417 template <class T>
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
418 void permute (const T *src, T *dest) const { do_permute (src, dest, top); }
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
419
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
420 };
7241
da540e715d05 [project @ 2007-12-03 22:55:20 by jwe]
jwe
parents: 7189
diff changeset
421
5607
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
422
4567
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe]
jwe
parents: 4553
diff changeset
423 template <class T>
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
424 Array<T>
5607
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
425 Array<T>::permute (const Array<octave_idx_type>& perm_vec_arg, bool inv) const
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
426 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
427 Array<T> retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
428
5607
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
429 Array<octave_idx_type> perm_vec = perm_vec_arg;
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
430
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
431 dim_vector dv = dims ();
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
432
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
433 int perm_vec_len = perm_vec_arg.length ();
5148
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
434
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
435 if (perm_vec_len < dv.length ())
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
436 (*current_liboctave_error_handler)
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
437 ("%s: invalid permutation vector", inv ? "ipermute" : "permute");
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
438
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9341
diff changeset
439 dim_vector dv_new = dim_vector::alloc (perm_vec_len);
5148
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
440
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
441 // Append singleton dimensions as needed.
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
442 dv.resize (perm_vec_len, 1);
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
443
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
444 // Need this array to check for identical elements in permutation array.
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
445 OCTAVE_LOCAL_BUFFER_INIT (bool, checked, perm_vec_len, false);
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
446
9678
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
447 bool identity = true;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
448
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
449 // Find dimension vector of permuted array.
5148
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
450 for (int i = 0; i < perm_vec_len; i++)
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
451 {
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
452 octave_idx_type perm_elt = perm_vec.elem (i);
5148
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
453 if (perm_elt >= perm_vec_len || perm_elt < 0)
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
454 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
455 (*current_liboctave_error_handler)
5148
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
456 ("%s: permutation vector contains an invalid element",
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
457 inv ? "ipermute" : "permute");
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
458
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
459 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
460 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
461
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
462 if (checked[perm_elt])
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
463 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
464 (*current_liboctave_error_handler)
5148
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
465 ("%s: permutation vector cannot contain identical elements",
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
466 inv ? "ipermute" : "permute");
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
467
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
468 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
469 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
470 else
9678
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
471 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
472 checked[perm_elt] = true;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
473 identity = identity && perm_elt == i;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
474 }
5148
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
475
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe]
jwe
parents: 5120
diff changeset
476 dv_new(i) = dv(perm_elt);
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
477 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
478
9678
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
479 if (identity)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
480 return *this;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes
Jaroslav Hajek <highegg@gmail.com>
parents: 9624
diff changeset
481
5607
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
482 if (inv)
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
483 {
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
484 for (int i = 0; i < perm_vec_len; i++)
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
485 perm_vec(perm_vec_arg(i)) = i;
5607
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
486 }
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
487
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
488 retval = Array<T> (dv_new);
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
489
5940
0dd8428bb260 [project @ 2006-08-18 17:50:23 by jwe]
jwe
parents: 5837
diff changeset
490 if (numel () > 0)
5607
4b33d802ef3c [project @ 2006-02-08 18:56:54 by jwe]
jwe
parents: 5535
diff changeset
491 {
8410
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
492 rec_permute_helper rh (dv, perm_vec);
ba24ecd4c019 optimize permute
Jaroslav Hajek <highegg@gmail.com>
parents: 8390
diff changeset
493 rh.permute (data (), retval.fortran_vec ());
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
494 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
495
5340
15843d76156d [project @ 2005-05-06 16:26:58 by jwe]
jwe
parents: 5338
diff changeset
496 retval.chop_trailing_singletons ();
5338
c4b55d47122e [project @ 2005-05-05 17:28:51 by jwe]
jwe
parents: 5307
diff changeset
497
4593
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
498 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
499 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe]
jwe
parents: 4592
diff changeset
500
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
501 // Helper class for multi-d index reduction and recursive indexing/indexed assignment.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
502 // Rationale: we could avoid recursion using a state machine instead. However, using
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
503 // recursion is much more amenable to possible parallelization in the future.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
504 // Also, the recursion solution is cleaner and more understandable.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
505 class rec_index_helper
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
506 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
507 octave_idx_type *dim, *cdim;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
508 idx_vector *idx;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
509 int top;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
510
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
511 public:
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
512 rec_index_helper (const dim_vector& dv, const Array<idx_vector>& ia)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
513 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
514 int n = ia.length ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
515 assert (n > 0 && (dv.length () == std::max (n, 2)));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
516
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
517 dim = new octave_idx_type [2*n];
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
518 // A hack to avoid double allocation
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
519 cdim = dim + n;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
520 idx = new idx_vector [n];
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
521 top = 0;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
522
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
523 dim[0] = dv(0);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
524 cdim[0] = 1;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
525 idx[0] = ia(0);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
526
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
527 for (int i = 1; i < n; i++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
528 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
529 // Try reduction...
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
530 if (idx[top].maybe_reduce (dim[top], ia(i), dv(i)))
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
531 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
532 // Reduction successful, fold dimensions.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
533 dim[top] *= dv(i);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
534 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
535 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
536 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
537 // Unsuccessful, store index & cumulative dim.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
538 top++;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
539 idx[top] = ia(i);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
540 dim[top] = dv(i);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
541 cdim[top] = cdim[top-1] * dim[top-1];
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
542 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
543 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
544 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
545
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
546 ~rec_index_helper (void) { delete [] idx; delete [] dim; }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
547
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
548 private:
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
549
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
550 // Recursive N-d indexing
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
551 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
552 T *do_index (const T *src, T *dest, int lev) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
553 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
554 if (lev == 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
555 dest += idx[0].index (src, dim[0], dest);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
556 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
557 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
558 octave_idx_type n = idx[lev].length (dim[lev]), d = cdim[lev];
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
559 for (octave_idx_type i = 0; i < n; i++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
560 dest = do_index (src + d*idx[lev].xelem (i), dest, lev-1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
561 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
562
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
563 return dest;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
564 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
565
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
566 // Recursive N-d indexed assignment
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
567 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
568 const T *do_assign (const T *src, T *dest, int lev) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
569 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
570 if (lev == 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
571 src += idx[0].assign (src, dim[0], dest);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
572 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
573 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
574 octave_idx_type n = idx[lev].length (dim[lev]), d = cdim[lev];
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
575 for (octave_idx_type i = 0; i < n; i++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
576 src = do_assign (src, dest + d*idx[lev].xelem (i), lev-1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
577 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
578
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
579 return src;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
580 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
581
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
582 // Recursive N-d indexed assignment
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
583 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
584 void do_fill (const T& val, T *dest, int lev) const
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
585 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
586 if (lev == 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
587 idx[0].fill (val, dim[0], dest);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
588 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
589 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
590 octave_idx_type n = idx[lev].length (dim[lev]), d = cdim[lev];
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
591 for (octave_idx_type i = 0; i < n; i++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
592 do_fill (val, dest + d*idx[lev].xelem (i), lev-1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
593 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
594 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
595
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
596 public:
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
597
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
598 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
599 void index (const T *src, T *dest) const { do_index (src, dest, top); }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
600
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
601 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
602 void assign (const T *src, T *dest) const { do_assign (src, dest, top); }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
603
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
604 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
605 void fill (const T& val, T *dest) const { do_fill (val, dest, top); }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
606
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
607 bool is_cont_range (octave_idx_type& l,
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
608 octave_idx_type& u) const
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
609 {
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
610 return top == 0 && idx[0].is_cont_range (dim[0], l, u);
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
611 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
612 };
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
613
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
614 // Helper class for multi-d recursive resizing
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
615 // This handles resize () in an efficient manner, touching memory only
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
616 // once (apart from reinitialization)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
617 class rec_resize_helper
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
618 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
619 octave_idx_type *cext, *sext, *dext;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
620 int n;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
621
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
622 public:
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
623 rec_resize_helper (const dim_vector& ndv, const dim_vector& odv)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
624 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
625 int l = ndv.length ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
626 assert (odv.length () == l);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
627 octave_idx_type ld = 1;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
628 int i = 0;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
629 for (; i < l-1 && ndv(i) == odv(i); i++) ld *= ndv(i);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
630 n = l - i;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
631 cext = new octave_idx_type[3*n];
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
632 // Trick to avoid three allocations
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
633 sext = cext + n;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
634 dext = sext + n;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
635
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
636 octave_idx_type sld = ld, dld = ld;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
637 for (int j = 0; j < n; j++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
638 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
639 cext[j] = std::min (ndv(i+j), odv(i+j));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
640 sext[j] = sld *= odv(i+j);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
641 dext[j] = dld *= ndv(i+j);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
642 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
643 cext[0] *= ld;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
644 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
645
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
646 ~rec_resize_helper (void) { delete [] cext; }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
647
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
648 private:
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
649 // recursive resizing
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
650 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
651 void do_resize_fill (const T* src, T *dest, const T& rfv, int lev) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
652 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
653 if (lev == 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
654 {
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
655 copy_or_memcpy (cext[0], src, dest);
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
656 fill_or_memset (dext[0] - cext[0], rfv, dest + cext[0]);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
657 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
658 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
659 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
660 octave_idx_type sd = sext[lev-1], dd = dext[lev-1], k;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
661 for (k = 0; k < cext[lev]; k++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
662 do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
663
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
664 fill_or_memset (dext[lev] - k * dd, rfv, dest + k * dd);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
665 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
666 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
667 public:
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
668 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
669 void resize_fill (const T* src, T *dest, const T& rfv) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
670 { do_resize_fill (src, dest, rfv, n-1); }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
671
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
672 };
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
673
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
674 static void gripe_index_out_of_range (void)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
675 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
676 (*current_liboctave_error_handler)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
677 ("A(I): Index exceeds matrix dimension.");
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
678 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
679
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
680 template <class T>
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
681 Array<T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
682 Array<T>::index (const idx_vector& i) const
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
683 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
684 octave_idx_type n = numel ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
685 Array<T> retval;
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
686
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
687 if (i.is_colon ())
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
688 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
689 // A(:) produces a shallow copy as a column vector.
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
690 retval = Array<T> (*this, dim_vector (n, 1));
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
691 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
692 else if (i.extent (n) != n)
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4545
diff changeset
693 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
694 gripe_index_out_of_range ();
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4545
diff changeset
695 }
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4545
diff changeset
696 else
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
697 {
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
698 // FIXME -- this is the only place where orig_dimensions are used.
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
699 dim_vector rd = i.orig_dimensions ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
700 octave_idx_type il = i.length (n);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
701
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
702 // FIXME -- this is for Matlab compatibility. Matlab 2007 given
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
703 //
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
704 // b = ones(3,1)
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
705 //
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
706 // yields the following:
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
707 //
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
708 // b(zeros(0,0)) gives []
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
709 // b(zeros(1,0)) gives zeros(0,1)
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
710 // b(zeros(0,1)) gives zeros(0,1)
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
711 // b(zeros(0,m)) gives zeros(0,m)
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
712 // b(zeros(m,0)) gives zeros(m,0)
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
713 // b(1:2) gives ones(2,1)
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
714 // b(ones(2)) gives ones(2) etc.
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
715 //
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
716 // As you can see, the behaviour is weird, but the tests end up pretty
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
717 // simple. Nah, I don't want to suggest that this is ad hoc :)
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
718
9987
bb30843c4929 fix subscripting of vectors by N-d arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9921
diff changeset
719 if (ndims () == 2 && n != 1 && rd.is_vector ())
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
720 {
9987
bb30843c4929 fix subscripting of vectors by N-d arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9921
diff changeset
721 if (columns () == 1)
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
722 rd = dim_vector (il, 1);
9987
bb30843c4929 fix subscripting of vectors by N-d arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9921
diff changeset
723 else if (rows () == 1)
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
724 rd = dim_vector (1, il);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
725 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
726
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
727 octave_idx_type l, u;
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
728 if (il != 0 && i.is_cont_range (n, l, u))
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
729 // If suitable, produce a shallow slice.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
730 retval = Array<T> (*this, rd, l, u);
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
731 else
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
732 {
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
733 // Don't use resize here to avoid useless initialization for POD
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
734 // types.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
735 retval = Array<T> (rd);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
736
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
737 if (il != 0)
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
738 i.index (data (), n, retval.fortran_vec ());
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
739 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
740 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
741
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
742 return retval;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
743 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
744
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
745 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
746 Array<T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
747 Array<T>::index (const idx_vector& i, const idx_vector& j) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
748 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
749 // Get dimensions, allowing Fortran indexing in the 2nd dim.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
750 dim_vector dv = dimensions.redim (2);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
751 octave_idx_type r = dv(0), c = dv(1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
752 Array<T> retval;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
753
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
754 if (i.is_colon () && j.is_colon ())
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
755 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
756 // A(:,:) produces a shallow copy.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
757 retval = Array<T> (*this, dv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
758 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
759 else if (i.extent (r) != r || j.extent (c) != c)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
760 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
761 gripe_index_out_of_range ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
762 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
763 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
764 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
765 octave_idx_type n = numel (), il = i.length (r), jl = j.length (c);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
766
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
767 idx_vector ii (i);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
768
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
769 if (ii.maybe_reduce (r, j, c))
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
770 {
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
771 octave_idx_type l, u;
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
772 if (ii.length () > 0 && ii.is_cont_range (n, l, u))
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
773 // If suitable, produce a shallow slice.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
774 retval = Array<T> (*this, dim_vector (il, jl), l, u);
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
775 else
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
776 {
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
777 // Don't use resize here to avoid useless initialization for POD types.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
778 retval = Array<T> (dim_vector (il, jl));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
779
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
780 ii.index (data (), n, retval.fortran_vec ());
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
781 }
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
782 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
783 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
784 {
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
785 // Don't use resize here to avoid useless initialization for POD types.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
786 retval = Array<T> (dim_vector (il, jl));
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
787
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
788 const T* src = data ();
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
789 T *dest = retval.fortran_vec ();
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
790
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
791 for (octave_idx_type k = 0; k < jl; k++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
792 dest += i.index (src + r * j.xelem (k), r, dest);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
793 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
794 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
795
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
796 return retval;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
797 }
4747
3f28979bbe2c [project @ 2004-02-06 23:56:46 by jwe]
jwe
parents: 4746
diff changeset
798
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
799 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
800 Array<T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
801 Array<T>::index (const Array<idx_vector>& ia) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
802 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
803 int ial = ia.length ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
804 Array<T> retval;
4587
7b957b442818 [project @ 2003-11-10 15:50:39 by jwe]
jwe
parents: 4586
diff changeset
805
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
806 // FIXME: is this dispatching necessary?
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
807 if (ial == 1)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
808 retval = index (ia(0));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
809 else if (ial == 2)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
810 retval = index (ia(0), ia(1));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
811 else if (ial > 0)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
812 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
813 // Get dimensions, allowing Fortran indexing in the last dim.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
814 dim_vector dv = dimensions.redim (ial);
4747
3f28979bbe2c [project @ 2004-02-06 23:56:46 by jwe]
jwe
parents: 4746
diff changeset
815
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
816 // Check for out of bounds conditions.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
817 bool all_colons = true, mismatch = false;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
818 for (int i = 0; i < ial; i++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
819 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
820 if (ia(i).extent (dv(i)) != dv(i))
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
821 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
822 mismatch = true;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
823 break;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
824 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
825 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
826 all_colons = all_colons && ia(i).is_colon ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
827 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
828
4870
2cbc6f37b0c2 [project @ 2004-04-21 17:30:51 by jwe]
jwe
parents: 4834
diff changeset
829
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
830 if (mismatch)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
831 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
832 gripe_index_out_of_range ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
833 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
834 else if (all_colons)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
835 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
836 // A(:,:,...,:) produces a shallow copy.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
837 retval = Array<T> (*this, dv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
838 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
839 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
840 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
841 // Form result dimensions.
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9341
diff changeset
842 dim_vector rdv = dim_vector::alloc (ial);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
843 for (int i = 0; i < ial; i++) rdv(i) = ia(i).length (dv(i));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
844 rdv.chop_trailing_singletons ();
4870
2cbc6f37b0c2 [project @ 2004-04-21 17:30:51 by jwe]
jwe
parents: 4834
diff changeset
845
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
846 // Prepare for recursive indexing
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
847 rec_index_helper rh (dv, ia);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
848
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
849 octave_idx_type l, u;
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
850 if (rh.is_cont_range (l, u))
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
851 // If suitable, produce a shallow slice.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
852 retval = Array<T> (*this, rdv, l, u);
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
853 else
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
854 {
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
855 // Don't use resize here to avoid useless initialization for POD types.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
856 retval = Array<T> (rdv);
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
857
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
858 // Do it.
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
859 rh.index (data (), retval.fortran_vec ());
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
860 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
861 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
862 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
863
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
864 return retval;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
865 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
866
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
867 // FIXME -- the following is a common error message to resize,
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
868 // regardless of whether it's called from assign or elsewhere. It
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
869 // seems OK to me, but eventually the gripe can be specialized.
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
870 // Anyway, propagating various error messages into procedure is, IMHO,
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
871 // a nonsense. If anything, we should change error handling here (and
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
872 // throughout liboctave) to allow custom handling of errors
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
873 static void gripe_invalid_resize (void)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
874 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
875 (*current_liboctave_error_handler)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
876 ("resize: Invalid resizing operation or ambiguous assignment to an out-of-bounds array element.");
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
877 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
878
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
879 // The default fill value. Override if you want a different one.
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
880
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
881 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
882 T Array<T>::resize_fill_value ()
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
883 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
884 return T ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
885 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
886
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
887 // Yes, we could do resize using index & assign. However, that would
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
888 // possibly involve a lot more memory traffic than we actually need.
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
889
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
890 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
891 void
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
892 Array<T>::resize_fill (octave_idx_type n, const T& rfv)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
893 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
894 if (n >= 0 && ndims () == 2)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
895 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
896 dim_vector dv;
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
897 // This is driven by Matlab's behaviour of giving a *row* vector
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
898 // on some out-of-bounds assignments. Specifically, Matlab
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
899 // allows a(i) with out-of-bouds i when a is either of 0x0, 1x0,
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
900 // 1x1, 0xN, and gives a row vector in all cases (yes, even the
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
901 // last one, search me why). Giving a column vector would make
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
902 // much more sense (given the way trailing singleton dims are
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
903 // treated).
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
904 bool invalid = false;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
905 if (rows () == 0 || rows () == 1)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
906 dv = dim_vector (1, n);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
907 else if (columns () == 1)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
908 dv = dim_vector (n, 1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
909 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
910 invalid = true;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
911
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
912 if (invalid)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
913 gripe_invalid_resize ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
914 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
915 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
916 octave_idx_type nx = numel ();
9100
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
917 if (n == nx - 1 && n > 0)
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
918 {
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
919 // Stack "pop" operation.
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
920 if (rep->count == 1)
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
921 slice_data[slice_len-1] = T ();
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
922 slice_len--;
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
923 dimensions = dv;
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
924 }
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
925 else if (n == nx + 1 && nx > 0)
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
926 {
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
927 // Stack "push" operation.
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
928 if (rep->count == 1 && slice_data + slice_len < rep->data + rep->len)
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
929 {
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
930 slice_data[slice_len++] = rfv;
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
931 dimensions = dv;
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
932 }
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
933 else
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
934 {
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
935 static const octave_idx_type max_stack_chunk = 1024;
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
936 octave_idx_type nn = n + std::min (nx, max_stack_chunk);
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
937 Array<T> tmp (Array<T> (nn), dv, 0, n);
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
938 T *dest = tmp.fortran_vec ();
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
939
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
940 copy_or_memcpy (nx, data (), dest);
9100
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
941 dest[nx] = rfv;
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
942
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
943 *this = tmp;
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
944 }
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
945 }
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
946 else if (n != nx)
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
947 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
948 Array<T> tmp = Array<T> (dv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
949 T *dest = tmp.fortran_vec ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
950
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
951 octave_idx_type n0 = std::min (n, nx), n1 = n - n0;
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
952 copy_or_memcpy (n0, data (), dest);
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
953 fill_or_memset (n1, rfv, dest + n0);
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
954
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
955 *this = tmp;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
956 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
957 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
958 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
959 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
960 gripe_invalid_resize ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
961 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
962
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
963 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
964 void
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
965 Array<T>::resize_fill (octave_idx_type r, octave_idx_type c, const T& rfv)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
966 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
967 if (r >= 0 && c >= 0 && ndims () == 2)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
968 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
969 octave_idx_type rx = rows (), cx = columns ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
970 if (r != rx || c != cx)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
971 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
972 Array<T> tmp = Array<T> (dim_vector (r, c));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
973 T *dest = tmp.fortran_vec ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
974
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
975 octave_idx_type r0 = std::min (r, rx), r1 = r - r0;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
976 octave_idx_type c0 = std::min (c, cx), c1 = c - c0;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
977 const T *src = data ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
978 if (r == rx)
9773
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
979 {
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
980 copy_or_memcpy (r * c0, src, dest);
9773
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
981 dest += r * c0;
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
982 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
983 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
984 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
985 for (octave_idx_type k = 0; k < c0; k++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
986 {
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
987 copy_or_memcpy (r0, src, dest);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
988 src += rx;
9773
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
989 dest += r0;
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
990 fill_or_memset (r1, rfv, dest);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
991 dest += r1;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
992 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
993 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
994
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
995 fill_or_memset (r * c1, rfv, dest);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
996
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
997 *this = tmp;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
998 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
999 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1000 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1001 gripe_invalid_resize ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1002
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1003 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1004
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1005 template<class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1006 void
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1007 Array<T>::resize_fill (const dim_vector& dv, const T& rfv)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1008 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1009 int dvl = dv.length ();
8784
374cb30311a8 remove dead branch in Array.cc
Jaroslav Hajek <highegg@gmail.com>
parents: 8760
diff changeset
1010 if (dvl == 2)
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1011 resize (dv(0), dv(1), rfv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1012 else if (dimensions != dv)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1013 {
8799
f6dc6eb57045 improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 8784
diff changeset
1014 if (dimensions.length () <= dvl && ! dv.any_neg ())
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1015 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1016 Array<T> tmp (dv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1017 // Prepare for recursive resizing.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1018 rec_resize_helper rh (dv, dimensions.redim (dvl));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1019
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1020 // Do it.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1021 rh.resize_fill (data (), tmp.fortran_vec (), rfv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1022 *this = tmp;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1023 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1024 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1025 gripe_invalid_resize ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1026 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1027 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1028
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1029 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1030 Array<T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1031 Array<T>::index (const idx_vector& i, bool resize_ok, const T& rfv) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1032 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1033 Array<T> tmp = *this;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1034 if (resize_ok)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1035 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1036 octave_idx_type n = numel (), nx = i.extent (n);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1037 if (n != nx)
8563
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1038 {
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1039 if (i.is_scalar ())
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1040 return Array<T> (1, rfv);
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1041 else
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1042 tmp.resize_fill (nx, rfv);
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1043 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1044
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1045 if (tmp.numel () != nx)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1046 return Array<T> ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1047 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1048
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1049 return tmp.index (i);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1050 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1051
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1052 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1053 Array<T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1054 Array<T>::index (const idx_vector& i, const idx_vector& j,
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1055 bool resize_ok, const T& rfv) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1056 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1057 Array<T> tmp = *this;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1058 if (resize_ok)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1059 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1060 dim_vector dv = dimensions.redim (2);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1061 octave_idx_type r = dv(0), c = dv(1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1062 octave_idx_type rx = i.extent (r), cx = j.extent (c);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1063 if (r != rx || c != cx)
8563
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1064 {
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1065 if (i.is_scalar () && j.is_scalar ())
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1066 return Array<T> (1, rfv);
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1067 else
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1068 tmp.resize_fill (rx, cx, rfv);
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1069 }
4747
3f28979bbe2c [project @ 2004-02-06 23:56:46 by jwe]
jwe
parents: 4746
diff changeset
1070
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1071 if (tmp.rows () != rx || tmp.columns () != cx)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1072 return Array<T> ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1073 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1074
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1075 return tmp.index (i, j);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1076 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1077
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1078 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1079 Array<T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1080 Array<T>::index (const Array<idx_vector>& ia,
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1081 bool resize_ok, const T& rfv) const
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1082 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1083 Array<T> tmp = *this;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1084 if (resize_ok)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1085 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1086 int ial = ia.length ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1087 dim_vector dv = dimensions.redim (ial);
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9341
diff changeset
1088 dim_vector dvx = dim_vector::alloc (ial);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1089 for (int i = 0; i < ial; i++) dvx(i) = ia(i).extent (dv (i));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1090 if (! (dvx == dv))
8563
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1091 {
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1092 bool all_scalars = true;
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1093 for (int i = 0; i < ial; i++)
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1094 all_scalars = all_scalars && ia(i).is_scalar ();
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1095 if (all_scalars)
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1096 return Array<T> (1, rfv);
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1097 else
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1098 tmp.resize_fill (dvx, rfv);
3a3421a9f0bb optimize resizable indexing with scalars
Jaroslav Hajek <highegg@gmail.com>
parents: 8527
diff changeset
1099 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1100
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1101 if (tmp.dimensions != dvx)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1102 return Array<T> ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1103 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1104
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1105 return tmp.index (ia);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1106 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1107
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1108
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1109 static void
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1110 gripe_invalid_assignment_size (void)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1111 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1112 (*current_liboctave_error_handler)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1113 ("A(I) = X: X must have the same size as I");
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1114 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1115
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1116 static void
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1117 gripe_assignment_dimension_mismatch (void)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1118 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1119 (*current_liboctave_error_handler)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1120 ("A(I,J,...) = X: dimensions mismatch");
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1121 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1122
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1123 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1124 void
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1125 Array<T>::assign (const idx_vector& i, const Array<T>& rhs, const T& rfv)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1126 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1127 octave_idx_type n = numel (), rhl = rhs.numel ();
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4545
diff changeset
1128
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1129 if (rhl == 1 || i.length (n) == rhl)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1130 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1131 octave_idx_type nx = i.extent (n);
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1132 bool colon = i.is_colon_equiv (nx);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1133 // Try to resize first if necessary.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1134 if (nx != n)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1135 {
8580
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1136 // Optimize case A = []; A(1:n) = X with A empty.
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1137 if (dimensions.zero_by_zero () && colon)
8580
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1138 {
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1139 if (rhl == 1)
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1140 *this = Array<T> (dim_vector (1, nx), rhs(0));
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1141 else
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1142 *this = Array<T> (rhs, dim_vector (1, nx));
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1143 return;
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1144 }
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1145
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1146 resize_fill (nx, rfv);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1147 n = numel ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1148 }
4747
3f28979bbe2c [project @ 2004-02-06 23:56:46 by jwe]
jwe
parents: 4746
diff changeset
1149
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1150 if (colon)
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1151 {
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1152 // A(:) = X makes a full fill or a shallow copy.
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1153 if (rhl == 1)
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1154 fill (rhs(0));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1155 else
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1156 *this = rhs.reshape (dimensions);
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1157 }
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1158 else
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1159 {
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1160 if (rhl == 1)
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1161 i.fill (rhs(0), n, fortran_vec ());
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1162 else
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1163 i.assign (rhs.data (), n, fortran_vec ());
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1164 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1165 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1166 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1167 gripe_invalid_assignment_size ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1168 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1169
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1170 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1171 void
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1172 Array<T>::assign (const idx_vector& i, const idx_vector& j,
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1173 const Array<T>& rhs, const T& rfv)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1174 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1175 // Get RHS extents, discarding singletons.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1176 dim_vector rhdv = rhs.dims ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1177 // Get LHS extents, allowing Fortran indexing in the second dim.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1178 dim_vector dv = dimensions.redim (2);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1179 // Check for out-of-bounds and form resizing dimensions.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1180 dim_vector rdv;
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1181 // In the special when all dimensions are zero, colons are allowed
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1182 // to inquire the shape of RHS. The rules are more obscure, so we
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1183 // solve that elsewhere.
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1184 if (dv.all_zero ())
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1185 rdv = zero_dims_inquire (i, j, rhdv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1186 else
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1187 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1188 rdv(0) = i.extent (dv(0));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1189 rdv(1) = j.extent (dv(1));
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1190 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1191
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1192 bool isfill = rhs.numel () == 1;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1193 octave_idx_type il = i.length (rdv(0)), jl = j.length (rdv(1));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1194 rhdv.chop_all_singletons ();
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1195 bool match = (isfill
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1196 || (rhdv.length () == 2 && il == rhdv(0) && jl == rhdv(1)));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1197 match = match || (il == 1 && jl == rhdv(0) && rhdv(1) == 1);
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4545
diff changeset
1198
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1199 if (match)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1200 {
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1201 bool all_colons = (i.is_colon_equiv (rdv(0))
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1202 && j.is_colon_equiv (rdv(1)));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1203 // Resize if requested.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1204 if (rdv != dv)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1205 {
8580
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1206 // Optimize case A = []; A(1:m, 1:n) = X
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1207 if (dv.zero_by_zero () && all_colons)
8580
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1208 {
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1209 if (isfill)
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1210 *this = Array<T> (rdv, rhs(0));
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1211 else
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1212 *this = Array<T> (rhs, rdv);
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1213 return;
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1214 }
188d38a553c7 further indexing optimization touches
Jaroslav Hajek <highegg@gmail.com>
parents: 8563
diff changeset
1215
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1216 resize (rdv, rfv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1217 dv = dimensions;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1218 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1219
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1220 if (all_colons)
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1221 {
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1222 // A(:,:) = X makes a full fill or a shallow copy
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1223 if (isfill)
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1224 fill (rhs(0));
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1225 else
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1226 *this = rhs.reshape (dimensions);
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1227 }
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1228 else
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1229 {
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1230 // The actual work.
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1231 octave_idx_type n = numel (), r = dv (0), c = dv (1);
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1232 idx_vector ii (i);
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1233
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1234 const T* src = rhs.data ();
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1235 T *dest = fortran_vec ();
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1236
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1237 // Try reduction first.
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1238 if (ii.maybe_reduce (r, j, c))
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1239 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1240 if (isfill)
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1241 ii.fill (*src, n, dest);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1242 else
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1243 ii.assign (src, n, dest);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1244 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1245 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1246 {
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1247 if (isfill)
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1248 {
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1249 for (octave_idx_type k = 0; k < jl; k++)
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1250 i.fill (*src, r, dest + r * j.xelem (k));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1251 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1252 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1253 {
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1254 for (octave_idx_type k = 0; k < jl; k++)
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1255 src += i.assign (src, r, dest + r * j.xelem (k));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1256 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1257 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1258 }
4747
3f28979bbe2c [project @ 2004-02-06 23:56:46 by jwe]
jwe
parents: 4746
diff changeset
1259 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1260 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1261 gripe_assignment_dimension_mismatch ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1262 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1263
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1264 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1265 void
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1266 Array<T>::assign (const Array<idx_vector>& ia,
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1267 const Array<T>& rhs, const T& rfv)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1268 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1269 int ial = ia.length ();
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1270
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1271 // FIXME: is this dispatching necessary / desirable?
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1272 if (ial == 1)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1273 assign (ia(0), rhs, rfv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1274 else if (ial == 2)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1275 assign (ia(0), ia(1), rhs, rfv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1276 else if (ial > 0)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1277 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1278 // Get RHS extents, discarding singletons.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1279 dim_vector rhdv = rhs.dims ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1280
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1281 // Get LHS extents, allowing Fortran indexing in the second dim.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1282 dim_vector dv = dimensions.redim (ial);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1283
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1284 // Get the extents forced by indexing.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1285 dim_vector rdv;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1286
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1287 // In the special when all dimensions are zero, colons are
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1288 // allowed to inquire the shape of RHS. The rules are more
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1289 // obscure, so we solve that elsewhere.
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1290 if (dv.all_zero ())
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1291 rdv = zero_dims_inquire (ia, rhdv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1292 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1293 {
9507
b096d11237be dim_vector improvements
Jaroslav Hajek <highegg@gmail.com>
parents: 9341
diff changeset
1294 rdv = dim_vector::alloc (ial);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1295 for (int i = 0; i < ial; i++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1296 rdv(i) = ia(i).extent (dv(i));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1297 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1298
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1299 // Check whether LHS and RHS match, up to singleton dims.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1300 bool match = true, all_colons = true, isfill = rhs.numel () == 1;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1301
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1302 rhdv.chop_all_singletons ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1303 int j = 0, rhdvl = rhdv.length ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1304 for (int i = 0; i < ial; i++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1305 {
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1306 all_colons = all_colons && ia(i).is_colon_equiv (rdv(i));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1307 octave_idx_type l = ia(i).length (rdv(i));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1308 if (l == 1) continue;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1309 match = match && j < rhdvl && l == rhdv(j++);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1310 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1311
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1312 match = match && (j == rhdvl || rhdv(j) == 1);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1313 match = match || isfill;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1314
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1315 if (match)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1316 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1317 // Resize first if necessary.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1318 if (rdv != dv)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1319 {
9886
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1320 // Optimize case A = []; A(1:m, 1:n) = X
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1321 if (dv.zero_by_zero () && all_colons)
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1322 {
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1323 rdv.chop_trailing_singletons ();
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1324 if (isfill)
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1325 *this = Array<T> (rdv, rhs(0));
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1326 else
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1327 *this = Array<T> (rhs, rdv);
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1328 return;
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1329 }
cddd5c3d5f04 fix & extend special-case optimizations for indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents: 9878
diff changeset
1330
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1331 resize_fill (rdv, rfv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1332 dv = dimensions;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1333 chop_trailing_singletons ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1334 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1335
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1336 if (all_colons)
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1337 {
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1338 // A(:,:,...,:) = X makes a full fill or a shallow copy.
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1339 if (isfill)
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1340 fill (rhs(0));
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1341 else
9058
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1342 *this = rhs.reshape (dimensions);
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1343 }
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1344 else
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1345 {
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1346 // Do the actual work.
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1347
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1348 // Prepare for recursive indexing
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1349 rec_index_helper rh (dv, ia);
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1350
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1351 // Do it.
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1352 if (isfill)
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1353 rh.fill (rhs(0), fortran_vec ());
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1354 else
2da105bf2507 remove redundant checks from Array<T>::index
Jaroslav Hajek <highegg@gmail.com>
parents: 9046
diff changeset
1355 rh.assign (rhs.data (), fortran_vec ());
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1356 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1357 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1358 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1359 gripe_assignment_dimension_mismatch ();
4553
c7eb767505e9 [project @ 2003-10-27 21:39:55 by jwe]
jwe
parents: 4548
diff changeset
1360 }
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1361 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1362
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1363 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1364 void
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1365 Array<T>::delete_elements (const idx_vector& i)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1366 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1367 octave_idx_type n = numel ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1368 if (i.is_colon ())
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1369 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1370 *this = Array<T> ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1371 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1372 else if (i.extent (n) != n)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1373 {
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1374 gripe_index_out_of_range ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1375 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1376 else if (i.length (n) != 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1377 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1378 octave_idx_type l, u;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1379 bool col_vec = ndims () == 2 && columns () == 1 && rows () != 1;
9100
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
1380 if (i.is_scalar () && i(0) == n-1)
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
1381 {
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
1382 // Stack "pop" operation.
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
1383 resize (n-1);
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
1384 }
1a8bbfb2f7cf optimize simple stack operations on arrays
Jaroslav Hajek <highegg@gmail.com>
parents: 9058
diff changeset
1385 else if (i.is_cont_range (n, l, u))
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1386 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1387 // Special case deleting a contiguous range.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1388 octave_idx_type m = n + l - u;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1389 Array<T> tmp (dim_vector (col_vec ? m : 1, !col_vec ? m : 1));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1390 const T *src = data ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1391 T *dest = tmp.fortran_vec ();
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
1392 copy_or_memcpy (l, src, dest);
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
1393 copy_or_memcpy (n - u, src + u, dest + l);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1394 *this = tmp;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1395 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1396 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1397 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1398 // Use index.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1399 *this = index (i.complement (n));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1400 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1401 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1402 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1403
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1404 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1405 void
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1406 Array<T>::delete_elements (int dim, const idx_vector& i)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1407 {
8302
f2e050b62199 fix dim check in Array<T>::delete_elements
Jaroslav Hajek <highegg@gmail.com>
parents: 8290
diff changeset
1408 if (dim < 0 || dim >= ndims ())
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1409 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1410 (*current_liboctave_error_handler)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1411 ("invalid dimension in delete_elements");
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1412 return;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1413 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1414
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1415 octave_idx_type n = dimensions (dim);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1416 if (i.is_colon ())
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1417 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1418 *this = Array<T> ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1419 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1420 else if (i.extent (n) != n)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1421 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1422 gripe_index_out_of_range ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1423 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1424 else if (i.length (n) != 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1425 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1426 octave_idx_type l, u;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1427
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1428 if (i.is_cont_range (n, l, u))
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1429 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1430 // Special case deleting a contiguous range.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1431 octave_idx_type nd = n + l - u, dl = 1, du = 1;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1432 dim_vector rdv = dimensions;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1433 rdv(dim) = nd;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1434 for (int k = 0; k < dim; k++) dl *= dimensions(k);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1435 for (int k = dim + 1; k < ndims (); k++) du *= dimensions(k);
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1436
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1437 // Special case deleting a contiguous range.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1438 Array<T> tmp = Array<T> (rdv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1439 const T *src = data ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1440 T *dest = tmp.fortran_vec ();
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1441 l *= dl; u *= dl; n *= dl;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1442 for (octave_idx_type k = 0; k < du; k++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1443 {
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
1444 copy_or_memcpy (l, src, dest);
9773
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
1445 dest += l;
9780
6dafc60dde31 rename oct-mem functions
Jaroslav Hajek <highegg@gmail.com>
parents: 9773
diff changeset
1446 copy_or_memcpy (n - u, src + u, dest);
9773
01f897d8a130 optimize memory manipulation by arrays & indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
1447 dest += n - u;
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1448 src += n;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1449 }
4870
2cbc6f37b0c2 [project @ 2004-04-21 17:30:51 by jwe]
jwe
parents: 4834
diff changeset
1450
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1451 *this = tmp;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1452 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1453 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1454 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1455 // Use index.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1456 Array<idx_vector> ia (ndims (), idx_vector::colon);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1457 ia (dim) = i.complement (n);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1458 *this = index (ia);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1459 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1460 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1461 }
4747
3f28979bbe2c [project @ 2004-02-06 23:56:46 by jwe]
jwe
parents: 4746
diff changeset
1462
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1463 template <class T>
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1464 void
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1465 Array<T>::delete_elements (const Array<idx_vector>& ia)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1466 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1467 if (ia.length () == 1)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1468 delete_elements (ia(0));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1469 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1470 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1471 int len = ia.length (), k, dim = -1;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1472 for (k = 0; k < len; k++)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1473 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1474 if (! ia(k).is_colon ())
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1475 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1476 if (dim < 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1477 dim = k;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1478 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1479 break;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1480 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1481 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1482 if (dim < 0)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1483 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1484 dim_vector dv = dimensions;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1485 dv(0) = 0;
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1486 *this = Array<T> (dv);
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1487 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1488 else if (k == len)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1489 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1490 delete_elements (dim, ia(dim));
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1491 }
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1492 else
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1493 {
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1494 (*current_liboctave_error_handler)
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1495 ("A null assignment can only have one non-colon index.");
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1496 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1497 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1498
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1499 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1500
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1501 // FIXME: Remove these methods or implement them using assign.
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1502
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1503 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1504 Array<T>&
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1505 Array<T>::insert (const Array<T>& a, octave_idx_type r, octave_idx_type c)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1506 {
4786
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1507 if (ndims () == 2 && a.ndims () == 2)
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1508 insert2 (a, r, c);
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1509 else
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1510 insertN (a, r, c);
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1511
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1512 return *this;
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1513 }
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1514
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1515
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1516 template <class T>
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1517 Array<T>&
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1518 Array<T>::insert2 (const Array<T>& a, octave_idx_type r, octave_idx_type c)
4786
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1519 {
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1520 octave_idx_type a_rows = a.rows ();
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1521 octave_idx_type a_cols = a.cols ();
4786
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1522
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1523 if (r < 0 || r + a_rows > rows () || c < 0 || c + a_cols > cols ())
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1524 {
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1525 (*current_liboctave_error_handler) ("range error for insert");
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1526 return *this;
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1527 }
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1528
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1529 for (octave_idx_type j = 0; j < a_cols; j++)
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1530 for (octave_idx_type i = 0; i < a_rows; i++)
4786
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1531 elem (r+i, c+j) = a.elem (i, j);
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1532
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1533 return *this;
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1534 }
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1535
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1536 template <class T>
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1537 Array<T>&
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1538 Array<T>::insertN (const Array<T>& a, octave_idx_type r, octave_idx_type c)
4786
fc316bde0053 [project @ 2004-02-18 12:52:20 by jwe]
jwe
parents: 4765
diff changeset
1539 {
4806
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1540 dim_vector dv = dims ();
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1541
4765
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1542 dim_vector a_dv = a.dims ();
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1543
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1544 int n = a_dv.length ();
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1545
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1546 if (n == dimensions.length ())
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1547 {
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1548 Array<octave_idx_type> a_ra_idx (a_dv.length (), 0);
4765
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1549
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1550 a_ra_idx.elem (0) = r;
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1551 a_ra_idx.elem (1) = c;
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1552
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1553 for (int i = 0; i < n; i++)
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1554 {
4806
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1555 if (a_ra_idx(i) < 0 || (a_ra_idx(i) + a_dv(i)) > dv(i))
4765
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1556 {
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1557 (*current_liboctave_error_handler)
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1558 ("Array<T>::insert: range error for insert");
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1559 return *this;
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1560 }
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1561 }
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1562
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1563 octave_idx_type n_elt = a.numel ();
4806
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1564
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1565 const T *a_data = a.data ();
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1566
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1567 octave_idx_type iidx = 0;
4806
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1568
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1569 octave_idx_type a_rows = a_dv(0);
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1570
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1571 octave_idx_type this_rows = dv(0);
4806
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1572
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1573 octave_idx_type numel_page = a_dv(0) * a_dv(1);
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1574
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1575 octave_idx_type count_pages = 0;
4806
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1576
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1577 for (octave_idx_type i = 0; i < n_elt; i++)
4765
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1578 {
4806
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1579 if (i != 0 && i % a_rows == 0)
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1580 iidx += (this_rows - a_rows);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1581
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1582 if (i % numel_page == 0)
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1583 iidx = c * dv(0) + r + dv(0) * dv(1) * count_pages++;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1584
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe]
jwe
parents: 4796
diff changeset
1585 elem (iidx++) = a_data[i];
4765
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1586 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1587 }
4765
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1588 else
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1589 (*current_liboctave_error_handler)
e941e1470d7b [project @ 2004-02-16 05:56:50 by jwe]
jwe
parents: 4762
diff changeset
1590 ("Array<T>::insert: invalid indexing operation");
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1591
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1592 return *this;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1593 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1594
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1595 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1596 Array<T>&
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1597 Array<T>::insert (const Array<T>& a, const Array<octave_idx_type>& ra_idx)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1598 {
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1599 octave_idx_type n = ra_idx.length ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1600
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1601 if (n == dimensions.length ())
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1602 {
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1603 dim_vector dva = a.dims ();
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1604 dim_vector dv = dims ();
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1605 int len_a = dva.length ();
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1606 int non_full_dim = 0;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1607
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1608 for (octave_idx_type i = 0; i < n; i++)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1609 {
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1610 if (ra_idx(i) < 0 || (ra_idx(i) +
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1611 (i < len_a ? dva(i) : 1)) > dimensions(i))
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1612 {
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1613 (*current_liboctave_error_handler)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1614 ("Array<T>::insert: range error for insert");
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1615 return *this;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1616 }
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1617
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1618 if (dv(i) != (i < len_a ? dva(i) : 1))
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1619 non_full_dim++;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1620 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1621
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1622 if (dva.numel ())
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1623 {
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1624 if (non_full_dim < 2)
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1625 {
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1626 // Special case for fast concatenation
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1627 const T *a_data = a.data ();
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1628 octave_idx_type numel_to_move = 1;
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1629 octave_idx_type skip = 0;
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1630 for (int i = 0; i < len_a; i++)
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1631 if (ra_idx(i) == 0 && dva(i) == dv(i))
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1632 numel_to_move *= dva(i);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1633 else
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1634 {
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1635 skip = numel_to_move * (dv(i) - dva(i));
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1636 numel_to_move *= dva(i);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1637 break;
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1638 }
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1639
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1640 octave_idx_type jidx = ra_idx(n-1);
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1641 for (int i = n-2; i >= 0; i--)
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1642 {
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1643 jidx *= dv(i);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1644 jidx += ra_idx(i);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1645 }
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1646
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1647 octave_idx_type iidx = 0;
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1648 octave_idx_type moves = dva.numel () / numel_to_move;
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1649 for (octave_idx_type i = 0; i < moves; i++)
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1650 {
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1651 for (octave_idx_type j = 0; j < numel_to_move; j++)
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1652 elem (jidx++) = a_data[iidx++];
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1653 jidx += skip;
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1654 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1655 }
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1656 else
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1657 {
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1658 // Generic code
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1659 const T *a_data = a.data ();
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1660 int nel = a.numel ();
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1661 Array<octave_idx_type> a_idx (n, 0);
5120
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1662
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1663 for (int i = 0; i < nel; i++)
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1664 {
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1665 int iidx = a_idx(n-1) + ra_idx(n-1);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1666 for (int j = n-2; j >= 0; j--)
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1667 {
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1668 iidx *= dv(j);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1669 iidx += a_idx(j) + ra_idx(j);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1670 }
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1671
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1672 elem (iidx) = a_data[i];
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1673
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1674 increment_index (a_idx, dva);
eb900c53cdb7 [project @ 2005-01-26 22:08:37 by jwe]
jwe
parents: 5108
diff changeset
1675 }
4915
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1676 }
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe]
jwe
parents: 4898
diff changeset
1677 }
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1678 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1679 else
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1680 (*current_liboctave_error_handler)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1681 ("Array<T>::insert: invalid indexing operation");
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1682
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1683 return *this;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1684 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1685
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
1686
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1687 template <class T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1688 Array<T>
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1689 Array<T>::transpose (void) const
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1690 {
4548
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4545
diff changeset
1691 assert (ndims () == 2);
820323598f4f [project @ 2003-10-26 03:16:42 by jwe]
jwe
parents: 4545
diff changeset
1692
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1693 octave_idx_type nr = dim1 ();
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1694 octave_idx_type nc = dim2 ();
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1695
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1696 if (nr >= 8 && nc >= 8)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1697 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1698 Array<T> result (dim_vector (nc, nr));
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1699
9121
bb62bc406ea7 reuse fast blocked transpose implementation from rec_permute_helper in Array<T>::transpose
Jaroslav Hajek <highegg@gmail.com>
parents: 9100
diff changeset
1700 // Reuse the implementation used for permuting.
bb62bc406ea7 reuse fast blocked transpose implementation from rec_permute_helper in Array<T>::transpose
Jaroslav Hajek <highegg@gmail.com>
parents: 9100
diff changeset
1701
bb62bc406ea7 reuse fast blocked transpose implementation from rec_permute_helper in Array<T>::transpose
Jaroslav Hajek <highegg@gmail.com>
parents: 9100
diff changeset
1702 rec_permute_helper::blk_trans (data (), result.fortran_vec (), nr, nc);
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1703
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1704 return result;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1705 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1706 else if (nr > 1 && nc > 1)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1707 {
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1708 Array<T> result (dim_vector (nc, nr));
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1709
5275
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1710 for (octave_idx_type j = 0; j < nc; j++)
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe]
jwe
parents: 5265
diff changeset
1711 for (octave_idx_type i = 0; i < nr; i++)
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1712 result.xelem (j, i) = xelem (i, j);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1713
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1714 return result;
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1715 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1716 else
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1717 {
8333
9238637cb81c style fixes
John W. Eaton <jwe@octave.org>
parents: 8302
diff changeset
1718 // Fast transpose for vectors and empty matrices.
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1719 return Array<T> (*this, dim_vector (nc, nr));
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1720 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1721 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1722
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1723 template <class T>
8028
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1724 static T
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1725 no_op_fcn (const T& x)
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1726 {
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1727 return x;
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1728 }
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1729
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1730 template <class T>
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1731 Array<T>
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1732 Array<T>::hermitian (T (*fcn) (const T&)) const
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1733 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1734 assert (ndims () == 2);
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1735
8028
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1736 if (! fcn)
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1737 fcn = no_op_fcn<T>;
f0fbf47c914c avoid null pointer call in Array<T>::hermitian
Jaroslav Hajek <highegg@gmail.com>
parents: 7796
diff changeset
1738
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1739 octave_idx_type nr = dim1 ();
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1740 octave_idx_type nc = dim2 ();
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1741
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1742 if (nr >= 8 && nc >= 8)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1743 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1744 Array<T> result (dim_vector (nc, nr));
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1745
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1746 // Blocked transpose to attempt to avoid cache misses.
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1747
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1748 // Don't use OCTAVE_LOCAL_BUFFER here as it doesn't work with bool
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1749 // on some compilers.
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1750 T buf[64];
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1751
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1752 octave_idx_type ii = 0, jj;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1753 for (jj = 0; jj < (nc - 8 + 1); jj += 8)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1754 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1755 for (ii = 0; ii < (nr - 8 + 1); ii += 8)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1756 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1757 // Copy to buffer
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1758 for (octave_idx_type j = jj, k = 0, idxj = jj * nr;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1759 j < jj + 8; j++, idxj += nr)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1760 for (octave_idx_type i = ii; i < ii + 8; i++)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1761 buf[k++] = xelem (i + idxj);
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1762
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1763 // Copy from buffer
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1764 for (octave_idx_type i = ii, idxi = ii * nc; i < ii + 8;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1765 i++, idxi += nc)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1766 for (octave_idx_type j = jj, k = i - ii; j < jj + 8;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1767 j++, k+=8)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1768 result.xelem (j + idxi) = fcn (buf[k]);
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1769 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1770
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1771 if (ii < nr)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1772 for (octave_idx_type j = jj; j < jj + 8; j++)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1773 for (octave_idx_type i = ii; i < nr; i++)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1774 result.xelem (j, i) = fcn (xelem (i, j));
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1775 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1776
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1777 for (octave_idx_type j = jj; j < nc; j++)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1778 for (octave_idx_type i = 0; i < nr; i++)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1779 result.xelem (j, i) = fcn (xelem (i, j));
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1780
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1781 return result;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1782 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1783 else
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1784 {
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1785 Array<T> result (dim_vector (nc, nr));
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1786
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1787 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1788 for (octave_idx_type i = 0; i < nr; i++)
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1789 result.xelem (j, i) = fcn (xelem (i, j));
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1790
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1791 return result;
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1792 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1793 }
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1794
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1795 /*
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1796
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1797 %% Tranpose tests for matrices of the tile size and plus or minus a row
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1798 %% and with four tiles.
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1799
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1800 %!shared m7, mt7, m8, mt8, m9, mt9
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1801 %! m7 = reshape (1 : 7*8, 8, 7);
7796
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1802 %! mt7 = [1:8; 9:16; 17:24; 25:32; 33:40; 41:48; 49:56];
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1803 %! m8 = reshape (1 : 8*8, 8, 8);
7796
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1804 %! mt8 = mt8 = [mt7; 57:64];
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1805 %! m9 = reshape (1 : 9*8, 8, 9);
7796
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1806 %! mt9 = [mt8; 65:72];
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1807
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1808 %!assert(m7', mt7)
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1809 %!assert((1i*m7).', 1i * mt7)
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1810 %!assert((1i*m7)', conj (1i * mt7))
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1811 %!assert(m8', mt8)
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1812 %!assert((1i*m8).', 1i * mt8)
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1813 %!assert((1i*m8)', conj (1i * mt8))
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1814 %!assert(m9', mt9)
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1815 %!assert((1i*m9).', 1i * mt9)
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1816 %!assert((1i*m9)', conj (1i * mt9))
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1817 %!assert([m7, m8; m7, m8]', [mt7, mt7; mt8, mt8])
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1818 %!assert((1i*[m7, m8; m7, m8]).', 1i * [mt7, mt7; mt8, mt8])
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1819 %!assert((1i*[m7, m8; m7, m8])', conj (1i * [mt7, mt7; mt8, mt8]))
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1820 %!assert([m8, m8; m8, m8]', [mt8, mt8; mt8, mt8])
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1821 %!assert((1i*[m8, m8; m8, m8]).', 1i * [mt8, mt8; mt8, mt8])
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1822 %!assert((1i*[m8, m8; m8, m8])', conj (1i * [mt8, mt8; mt8, mt8]))
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1823 %!assert([m9, m8; m9, m8]', [mt9, mt9; mt8, mt8])
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1824 %!assert((1i*[m9, m8; m9, m8]).', 1i * [mt9, mt9; mt8, mt8])
762801c50b21 Fix tests for transpose in Array.cc
David Bateman <dbateman@free.fr>
parents: 7789
diff changeset
1825 %!assert((1i*[m9, m8; m9, m8])', conj (1i * [mt9, mt9; mt8, mt8]))
7789
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1826
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1827 */
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1828
82be108cc558 First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents: 7717
diff changeset
1829 template <class T>
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1830 T *
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1831 Array<T>::fortran_vec (void)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1832 {
6881
cd2c6a69a70d [project @ 2007-09-07 21:48:09 by jwe]
jwe
parents: 6867
diff changeset
1833 make_unique ();
cd2c6a69a70d [project @ 2007-09-07 21:48:09 by jwe]
jwe
parents: 6867
diff changeset
1834
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
1835 return slice_data;
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1836 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1837
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
1838 template <class T>
3933
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe]
jwe
parents: 3657
diff changeset
1839 void
4517
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1840 Array<T>::maybe_delete_dims (void)
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1841 {
4587
7b957b442818 [project @ 2003-11-10 15:50:39 by jwe]
jwe
parents: 4586
diff changeset
1842 int nd = dimensions.length ();
4517
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1843
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1844 dim_vector new_dims (1, 1);
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1845
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1846 bool delete_dims = true;
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1847
4587
7b957b442818 [project @ 2003-11-10 15:50:39 by jwe]
jwe
parents: 4586
diff changeset
1848 for (int i = nd - 1; i >= 0; i--)
4517
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1849 {
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1850 if (delete_dims)
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1851 {
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1852 if (dimensions(i) != 1)
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1853 {
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1854 delete_dims = false;
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1855
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1856 new_dims = dim_vector (i + 1, dimensions(i));
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1857 }
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1858 }
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1859 else
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1860 new_dims(i) = dimensions(i);
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1861 }
4530
e8d87fefd144 [project @ 2003-10-07 04:02:04 by jwe]
jwe
parents: 4518
diff changeset
1862
4587
7b957b442818 [project @ 2003-11-10 15:50:39 by jwe]
jwe
parents: 4586
diff changeset
1863 if (nd != new_dims.length ())
4517
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1864 dimensions = new_dims;
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1865 }
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1866
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1867 // Non-real types don't have NaNs.
4517
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
1868 template <class T>
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
1869 inline bool
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
1870 sort_isnan (typename ref_param<T>::type)
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1871 {
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1872 return false;
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1873 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1874
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1875 template <class T>
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1876 Array<T>
9725
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
1877 Array<T>::sort (int dim, sortmode mode) const
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1878 {
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1879 if (dim < 0 || dim >= ndims ())
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1880 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1881 (*current_liboctave_error_handler)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1882 ("sort: invalid dimension");
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1883 return Array<T> ();
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1884 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1885
8651
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
1886 Array<T> m (dims ());
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1887
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1888 dim_vector dv = m.dims ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1889
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1890 if (m.length () < 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1891 return m;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1892
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1893 octave_idx_type ns = dv(dim);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1894 octave_idx_type iter = dv.numel () / ns;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1895 octave_idx_type stride = 1;
8505
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
1896
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1897 for (int i = 0; i < dim; i++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1898 stride *= dv(i);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1899
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1900 T *v = m.fortran_vec ();
8651
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
1901 const T *ov = data ();
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
1902
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1903 octave_sort<T> lsort;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1904
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1905 if (mode)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1906 lsort.set_compare (mode);
7463
2467639bd8c0 eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents: 7443
diff changeset
1907 else
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1908 return m;
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1909
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1910 if (stride == 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1911 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1912 for (octave_idx_type j = 0; j < iter; j++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1913 {
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1914 // copy and partition out NaNs.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1915 // FIXME: impact on integer types noticeable?
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1916 octave_idx_type kl = 0, ku = ns;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1917 for (octave_idx_type i = 0; i < ns; i++)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1918 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1919 T tmp = ov[i];
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
1920 if (sort_isnan<T> (tmp))
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1921 v[--ku] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1922 else
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1923 v[kl++] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1924 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1925
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1926 // sort.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1927 lsort.sort (v, kl);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1928
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1929 if (ku < ns)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1930 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1931 // NaNs are in reverse order
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1932 std::reverse (v + ku, v + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1933 if (mode == DESCENDING)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1934 std::rotate (v, v + ku, v + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1935 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1936
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1937 v += ns;
8651
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
1938 ov += ns;
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1939 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1940 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1941 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1942 {
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1943 OCTAVE_LOCAL_BUFFER (T, buf, ns);
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1944
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1945 for (octave_idx_type j = 0; j < iter; j++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1946 {
8505
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
1947 octave_idx_type offset = j;
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
1948 octave_idx_type offset2 = 0;
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
1949
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1950 while (offset >= stride)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1951 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1952 offset -= stride;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1953 offset2++;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1954 }
8505
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
1955
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1956 offset += offset2 * stride * ns;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1957
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1958 // gather and partition out NaNs.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1959 // FIXME: impact on integer types noticeable?
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1960 octave_idx_type kl = 0, ku = ns;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1961 for (octave_idx_type i = 0; i < ns; i++)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1962 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1963 T tmp = ov[i*stride + offset];
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
1964 if (sort_isnan<T> (tmp))
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1965 buf[--ku] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1966 else
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1967 buf[kl++] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1968 }
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1969
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1970 // sort.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1971 lsort.sort (buf, kl);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1972
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1973 if (ku < ns)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1974 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1975 // NaNs are in reverse order
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1976 std::reverse (buf + ku, buf + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1977 if (mode == DESCENDING)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1978 std::rotate (buf, buf + ku, buf + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1979 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1980
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1981 // scatter.
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1982 for (octave_idx_type i = 0; i < ns; i++)
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
1983 v[i*stride + offset] = buf[i];
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1984 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1985 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1986
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1987 return m;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1988 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1989
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1990 template <class T>
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1991 Array<T>
9725
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
1992 Array<T>::sort (Array<octave_idx_type> &sidx, int dim,
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1993 sortmode mode) const
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
1994 {
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1995 if (dim < 0 || dim >= ndims ())
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1996 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1997 (*current_liboctave_error_handler)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1998 ("sort: invalid dimension");
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
1999 return Array<T> ();
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2000 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2001
8651
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
2002 Array<T> m (dims ());
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2003
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2004 dim_vector dv = m.dims ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2005
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2006 if (m.length () < 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2007 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2008 sidx = Array<octave_idx_type> (dv);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2009 return m;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2010 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2011
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2012 octave_idx_type ns = dv(dim);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2013 octave_idx_type iter = dv.numel () / ns;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2014 octave_idx_type stride = 1;
8505
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
2015
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2016 for (int i = 0; i < dim; i++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2017 stride *= dv(i);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2018
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2019 T *v = m.fortran_vec ();
8651
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
2020 const T *ov = data ();
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
2021
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2022 octave_sort<T> lsort;
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2023
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2024 sidx = Array<octave_idx_type> (dv);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2025 octave_idx_type *vi = sidx.fortran_vec ();
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2026
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2027 if (mode)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2028 lsort.set_compare (mode);
7463
2467639bd8c0 eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents: 7443
diff changeset
2029 else
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2030 return m;
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2031
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2032 if (stride == 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2033 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2034 for (octave_idx_type j = 0; j < iter; j++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2035 {
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2036 // copy and partition out NaNs.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2037 // FIXME: impact on integer types noticeable?
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2038 octave_idx_type kl = 0, ku = ns;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2039 for (octave_idx_type i = 0; i < ns; i++)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2040 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2041 T tmp = ov[i];
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
2042 if (sort_isnan<T> (tmp))
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2043 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2044 --ku;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2045 v[ku] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2046 vi[ku] = i;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2047 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2048 else
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2049 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2050 v[kl] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2051 vi[kl] = i;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2052 kl++;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2053 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2054 }
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2055
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2056 // sort.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2057 lsort.sort (v, vi, kl);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2058
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2059 if (ku < ns)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2060 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2061 // NaNs are in reverse order
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2062 std::reverse (v + ku, v + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2063 std::reverse (vi + ku, vi + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2064 if (mode == DESCENDING)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2065 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2066 std::rotate (v, v + ku, v + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2067 std::rotate (vi, vi + ku, vi + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2068 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2069 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2070
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2071 v += ns;
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2072 vi += ns;
8651
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
2073 ov += ns;
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2074 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2075 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2076 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2077 {
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2078 OCTAVE_LOCAL_BUFFER (T, buf, ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2079 OCTAVE_LOCAL_BUFFER (octave_idx_type, bufi, ns);
8651
ea8e65ca234f reduce memory usage in sorting
Jaroslav Hajek <highegg@gmail.com>
parents: 8580
diff changeset
2080
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2081 for (octave_idx_type j = 0; j < iter; j++)
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2082 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2083 octave_idx_type offset = j;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2084 octave_idx_type offset2 = 0;
8505
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
2085
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2086 while (offset >= stride)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2087 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2088 offset -= stride;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2089 offset2++;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2090 }
8505
124dd27bedae Array.cc: style fixes
John W. Eaton <jwe@octave.org>
parents: 8410
diff changeset
2091
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2092 offset += offset2 * stride * ns;
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2093
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2094 // gather and partition out NaNs.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2095 // FIXME: impact on integer types noticeable?
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2096 octave_idx_type kl = 0, ku = ns;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2097 for (octave_idx_type i = 0; i < ns; i++)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2098 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2099 T tmp = ov[i*stride + offset];
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
2100 if (sort_isnan<T> (tmp))
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2101 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2102 --ku;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2103 buf[ku] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2104 bufi[ku] = i;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2105 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2106 else
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2107 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2108 buf[kl] = tmp;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2109 bufi[kl] = i;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2110 kl++;
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2111 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2112 }
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2113
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2114 // sort.
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2115 lsort.sort (buf, bufi, kl);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2116
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2117 if (ku < ns)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2118 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2119 // NaNs are in reverse order
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2120 std::reverse (buf + ku, buf + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2121 std::reverse (bufi + ku, bufi + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2122 if (mode == DESCENDING)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2123 {
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2124 std::rotate (buf, buf + ku, buf + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2125 std::rotate (bufi, bufi + ku, bufi + ns);
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2126 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2127 }
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2128
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2129 // scatter.
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2130 for (octave_idx_type i = 0; i < ns; i++)
8700
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2131 v[i*stride + offset] = buf[i];
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2132 for (octave_idx_type i = 0; i < ns; i++)
314be237cd5b sorting optimizations
Jaroslav Hajek <highegg@gmail.com>
parents: 8651
diff changeset
2133 vi[i*stride + offset] = bufi[i];
7433
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2134 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2135 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2136
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2137 return m;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2138 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman]
dbateman
parents: 7321
diff changeset
2139
7620
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2140 template <class T>
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
2141 typename Array<T>::compare_fcn_type
9920
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2142 safe_comparator (sortmode mode, const Array<T>& /* a */,
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2143 bool /* allow_chk */)
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2144 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2145 if (mode == ASCENDING)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2146 return octave_sort<T>::ascending_compare;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2147 else if (mode == DESCENDING)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2148 return octave_sort<T>::descending_compare;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2149 else
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2150 return 0;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2151 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2152
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2153 template <class T>
9920
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2154 sortmode
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2155 Array<T>::is_sorted (sortmode mode) const
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2156 {
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2157 octave_sort<T> lsort;
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2158
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2159 octave_idx_type n = numel ();
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2160
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2161 if (n <= 1)
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2162 return mode ? mode : ASCENDING;
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2163
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2164 if (! mode)
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2165 {
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2166 // Auto-detect mode.
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2167 compare_fcn_type compare
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2168 = safe_comparator (ASCENDING, *this, false);
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2169
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2170 if (compare (elem (n-1), elem (0)))
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2171 mode = DESCENDING;
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2172 else
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2173 mode = ASCENDING;
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2174 }
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2175
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2176 if (mode)
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2177 {
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2178 lsort.set_compare (safe_comparator (mode, *this, false));
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2179
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2180 if (! lsort.is_sorted (data (), n))
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2181 mode = UNSORTED;
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2182 }
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2183
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2184 return mode;
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2185
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2186 }
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2187
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2188 template <class T>
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2189 Array<octave_idx_type>
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2190 Array<T>::sort_rows_idx (sortmode mode) const
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2191 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2192 Array<octave_idx_type> idx;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2193
9921
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2194 octave_sort<T> lsort (safe_comparator (mode, *this, true));
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2195
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2196 octave_idx_type r = rows (), c = cols ();
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2197
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2198 idx = Array<octave_idx_type> (r);
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2199
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2200 lsort.sort_rows (data (), idx.fortran_vec (), r, c);
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2201
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2202 return idx;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2203 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2204
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2205
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2206 template <class T>
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2207 sortmode
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2208 Array<T>::is_sorted_rows (sortmode mode) const
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2209 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2210 octave_sort<T> lsort;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2211
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2212 octave_idx_type r = rows (), c = cols ();
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2213
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2214 if (r <= 1 || c == 0)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2215 return mode ? mode : ASCENDING;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2216
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2217 if (! mode)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2218 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2219 // Auto-detect mode.
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
2220 compare_fcn_type compare
9920
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2221 = safe_comparator (ASCENDING, *this, false);
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2222
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2223 octave_idx_type i;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2224 for (i = 0; i < cols (); i++)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2225 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2226 T l = elem (0, i), u = elem (rows () - 1, i);
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2227 if (compare (l, u))
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2228 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2229 if (mode == DESCENDING)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2230 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2231 mode = UNSORTED;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2232 break;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2233 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2234 else
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2235 mode = ASCENDING;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2236 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2237 else if (compare (u, l))
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2238 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2239 if (mode == ASCENDING)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2240 {
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2241 mode = UNSORTED;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2242 break;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2243 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2244 else
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2245 mode = DESCENDING;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2246 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2247 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2248 if (! mode && i == cols ())
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2249 mode = ASCENDING;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2250 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2251
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2252 if (mode)
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2253 {
9920
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2254 lsort.set_compare (safe_comparator (mode, *this, false));
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2255
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2256 if (! lsort.is_sorted_rows (data (), r, c))
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2257 mode = UNSORTED;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2258 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2259
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2260 return mode;
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2261
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2262 }
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2263
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2264 // Do a binary lookup in a sorted array.
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2265 template <class T>
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2266 octave_idx_type
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2267 Array<T>::lookup (const T& value, sortmode mode) const
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2268 {
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2269 octave_idx_type n = numel ();
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2270 octave_sort<T> lsort;
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2271
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2272 if (mode == UNSORTED)
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2273 {
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2274 // auto-detect mode
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2275 if (n > 1 && lsort.descending_compare (elem (0), elem (n-1)))
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2276 mode = DESCENDING;
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2277 else
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2278 mode = ASCENDING;
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2279 }
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2280
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2281 lsort.set_compare (mode);
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2282
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2283 return lsort.lookup (data (), n, value);
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2284 }
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2285
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2286 template <class T>
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2287 Array<octave_idx_type>
9921
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2288 Array<T>::lookup (const Array<T>& values, sortmode mode) const
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2289 {
9921
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2290 octave_idx_type n = numel (), nval = values.numel ();
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2291 octave_sort<T> lsort;
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2292 Array<octave_idx_type> idx (values.dims ());
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2293
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2294 if (mode == UNSORTED)
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2295 {
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2296 // auto-detect mode
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2297 if (n > 1 && lsort.descending_compare (elem (0), elem (n-1)))
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2298 mode = DESCENDING;
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2299 else
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2300 mode = ASCENDING;
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2301 }
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2302
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2303 lsort.set_compare (mode);
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2304
9921
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2305 // This determines the split ratio between the O(M*log2(N)) and O(M+N) algorithms.
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2306 static const double ratio = 1.0;
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2307 sortmode vmode = UNSORTED;
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2308
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2309 // Attempt the O(M+N) algorithm if M is large enough.
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2310 if (nval > ratio * n / xlog2 (n + 1.0))
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2311 {
9921
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2312 vmode = values.is_sorted ();
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2313 // The table must not contain a NaN.
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2314 if ((vmode == ASCENDING && sort_isnan<T> (values(nval-1)))
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2315 || (vmode == DESCENDING && sort_isnan<T> (values(0))))
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2316 vmode = UNSORTED;
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2317 }
9921
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2318
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2319 if (vmode != UNSORTED)
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2320 lsort.lookup_sorted (data (), n, values.data (), nval,
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2321 idx.fortran_vec (), vmode != mode);
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2322 else
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2323 lsort.lookup (data (), n, values.data (), nval, idx.fortran_vec ());
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2324
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2325 return idx;
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2326 }
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2327
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2328 template <class T>
9878
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2329 octave_idx_type
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2330 Array<T>::nnz (void) const
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2331 {
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2332 const T *src = data ();
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2333 octave_idx_type nel = nelem (), retval = 0;
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2334 const T zero = T ();
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2335 for (octave_idx_type i = 0; i < nel; i++)
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2336 if (src[i] != zero)
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2337 retval++;
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2338
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2339 return retval;
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2340 }
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2341
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2342 template <class T>
9341
9fd5c56ce57a extend lookup capabilities
Jaroslav Hajek <highegg@gmail.com>
parents: 9310
diff changeset
2343 Array<octave_idx_type>
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2344 Array<T>::find (octave_idx_type n, bool backward) const
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2345 {
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2346 Array<octave_idx_type> retval;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2347 const T *src = data ();
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2348 octave_idx_type nel = nelem ();
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2349 const T zero = T ();
9310
256c0db275b6 fix behavior of find
Jaroslav Hajek <highegg@gmail.com>
parents: 9237
diff changeset
2350 if (n < 0 || n >= nel)
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2351 {
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2352 // We want all elements, which means we'll almost surely need
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2353 // to resize. So count first, then allocate array of exact size.
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2354 octave_idx_type cnt = 0;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2355 for (octave_idx_type i = 0; i < nel; i++)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2356 cnt += src[i] != zero;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2357
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2358 retval = Array<octave_idx_type> (cnt);
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2359 octave_idx_type *dest = retval.fortran_vec ();
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2360 for (octave_idx_type i = 0; i < nel; i++)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2361 if (src[i] != zero) *dest++ = i;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2362 }
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2363 else
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2364 {
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2365 // We want a fixed max number of elements, usually small. So be
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2366 // optimistic, alloc the array in advance, and then resize if
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2367 // needed.
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2368 retval = Array<octave_idx_type> (n);
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2369 if (backward)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2370 {
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2371 // Do the search as a series of successive single-element searches.
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2372 octave_idx_type k = 0, l = nel - 1;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2373 for (; k < n; k++)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2374 {
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2375 for (;l >= 0 && src[l] == zero; l--) ;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2376 if (l >= 0)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2377 retval(k) = l--;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2378 else
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2379 break;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2380 }
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2381 if (k < n)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2382 retval.resize (k);
9310
256c0db275b6 fix behavior of find
Jaroslav Hajek <highegg@gmail.com>
parents: 9237
diff changeset
2383 octave_idx_type *rdata = retval.fortran_vec ();
256c0db275b6 fix behavior of find
Jaroslav Hajek <highegg@gmail.com>
parents: 9237
diff changeset
2384 std::reverse (rdata, rdata + k);
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2385 }
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2386 else
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2387 {
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2388 // Do the search as a series of successive single-element searches.
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2389 octave_idx_type k = 0, l = 0;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2390 for (; k < n; k++)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2391 {
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2392 for (;l != nel && src[l] == zero; l++) ;
9029
2df28ad88b0e small fix in Array::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9025
diff changeset
2393 if (l != nel)
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2394 retval(k) = l++;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2395 else
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2396 break;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2397 }
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2398 if (k < n)
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2399 retval.resize (k);
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2400 }
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2401 }
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2402
9046
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2403 // Fixup return dimensions, for Matlab compatibility.
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2404 // find(zeros(0,0)) -> zeros(0,0)
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2405 // find(zeros(1,0)) -> zeros(1,0)
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2406 // find(zeros(0,1)) -> zeros(0,1)
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2407 // find(zeros(0,X)) -> zeros(0,1)
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2408 // find(zeros(1,1)) -> zeros(0,0) !!!! WHY?
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2409 // find(zeros(0,1,0)) -> zeros(0,0)
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2410 // find(zeros(0,1,0,1)) -> zeros(0,0) etc
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2411
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2412 if ((numel () == 1 && retval.is_empty ())
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2413 || (rows () == 0 && dims ().numel (1) == 0))
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2414 retval.dimensions = dim_vector ();
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2415 else if (rows () == 1 && ndims () == 2)
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2416 retval.dimensions = dim_vector (1, retval.length ());
88bf56bbccca make Array::find already return Matlab-compatible dimensions
Jaroslav Hajek <highegg@gmail.com>
parents: 9029
diff changeset
2417
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2418 return retval;
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2419 }
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2420
9725
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2421 template <class T>
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2422 Array<T>
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2423 Array<T>::nth_element (const idx_vector& n, int dim) const
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2424 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2425 if (dim < 0 || dim >= ndims ())
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2426 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2427 (*current_liboctave_error_handler)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2428 ("nth_element: invalid dimension");
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2429 return Array<T> ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2430 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2431
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2432 dim_vector dv = dims ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2433 octave_idx_type ns = dv(dim);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2434
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2435 octave_idx_type nn = n.length (ns);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2436
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2437 dv(dim) = std::min (nn, ns);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2438 dv.chop_trailing_singletons ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2439
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2440 Array<T> m (dv);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2441
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2442 if (m.numel () == 0)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2443 return m;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2444
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2445 sortmode mode = UNSORTED;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2446 octave_idx_type lo = 0;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2447
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2448 switch (n.idx_class ())
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2449 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2450 case idx_vector::class_scalar:
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2451 mode = ASCENDING;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2452 lo = n(0);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2453 break;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2454 case idx_vector::class_range:
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2455 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2456 octave_idx_type inc = n.increment ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2457 if (inc == 1)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2458 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2459 mode = ASCENDING;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2460 lo = n(0);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2461 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2462 else if (inc == -1)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2463 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2464 mode = DESCENDING;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2465 lo = ns - 1 - n(0);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2466 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2467 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2468 default:
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2469 break;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2470 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2471
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2472 if (mode == UNSORTED)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2473 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2474 (*current_liboctave_error_handler)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2475 ("nth_element: n must be a scalar or a contiguous range");
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2476 return Array<T> ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2477 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2478
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2479 octave_idx_type up = lo + nn;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2480
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2481 if (lo < 0 || up > ns)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2482 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2483 (*current_liboctave_error_handler)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2484 ("nth_element: invalid element index");
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2485 return Array<T> ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2486 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2487
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2488 octave_idx_type iter = numel () / ns;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2489 octave_idx_type stride = 1;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2490
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2491 for (int i = 0; i < dim; i++)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2492 stride *= dv(i);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2493
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2494 T *v = m.fortran_vec ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2495 const T *ov = data ();
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2496
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2497 OCTAVE_LOCAL_BUFFER (T, buf, ns);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2498
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2499 octave_sort<T> lsort;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2500 lsort.set_compare (mode);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2501
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2502 for (octave_idx_type j = 0; j < iter; j++)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2503 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2504 octave_idx_type kl = 0, ku = ns;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2505
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2506 if (stride == 1)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2507 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2508 // copy without NaNs.
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2509 // FIXME: impact on integer types noticeable?
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2510 for (octave_idx_type i = 0; i < ns; i++)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2511 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2512 T tmp = ov[i];
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2513 if (sort_isnan<T> (tmp))
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2514 buf[--ku] = tmp;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2515 else
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2516 buf[kl++] = tmp;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2517 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2518
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2519 ov += ns;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2520 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2521 else
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2522 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2523 octave_idx_type offset = j % stride;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2524 // copy without NaNs.
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2525 // FIXME: impact on integer types noticeable?
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2526 for (octave_idx_type i = 0; i < ns; i++)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2527 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2528 T tmp = ov[offset + i*stride];
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2529 if (sort_isnan<T> (tmp))
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2530 buf[--ku] = tmp;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2531 else
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2532 buf[kl++] = tmp;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2533 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2534
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2535 if (offset == stride-1)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2536 ov += ns*stride;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2537 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2538
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2539 if (ku == ns)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2540 lsort.nth_element (buf, ns, lo, up);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2541 else if (mode == ASCENDING)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2542 lsort.nth_element (buf, ku, lo, std::min (ku, up));
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2543 else
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2544 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2545 octave_idx_type nnan = ns - ku;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2546 lsort.nth_element (buf, ku, std::max (lo - nnan, 0),
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2547 std::max (up - nnan, 0));
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2548 std::rotate (buf, buf + ku, buf + ns);
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2549 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2550
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2551 if (stride == 1)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2552 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2553 for (octave_idx_type i = 0; i < nn; i++)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2554 v[i] = buf[lo + i];
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2555
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2556 v += nn;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2557 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2558 else
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2559 {
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2560 octave_idx_type offset = j % stride;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2561 for (octave_idx_type i = 0; i < nn; i++)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2562 v[offset + stride * i] = buf[lo + i];
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2563 if (offset == stride-1)
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2564 v += nn*stride;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2565 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2566 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2567
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2568 return m;
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2569 }
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2570
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2571
9237
3c1762c7e787 Add missing xxx_API decoration and remove misplaced ones
Michael Goffioul <michael.goffioul@gmail.com>
parents: 9222
diff changeset
2572 #define INSTANTIATE_ARRAY_SORT(T) template class OCTAVE_API octave_sort<T>;
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2573
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2574 #define NO_INSTANTIATE_ARRAY_SORT(T) \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2575 \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2576 template <> Array<T> \
9725
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2577 Array<T>::sort (int, sortmode) const { return *this; } \
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2578 \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2579 template <> Array<T> \
9725
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2580 Array<T>::sort (Array<octave_idx_type> &sidx, int, sortmode) const \
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2581 { sidx = Array<octave_idx_type> (); return *this; } \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2582 \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2583 template <> sortmode \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2584 Array<T>::is_sorted (sortmode) const \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2585 { return UNSORTED; } \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2586 \
8725
d5af326a3ede [mq]: sort-traits
John W. Eaton <jwe@octave.org>
parents: 8721
diff changeset
2587 Array<T>::compare_fcn_type \
9920
56fbe170d354 fix issorted with NaNs in middle
Jaroslav Hajek <highegg@gmail.com>
parents: 9886
diff changeset
2588 safe_comparator (sortmode, const Array<T>&, bool) \
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2589 { return 0; } \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2590 \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2591 template <> Array<octave_idx_type> \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2592 Array<T>::sort_rows_idx (sortmode) const \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2593 { return Array<octave_idx_type> (); } \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2594 \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2595 template <> sortmode \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2596 Array<T>::is_sorted_rows (sortmode) const \
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2597 { return UNSORTED; } \
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2598 \
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2599 template <> octave_idx_type \
9222
7bd406e12e4d instantiate Array<void *> in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents: 9201
diff changeset
2600 Array<T>::lookup (T const &, sortmode) const \
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2601 { return 0; } \
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2602 template <> Array<octave_idx_type> \
9921
7c8392a034e6 fix & improve lookup API
Jaroslav Hajek <highegg@gmail.com>
parents: 9920
diff changeset
2603 Array<T>::lookup (const Array<T>&, sortmode) const \
8814
de16ebeef93d improve lookup, provide Array<T>::lookup
Jaroslav Hajek <highegg@gmail.com>
parents: 8799
diff changeset
2604 { return Array<octave_idx_type> (); } \
9878
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2605 \
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2606 template <> octave_idx_type \
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2607 Array<T>::nnz (void) const\
ead4f9c82a9a implement Array<T>::nnz
Jaroslav Hajek <highegg@gmail.com>
parents: 9840
diff changeset
2608 { return 0; } \
9025
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2609 template <> Array<octave_idx_type> \
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2610 Array<T>::find (octave_idx_type, bool) const\
484756d558d6 add Array<T>::find
Jaroslav Hajek <highegg@gmail.com>
parents: 9012
diff changeset
2611 { return Array<octave_idx_type> (); } \
9725
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2612 \
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2613 template <> Array<T> \
aea3a3a950e1 implement nth_element
Jaroslav Hajek <highegg@gmail.com>
parents: 9678
diff changeset
2614 Array<T>::nth_element (const idx_vector&, int) const { return Array<T> (); } \
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2615
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2616
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2617 template <class T>
7620
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2618 Array<T>
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2619 Array<T>::diag (octave_idx_type k) const
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2620 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2621 dim_vector dv = dims ();
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2622 octave_idx_type nd = dv.length ();
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2623 Array<T> d;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2624
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2625 if (nd > 2)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2626 (*current_liboctave_error_handler) ("Matrix must be 2-dimensional");
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2627 else
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2628 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2629 octave_idx_type nnr = dv (0);
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2630 octave_idx_type nnc = dv (1);
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2631
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2632 if (nnr == 0 || nnc == 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2633 ; // do nothing
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2634 else if (nnr != 1 && nnc != 1)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2635 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2636 if (k > 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2637 nnc -= k;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2638 else if (k < 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2639 nnr += k;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2640
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2641 if (nnr > 0 && nnc > 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2642 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2643 octave_idx_type ndiag = (nnr < nnc) ? nnr : nnc;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2644
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2645 d.resize (dim_vector (ndiag, 1));
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2646
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2647 if (k > 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2648 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2649 for (octave_idx_type i = 0; i < ndiag; i++)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2650 d.xelem (i) = elem (i, i+k);
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2651 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2652 else if (k < 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2653 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2654 for (octave_idx_type i = 0; i < ndiag; i++)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2655 d.xelem (i) = elem (i-k, i);
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2656 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2657 else
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2658 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2659 for (octave_idx_type i = 0; i < ndiag; i++)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2660 d.xelem (i) = elem (i, i);
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2661 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2662 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2663 else
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2664 (*current_liboctave_error_handler)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2665 ("diag: requested diagonal out of range");
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2666 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2667 else if (nnr != 0 && nnc != 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2668 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2669 octave_idx_type roff = 0;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2670 octave_idx_type coff = 0;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2671 if (k > 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2672 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2673 roff = 0;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2674 coff = k;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2675 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2676 else if (k < 0)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2677 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2678 roff = -k;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2679 coff = 0;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2680 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2681
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2682 if (nnr == 1)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2683 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2684 octave_idx_type n = nnc + std::abs (k);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
2685 d = Array<T> (dim_vector (n, n), resize_fill_value ());
7620
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2686
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2687 for (octave_idx_type i = 0; i < nnc; i++)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2688 d.xelem (i+roff, i+coff) = elem (0, i);
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2689 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2690 else
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2691 {
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2692 octave_idx_type n = nnr + std::abs (k);
8290
7cbe01c21986 improve dense array indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8179
diff changeset
2693 d = Array<T> (dim_vector (n, n), resize_fill_value ());
7620
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2694
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2695 for (octave_idx_type i = 0; i < nnr; i++)
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2696 d.xelem (i+roff, i+coff) = elem (i, 0);
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2697 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2698 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2699 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2700
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2701 return d;
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2702 }
36594d5bbe13 Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents: 7605
diff changeset
2703
4517
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
2704 template <class T>
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe]
jwe
parents: 4513
diff changeset
2705 void
3933
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe]
jwe
parents: 3657
diff changeset
2706 Array<T>::print_info (std::ostream& os, const std::string& prefix) const
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe]
jwe
parents: 3657
diff changeset
2707 {
8523
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
2708 os << prefix << "rep address: " << rep << '\n'
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
2709 << prefix << "rep->len: " << rep->len << '\n'
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
2710 << prefix << "rep->data: " << static_cast<void *> (rep->data) << '\n'
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
2711 << prefix << "rep->count: " << rep->count << '\n'
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
2712 << prefix << "slice_data: " << static_cast<void *> (slice_data) << '\n'
ad3afaaa19c1 implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents: 8505
diff changeset
2713 << prefix << "slice_len: " << slice_len << '\n';
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
2714
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
2715 // 2D info:
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
2716 //
4657
a585a2dfca6c [project @ 2003-11-25 01:30:09 by jwe]
jwe
parents: 4656
diff changeset
2717 // << pefix << "rows: " << rows () << "\n"
4513
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe]
jwe
parents: 4192
diff changeset
2718 // << prefix << "cols: " << cols () << "\n";
3933
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe]
jwe
parents: 3657
diff changeset
2719 }
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe]
jwe
parents: 3657
diff changeset
2720
9201
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2721 template <class T>
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2722 void Array<T>::instantiation_guard ()
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2723 {
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2724 // This guards against accidental implicit instantiations.
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2725 // Array<T> instances should always be explicit and use INSTANTIATE_ARRAY.
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2726 T::__xXxXx__();
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2727 }
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2728
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2729 #define INSTANTIATE_ARRAY(T, API) \
9201
472f0e22aa60 guard against implicit instantiation
Jaroslav Hajek <highegg@gmail.com>
parents: 9121
diff changeset
2730 template <> void Array<T>::instantiation_guard () { } \
8721
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2731 template class API Array<T>
e9cb742df9eb imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents: 8700
diff changeset
2732
9732
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2733 // FIXME: is this used?
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2734
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2735 template <class T>
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2736 std::ostream&
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2737 operator << (std::ostream& os, const Array<T>& a)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2738 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2739 dim_vector a_dims = a.dims ();
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2740
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2741 int n_dims = a_dims.length ();
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2742
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2743 os << n_dims << "-dimensional array";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2744
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2745 if (n_dims)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2746 os << " (" << a_dims.str () << ")";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2747
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2748 os <<"\n\n";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2749
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2750 if (n_dims)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2751 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2752 os << "data:";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2753
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2754 Array<octave_idx_type> ra_idx (n_dims, 0);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2755
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2756 // Number of times the first 2d-array is to be displayed.
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2757
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2758 octave_idx_type m = 1;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2759 for (int i = 2; i < n_dims; i++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2760 m *= a_dims(i);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2761
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2762 if (m == 1)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2763 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2764 octave_idx_type rows = 0;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2765 octave_idx_type cols = 0;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2766
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2767 switch (n_dims)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2768 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2769 case 2:
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2770 rows = a_dims(0);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2771 cols = a_dims(1);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2772
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2773 for (octave_idx_type j = 0; j < rows; j++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2774 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2775 ra_idx(0) = j;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2776 for (octave_idx_type k = 0; k < cols; k++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2777 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2778 ra_idx(1) = k;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2779 os << " " << a.elem(ra_idx);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2780 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2781 os << "\n";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2782 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2783 break;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2784
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2785 default:
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2786 rows = a_dims(0);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2787
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2788 for (octave_idx_type k = 0; k < rows; k++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2789 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2790 ra_idx(0) = k;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2791 os << " " << a.elem(ra_idx);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2792 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2793 break;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2794 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2795
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2796 os << "\n";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2797 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2798 else
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2799 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2800 octave_idx_type rows = a_dims(0);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2801 octave_idx_type cols = a_dims(1);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2802
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2803 for (int i = 0; i < m; i++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2804 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2805 os << "\n(:,:,";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2806
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2807 for (int j = 2; j < n_dims - 1; j++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2808 os << ra_idx(j) + 1 << ",";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2809
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2810 os << ra_idx(n_dims - 1) + 1 << ") = \n";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2811
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2812 for (octave_idx_type j = 0; j < rows; j++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2813 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2814 ra_idx(0) = j;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2815
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2816 for (octave_idx_type k = 0; k < cols; k++)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2817 {
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2818 ra_idx(1) = k;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2819 os << " " << a.elem(ra_idx);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2820 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2821
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2822 os << "\n";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2823 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2824
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2825 os << "\n";
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2826
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2827 if (i != m - 1)
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2828 increment_index (ra_idx, a_dims, 2);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2829 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2830 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2831 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2832
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2833 return os;
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2834 }
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents: 9731
diff changeset
2835
237
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
2836 /*
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
2837 ;;; Local Variables: ***
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
2838 ;;; mode: C++ ***
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
2839 ;;; End: ***
5a9e23307fb0 [project @ 1993-11-30 20:23:04 by jwe]
jwe
parents:
diff changeset
2840 */