Mercurial > hg > octave-lyh

comparison liboctave/Array-util.cc @ 5275:23b37da9fd5b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2005-04-08 16:07:35 by jwe]
author jwe
date Fri, 08 Apr 2005 16:07:37 +0000
parents 9eab94f5fadf
children 4c8a2e4e0717
comparison
equal deleted inserted replaced
5274:eae7b40388e9 5275:23b37da9fd5b
27 #include "Array-util.h" 27 #include "Array-util.h"
28 #include "dim-vector.h" 28 #include "dim-vector.h"
29 #include "lo-error.h" 29 #include "lo-error.h"
30 30
31 bool 31 bool
32 index_in_bounds (const Array<int>& ra_idx, const dim_vector& dimensions) 32 index_in_bounds (const Array<octave_idx_type>& ra_idx, const dim_vector& dimensions)
33 { 33 {
34 bool retval = true; 34 bool retval = true;
35 35
36 int n = ra_idx.length (); 36 int n = ra_idx.length ();
37 37
51 51
52 return retval; 52 return retval;
53 } 53 }
54 54
55 void 55 void
56 increment_index (Array<int>& ra_idx, const dim_vector& dimensions, 56 increment_index (Array<octave_idx_type>& ra_idx, const dim_vector& dimensions,
57 int start_dimension) 57 int start_dimension)
58 { 58 {
59 ra_idx(start_dimension)++; 59 ra_idx(start_dimension)++;
60 60
61 int n = ra_idx.length () - 1; 61 int n = ra_idx.length () - 1;
70 ra_idx(i+1)++; 70 ra_idx(i+1)++;
71 } 71 }
72 } 72 }
73 } 73 }
74 74
75 int 75 octave_idx_type
76 get_scalar_idx (Array<int>& idx, dim_vector& dims) 76 get_scalar_idx (Array<octave_idx_type>& idx, dim_vector& dims)
77 { 77 {
78 int retval (-1); 78 octave_idx_type retval (-1);
79 79
80 int n = idx.length (); 80 int n = idx.length ();
81 81
82 if (n > 0) 82 if (n > 0)
83 { 83 {
91 } 91 }
92 } 92 }
93 return retval; 93 return retval;
94 } 94 }
95 95
96 int 96 octave_idx_type
97 num_ones (const Array<int>& ra_idx) 97 num_ones (const Array<octave_idx_type>& ra_idx)
98 { 98 {
99 int retval = 0; 99 octave_idx_type retval = 0;
100 100
101 for (int i = 0; i < ra_idx.length (); i++) 101 for (octave_idx_type i = 0; i < ra_idx.length (); i++)
102 { 102 {
103 if (ra_idx (i) == 1) 103 if (ra_idx (i) == 1)
104 retval++; 104 retval++;
105 } 105 }
106 106
132 } 132 }
133 return retval; 133 return retval;
134 } 134 }
135 135
136 bool 136 bool
137 any_ones (const Array<int>& arr) 137 any_ones (const Array<octave_idx_type>& arr)
138 { 138 {
139 bool retval = false; 139 bool retval = false;
140 140
141 for (int i = 0; i < arr.length (); i++) 141 for (octave_idx_type i = 0; i < arr.length (); i++)
142 { 142 {
143 if (arr (i) == 1) 143 if (arr (i) == 1)
144 { 144 {
145 retval = true; 145 retval = true;
146 146
148 } 148 }
149 } 149 }
150 return retval; 150 return retval;
151 } 151 }
152 152
153 int 153 octave_idx_type
154 compute_index (const Array<int>& ra_idx, const dim_vector& dims) 154 compute_index (const Array<octave_idx_type>& ra_idx, const dim_vector& dims)
155 { 155 {
156 int retval = -1; 156 octave_idx_type retval = -1;
157 157
158 int n = dims.length (); 158 int n = dims.length ();
159 159
160 if (n > 0 && n == ra_idx.length ()) 160 if (n > 0 && n == ra_idx.length ())
161 { 161 {
173 ("ArrayN<T>::compute_index: invalid ra_idxing operation"); 173 ("ArrayN<T>::compute_index: invalid ra_idxing operation");
174 174
175 return retval; 175 return retval;
176 } 176 }
177 177
178 Array<int> 178 Array<octave_idx_type>
179 conv_to_int_array (const Array<idx_vector>& a) 179 conv_to_int_array (const Array<idx_vector>& a)
180 { 180 {
181 Array<int> retval (a.length ()); 181 Array<octave_idx_type> retval (a.length ());
182 182
183 for (int i = 0; i < a.length (); i++) 183 for (octave_idx_type i = 0; i < a.length (); i++)
184 retval (i) = a(i).elem (0); 184 retval (i) = a(i).elem (0);
185 185
186 return retval; 186 return retval;
187 } 187 }
188 188
189 Array<idx_vector> 189 Array<idx_vector>
190 conv_to_array (const idx_vector *tmp, const int len) 190 conv_to_array (const idx_vector *tmp, const octave_idx_type len)
191 { 191 {
192 Array<idx_vector> retval (len); 192 Array<idx_vector> retval (len);
193 193
194 for (int i = 0; i < len; i++) 194 for (octave_idx_type i = 0; i < len; i++)
195 retval (i) = tmp[i]; 195 retval (i) = tmp[i];
196 196
197 return retval; 197 return retval;
198 } 198 }
199 199
216 216
217 return retval; 217 return retval;
218 } 218 }
219 219
220 bool 220 bool
221 vector_equivalent (const Array<int>& ra_idx) 221 vector_equivalent (const Array<octave_idx_type>& ra_idx)
222 { 222 {
223 int n = ra_idx.length (); 223 octave_idx_type n = ra_idx.length ();
224 224
225 bool found_first = false; 225 bool found_first = false;
226 226
227 for (int i = 0; i < n; i++) 227 for (octave_idx_type i = 0; i < n; i++)
228 { 228 {
229 if (ra_idx(i) != 1) 229 if (ra_idx(i) != 1)
230 { 230 {
231 if (! found_first) 231 if (! found_first)
232 found_first = true; 232 found_first = true;
241 bool 241 bool
242 all_ok (const Array<idx_vector>& ra_idx) 242 all_ok (const Array<idx_vector>& ra_idx)
243 { 243 {
244 bool retval = true; 244 bool retval = true;
245 245
246 int n = ra_idx.length (); 246 octave_idx_type n = ra_idx.length ();
247 247
248 for (int i = 0; i < n; i++) 248 for (octave_idx_type i = 0; i < n; i++)
249 { 249 {
250 if (! ra_idx(i)) 250 if (! ra_idx(i))
251 { 251 {
252 retval = false; 252 retval = false;
253 break; 253 break;
260 bool 260 bool
261 any_orig_empty (const Array<idx_vector>& ra_idx) 261 any_orig_empty (const Array<idx_vector>& ra_idx)
262 { 262 {
263 bool retval = false; 263 bool retval = false;
264 264
265 int n = ra_idx.length (); 265 octave_idx_type n = ra_idx.length ();
266 266
267 for (int i = 0; i < n; i++) 267 for (octave_idx_type i = 0; i < n; i++)
268 { 268 {
269 if (ra_idx(i).orig_empty ()) 269 if (ra_idx(i).orig_empty ())
270 { 270 {
271 retval = true; 271 retval = true;
272 break; 272 break;
280 all_colon_equiv (const Array<idx_vector>& ra_idx, 280 all_colon_equiv (const Array<idx_vector>& ra_idx,
281 const dim_vector& frozen_lengths) 281 const dim_vector& frozen_lengths)
282 { 282 {
283 bool retval = true; 283 bool retval = true;
284 284
285 int idx_n = ra_idx.length (); 285 octave_idx_type idx_n = ra_idx.length ();
286 286
287 int n = frozen_lengths.length (); 287 int n = frozen_lengths.length ();
288 288
289 assert (idx_n == n); 289 assert (idx_n == n);
290 290
291 for (int i = 0; i < n; i++) 291 for (octave_idx_type i = 0; i < n; i++)
292 { 292 {
293 if (! ra_idx(i).is_colon_equiv (frozen_lengths(i))) 293 if (! ra_idx(i).is_colon_equiv (frozen_lengths(i)))
294 { 294 {
295 retval = false; 295 retval = false;
296 break; 296 break;
299 299
300 return retval; 300 return retval;
301 } 301 }
302 302
303 bool 303 bool
304 is_in (int num, const idx_vector& idx) 304 is_in (octave_idx_type num, const idx_vector& idx)
305 { 305 {
306 int n = idx.capacity (); 306 octave_idx_type n = idx.capacity ();
307 307
308 for (int i = 0; i < n; i++) 308 for (octave_idx_type i = 0; i < n; i++)
309 if (idx.elem (i) == num) 309 if (idx.elem (i) == num)
310 return true; 310 return true;
311 311
312 return false; 312 return false;
313 } 313 }
314 314
315 int 315 octave_idx_type
316 how_many_lgt (const int num, idx_vector& idxv) 316 how_many_lgt (const octave_idx_type num, idx_vector& idxv)
317 { 317 {
318 int retval = 0; 318 octave_idx_type retval = 0;
319 319
320 int n = idxv.capacity (); 320 octave_idx_type n = idxv.capacity ();
321 321
322 for (int i = 0; i < n; i++) 322 for (octave_idx_type i = 0; i < n; i++)
323 { 323 {
324 if (num > idxv.elem (i)) 324 if (num > idxv.elem (i))
325 retval++; 325 retval++;
326 } 326 }
327 327
328 return retval; 328 return retval;
329 } 329 }
330 330
331 bool 331 bool
332 all_ones (const Array<int>& arr) 332 all_ones (const Array<octave_idx_type>& arr)
333 { 333 {
334 bool retval = true; 334 bool retval = true;
335 335
336 for (int i = 0; i < arr.length (); i++) 336 for (octave_idx_type i = 0; i < arr.length (); i++)
337 { 337 {
338 if (arr(i) != 1) 338 if (arr(i) != 1)
339 { 339 {
340 retval = false; 340 retval = false;
341 break; 341 break;
343 } 343 }
344 344
345 return retval; 345 return retval;
346 } 346 }
347 347
348 Array<int> 348 Array<octave_idx_type>
349 get_elt_idx (const Array<idx_vector>& ra_idx, const Array<int>& result_idx) 349 get_elt_idx (const Array<idx_vector>& ra_idx, const Array<octave_idx_type>& result_idx)
350 { 350 {
351 int n = ra_idx.length (); 351 octave_idx_type n = ra_idx.length ();
352 352
353 Array<int> retval (n); 353 Array<octave_idx_type> retval (n);
354 354
355 for (int i = 0; i < n; i++) 355 for (octave_idx_type i = 0; i < n; i++)
356 retval(i) = ra_idx(i).elem (result_idx(i)); 356 retval(i) = ra_idx(i).elem (result_idx(i));
357 357
358 return retval; 358 return retval;
359 } 359 }
360 360
361 Array<int> 361 Array<octave_idx_type>
362 get_ra_idx (int idx, const dim_vector& dims) 362 get_ra_idx (octave_idx_type idx, const dim_vector& dims)
363 { 363 {
364 Array<int> retval; 364 Array<octave_idx_type> retval;
365 365
366 int n_dims = dims.length (); 366 int n_dims = dims.length ();
367 367
368 retval.resize (n_dims); 368 retval.resize (n_dims);
369 369
370 for (int i = 0; i < n_dims; i++) 370 for (int i = 0; i < n_dims; i++)
371 retval(i) = 0; 371 retval(i) = 0;
372 372
373 assert (idx > 0 || idx < dims.numel ()); 373 assert (idx > 0 || idx < dims.numel ());
374 374
375 for (int i = 0; i < idx; i++) 375 for (octave_idx_type i = 0; i < idx; i++)
376 increment_index (retval, dims); 376 increment_index (retval, dims);
377 377
378 // XXX FIXME XXX -- the solution using increment_index is not 378 // XXX FIXME XXX -- the solution using increment_index is not
379 // efficient. 379 // efficient.
380 380
381 #if 0 381 #if 0
382 int var = 1; 382 octave_idx_type var = 1;
383 for (int i = 0; i < n_dims; i++) 383 for (int i = 0; i < n_dims; i++)
384 { 384 {
385 std::cout << "idx: " << idx << ", var: " << var << ", dims(" << i << "): " << dims(i) <<"\n"; 385 std::cout << "idx: " << idx << ", var: " << var << ", dims(" << i << "): " << dims(i) <<"\n";
386 retval(i) = ((int)floor(((idx) / (double)var))) % dims(i); 386 retval(i) = ((int)floor(((idx) / (double)var))) % dims(i);
387 idx -= var * retval(i); 387 idx -= var * retval(i);
422 { 422 {
423 retval(n-1) = size_left; 423 retval(n-1) = size_left;
424 } 424 }
425 else 425 else
426 { 426 {
427 int last_ra_idx = ra_idx(n-1)(0); 427 octave_idx_type last_ra_idx = ra_idx(n-1)(0);
428 for (int i = 1; i < ra_idx (n - 1).capacity (); i++) 428 for (octave_idx_type i = 1; i < ra_idx (n - 1).capacity (); i++)
429 last_ra_idx = (last_ra_idx > ra_idx(n-1)(i) ? last_ra_idx : 429 last_ra_idx = (last_ra_idx > ra_idx(n-1)(i) ? last_ra_idx :
430 ra_idx(n-1)(i)); 430 ra_idx(n-1)(i));
431 431
432 if (last_ra_idx < size_left) 432 if (last_ra_idx < size_left)
433 { 433 {
448 } 448 }
449 449
450 return retval; 450 return retval;
451 } 451 }
452 452
453 Array<int> 453 Array<octave_idx_type>
454 calc_permutated_idx (const Array<int>& old_idx, 454 calc_permutated_idx (const Array<octave_idx_type>& old_idx,
455 const Array<int>& perm_vec, bool inv) 455 const Array<octave_idx_type>& perm_vec, bool inv)
456 { 456 {
457 int n_el = old_idx.length (); 457 octave_idx_type n_el = old_idx.length ();
458 458
459 Array<int> retval (n_el); 459 Array<octave_idx_type> retval (n_el);
460 460
461 for (int i = 0; i < n_el; i++) 461 for (octave_idx_type i = 0; i < n_el; i++)
462 { 462 {
463 if (inv) 463 if (inv)
464 retval(perm_vec(i)) = old_idx(i); 464 retval(perm_vec(i)) = old_idx(i);
465 else 465 else
466 retval(i) = old_idx(perm_vec(i)); 466 retval(i) = old_idx(perm_vec(i));