Mercurial > hg > octave-thorsten

comparison liboctave/Sparse.cc @ 10480:19e1e4470e01

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
remove old sparse assembly ctors
author Jaroslav Hajek <highegg@gmail.com>
date Wed, 31 Mar 2010 10:24:57 +0200
parents ded9beac7582
children 6a9571b57745
comparison
equal deleted inserted replaced
10479:ded9beac7582 10480:19e1e4470e01
310 xdata(j) = a.data(j); 310 xdata(j) = a.data(j);
311 xridx(j) = ii; 311 xridx(j) = ii;
312 } 312 }
313 for (octave_idx_type k = kk; k < new_nc; k++) 313 for (octave_idx_type k = kk; k < new_nc; k++)
314 xcidx(k+1) = new_nzmx; 314 xcidx(k+1) = new_nzmx;
315 }
316 }
317
318 template <class T>
319 Sparse<T>::Sparse (const Array<T>& a, const Array<octave_idx_type>& r,
320 const Array<octave_idx_type>& c, octave_idx_type nr,
321 octave_idx_type nc, bool sum_terms)
322 : dimensions (dim_vector (nr, nc)), idx (0), idx_count (0)
323 {
324 octave_idx_type a_len = a.length ();
325 octave_idx_type r_len = r.length ();
326 octave_idx_type c_len = c.length ();
327 bool ri_scalar = (r_len == 1);
328 bool ci_scalar = (c_len == 1);
329 bool cf_scalar = (a_len == 1);
330
331 if ((a_len != r_len && !cf_scalar && !ri_scalar) ||
332 (a_len != c_len && !cf_scalar && !ci_scalar) ||
333 (r_len != c_len && !ri_scalar && !ci_scalar) || nr < 0 || nc < 0)
334 {
335 (*current_liboctave_error_handler)
336 ("Sparse::Sparse (const Array<T>&, const Array<octave_idx_type>&, ...): dimension mismatch");
337 rep = nil_rep ();
338 dimensions = dim_vector (0, 0);
339 }
340 else
341 {
342 octave_idx_type max_nzmx = (r_len > c_len ? r_len : c_len);
343
344 OCTAVE_LOCAL_BUFFER (octave_sparse_sort_idxl *, sidx, max_nzmx);
345 OCTAVE_LOCAL_BUFFER (octave_sparse_sort_idxl, sidxX, max_nzmx);
346
347 for (octave_idx_type i = 0; i < max_nzmx; i++)
348 sidx[i] = &sidxX[i];
349
350 octave_idx_type actual_nzmx = 0;
351 octave_quit ();
352 for (octave_idx_type i = 0; i < max_nzmx; i++)
353 {
354 octave_idx_type rowidx = (ri_scalar ? r(0) : r(i));
355 octave_idx_type colidx = (ci_scalar ? c(0) : c(i));
356 if (rowidx < nr && rowidx >= 0 &&
357 colidx < nc && colidx >= 0 )
358 {
359 if ( a (cf_scalar ? 0 : i ) != T ())
360 {
361 sidx[actual_nzmx]->r = rowidx;
362 sidx[actual_nzmx]->c = colidx;
363 sidx[actual_nzmx]->idx = i;
364 actual_nzmx++;
365 }
366 }
367 else
368 {
369 (*current_liboctave_error_handler)
370 ("Sparse::Sparse : index (%d,%d) out of range",
371 rowidx + 1, colidx + 1);
372 rep = nil_rep ();
373 dimensions = dim_vector (0, 0);
374 return;
375 }
376 }
377
378 if (actual_nzmx == 0)
379 rep = new typename Sparse<T>::SparseRep (nr, nc);
380 else
381 {
382 octave_quit ();
383 octave_sort<octave_sparse_sort_idxl *>
384 lsort (octave_sparse_sidxl_comp);
385
386 lsort.sort (sidx, actual_nzmx);
387 octave_quit ();
388
389 // Now count the unique non-zero values
390 octave_idx_type real_nzmx = 1;
391 for (octave_idx_type i = 1; i < actual_nzmx; i++)
392 if (sidx[i-1]->r != sidx[i]->r || sidx[i-1]->c != sidx[i]->c)
393 real_nzmx++;
394
395 rep = new typename Sparse<T>::SparseRep (nr, nc, real_nzmx);
396
397 octave_idx_type cx = 0;
398 octave_idx_type prev_rval = -1;
399 octave_idx_type prev_cval = -1;
400 octave_idx_type ii = -1;
401 xcidx (0) = 0;
402 for (octave_idx_type i = 0; i < actual_nzmx; i++)
403 {
404 octave_quit ();
405 octave_idx_type iidx = sidx[i]->idx;
406 octave_idx_type rval = sidx[i]->r;
407 octave_idx_type cval = sidx[i]->c;
408
409 if (prev_cval < cval || (prev_rval < rval && prev_cval == cval))
410 {
411 octave_idx_type ci = static_cast<octave_idx_type> (c (ci_scalar ? 0 : iidx));
412 ii++;
413 while (cx < ci)
414 xcidx (++cx) = ii;
415 xdata(ii) = a (cf_scalar ? 0 : iidx);
416 xridx(ii) = static_cast<octave_idx_type> (r (ri_scalar ? 0 : iidx));
417 }
418 else
419 {
420 if (sum_terms)
421 xdata(ii) += a (cf_scalar ? 0 : iidx);
422 else
423 xdata(ii) = a (cf_scalar ? 0 : iidx);
424 }
425 prev_rval = rval;
426 prev_cval = cval;
427 }
428
429 while (cx < nc)
430 xcidx (++cx) = ii + 1;
431 }
432 }
433 }
434
435 template <class T>
436 Sparse<T>::Sparse (const Array<T>& a, const Array<double>& r,
437 const Array<double>& c, octave_idx_type nr,
438 octave_idx_type nc, bool sum_terms)
439 : dimensions (dim_vector (nr, nc)), idx (0), idx_count (0)
440 {
441 octave_idx_type a_len = a.length ();
442 octave_idx_type r_len = r.length ();
443 octave_idx_type c_len = c.length ();
444 bool ri_scalar = (r_len == 1);
445 bool ci_scalar = (c_len == 1);
446 bool cf_scalar = (a_len == 1);
447
448 if ((a_len != r_len && !cf_scalar && !ri_scalar) ||
449 (a_len != c_len && !cf_scalar && !ci_scalar) ||
450 (r_len != c_len && !ri_scalar && !ci_scalar) || nr < 0 || nc < 0)
451 {
452 (*current_liboctave_error_handler)
453 ("Sparse::Sparse (const Array<T>&, const Array<double>&, ...): dimension mismatch");
454 rep = nil_rep ();
455 dimensions = dim_vector (0, 0);
456 }
457 else
458 {
459 octave_idx_type max_nzmx = (r_len > c_len ? r_len : c_len);
460
461 OCTAVE_LOCAL_BUFFER (octave_sparse_sort_idxl *, sidx, max_nzmx);
462 OCTAVE_LOCAL_BUFFER (octave_sparse_sort_idxl, sidxX, max_nzmx);
463
464 for (octave_idx_type i = 0; i < max_nzmx; i++)
465 sidx[i] = &sidxX[i];
466
467 octave_idx_type actual_nzmx = 0;
468 octave_quit ();
469
470 for (octave_idx_type i = 0; i < max_nzmx; i++)
471 {
472 octave_idx_type rowidx = static_cast<octave_idx_type> (ri_scalar ? r(0) : r(i));
473 octave_idx_type colidx = static_cast<octave_idx_type> (ci_scalar ? c(0) : c(i));
474 if (rowidx < nr && rowidx >= 0 &&
475 colidx < nc && colidx >= 0 )
476 {
477 if ( a (cf_scalar ? 0 : i ) != T ())
478 {
479 sidx[actual_nzmx]->r = rowidx;
480 sidx[actual_nzmx]->c = colidx;
481 sidx[actual_nzmx]->idx = i;
482 actual_nzmx++;
483 }
484 }
485 else
486 {
487 (*current_liboctave_error_handler)
488 ("Sparse::Sparse : index (%d,%d) out of range",
489 rowidx + 1, colidx + 1);
490 rep = nil_rep ();
491 dimensions = dim_vector (0, 0);
492 return;
493 }
494 }
495
496 if (actual_nzmx == 0)
497 rep = new typename Sparse<T>::SparseRep (nr, nc);
498 else
499 {
500 octave_quit ();
501 octave_sort<octave_sparse_sort_idxl *>
502 lsort (octave_sparse_sidxl_comp);
503
504 lsort.sort (sidx, actual_nzmx);
505 octave_quit ();
506
507 // Now count the unique non-zero values
508 octave_idx_type real_nzmx = 1;
509 for (octave_idx_type i = 1; i < actual_nzmx; i++)
510 if (sidx[i-1]->r != sidx[i]->r || sidx[i-1]->c != sidx[i]->c)
511 real_nzmx++;
512
513 rep = new typename Sparse<T>::SparseRep (nr, nc, real_nzmx);
514
515 octave_idx_type cx = 0;
516 octave_idx_type prev_rval = -1;
517 octave_idx_type prev_cval = -1;
518 octave_idx_type ii = -1;
519 xcidx (0) = 0;
520 for (octave_idx_type i = 0; i < actual_nzmx; i++)
521 {
522 octave_quit ();
523 octave_idx_type iidx = sidx[i]->idx;
524 octave_idx_type rval = sidx[i]->r;
525 octave_idx_type cval = sidx[i]->c;
526
527 if (prev_cval < cval || (prev_rval < rval && prev_cval == cval))
528 {
529 octave_idx_type ci = static_cast<octave_idx_type> (c (ci_scalar ? 0 : iidx));
530 ii++;
531
532 while (cx < ci)
533 xcidx (++cx) = ii;
534 xdata(ii) = a (cf_scalar ? 0 : iidx);
535 xridx(ii) = static_cast<octave_idx_type> (r (ri_scalar ? 0 : iidx));
536 }
537 else
538 {
539 if (sum_terms)
540 xdata(ii) += a (cf_scalar ? 0 : iidx);
541 else
542 xdata(ii) = a (cf_scalar ? 0 : iidx);
543 }
544 prev_rval = rval;
545 prev_cval = cval;
546 }
547
548 while (cx < nc)
549 xcidx (++cx) = ii + 1;
550 }
551 } 315 }
552 } 316 }
553 317
554 template <class T> 318 template <class T>
555 Sparse<T>::Sparse (const Array<T>& a, const idx_vector& r, 319 Sparse<T>::Sparse (const Array<T>& a, const idx_vector& r,