Mercurial > octave-nkf

comparison liboctave/array/CSparse.cc @ 18106:b3f443b4802b gui-release

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: backout cset 35464baa7d99 on gui-release branch.
author Rik <rik@octave.org>
date Thu, 05 Dec 2013 11:39:02 -0800
parents 8e056300994b
children 2217bc116aa9
comparison
equal deleted inserted replaced
18105:e0775b4f41dd 18106:b3f443b4802b
7686 SparseComplexMatrix 7686 SparseComplexMatrix
7687 min (const SparseComplexMatrix& a, const SparseComplexMatrix& b) 7687 min (const SparseComplexMatrix& a, const SparseComplexMatrix& b)
7688 { 7688 {
7689 SparseComplexMatrix r; 7689 SparseComplexMatrix r;
7690 7690
7691 octave_idx_type a_nr = a.rows (); 7691 if ((a.rows () == b.rows ()) && (a.cols () == b.cols ()))
7692 octave_idx_type a_nc = a.cols ();
7693 octave_idx_type b_nr = b.rows ();
7694 octave_idx_type b_nc = b.cols ();
7695
7696 if (a_nr == b_nr && a_nc == b_nc)
7697 { 7692 {
7698 r = SparseComplexMatrix (a_nr, a_nc, (a.nnz () + b.nnz ())); 7693 octave_idx_type a_nr = a.rows ();
7699 7694 octave_idx_type a_nc = a.cols ();
7700 octave_idx_type jx = 0; 7695
7701 r.cidx (0) = 0; 7696 octave_idx_type b_nr = b.rows ();
7702 for (octave_idx_type i = 0 ; i < a_nc ; i++) 7697 octave_idx_type b_nc = b.cols ();
7698
7699 if (a_nr == 0 || b_nc == 0 || a.nnz () == 0 || b.nnz () == 0)
7700 return SparseComplexMatrix (a_nr, a_nc);
7701
7702 if (a_nr != b_nr || a_nc != b_nc)
7703 gripe_nonconformant ("min", a_nr, a_nc, b_nr, b_nc);
7704 else
7703 { 7705 {
7704 octave_idx_type ja = a.cidx (i); 7706 r = SparseComplexMatrix (a_nr, a_nc, (a.nnz () + b.nnz ()));
7705 octave_idx_type ja_max = a.cidx (i+1); 7707
7706 bool ja_lt_max= ja < ja_max; 7708 octave_idx_type jx = 0;
7707 7709 r.cidx (0) = 0;
7708 octave_idx_type jb = b.cidx (i); 7710 for (octave_idx_type i = 0 ; i < a_nc ; i++)
7709 octave_idx_type jb_max = b.cidx (i+1); 7711 {
7710 bool jb_lt_max = jb < jb_max; 7712 octave_idx_type ja = a.cidx (i);
7711 7713 octave_idx_type ja_max = a.cidx (i+1);
7712 while (ja_lt_max || jb_lt_max ) 7714 bool ja_lt_max= ja < ja_max;
7713 { 7715
7714 octave_quit (); 7716 octave_idx_type jb = b.cidx (i);
7715 if ((! jb_lt_max) || 7717 octave_idx_type jb_max = b.cidx (i+1);
7716 (ja_lt_max && (a.ridx (ja) < b.ridx (jb)))) 7718 bool jb_lt_max = jb < jb_max;
7717 { 7719
7718 Complex tmp = xmin (a.data (ja), 0.); 7720 while (ja_lt_max || jb_lt_max )
7719 if (tmp != 0.) 7721 {
7720 { 7722 octave_quit ();
7721 r.ridx (jx) = a.ridx (ja); 7723 if ((! jb_lt_max) ||
7722 r.data (jx) = tmp; 7724 (ja_lt_max && (a.ridx (ja) < b.ridx (jb))))
7723 jx++; 7725 {
7724 } 7726 Complex tmp = xmin (a.data (ja), 0.);
7725 ja++; 7727 if (tmp != 0.)
7726 ja_lt_max= ja < ja_max; 7728 {
7727 } 7729 r.ridx (jx) = a.ridx (ja);
7728 else if (( !ja_lt_max ) || 7730 r.data (jx) = tmp;
7729 (jb_lt_max && (b.ridx (jb) < a.ridx (ja)) ) ) 7731 jx++;
7730 { 7732 }
7731 Complex tmp = xmin (0., b.data (jb)); 7733 ja++;
7732 if (tmp != 0.) 7734 ja_lt_max= ja < ja_max;
7733 { 7735 }
7734 r.ridx (jx) = b.ridx (jb); 7736 else if (( !ja_lt_max ) ||
7735 r.data (jx) = tmp; 7737 (jb_lt_max && (b.ridx (jb) < a.ridx (ja)) ) )
7736 jx++; 7738 {
7737 } 7739 Complex tmp = xmin (0., b.data (jb));
7738 jb++; 7740 if (tmp != 0.)
7739 jb_lt_max= jb < jb_max; 7741 {
7740 } 7742 r.ridx (jx) = b.ridx (jb);
7741 else 7743 r.data (jx) = tmp;
7742 { 7744 jx++;
7743 Complex tmp = xmin (a.data (ja), b.data (jb)); 7745 }
7744 if (tmp != 0.) 7746 jb++;
7745 { 7747 jb_lt_max= jb < jb_max;
7746 r.data (jx) = tmp; 7748 }
7747 r.ridx (jx) = a.ridx (ja); 7749 else
7748 jx++; 7750 {
7749 } 7751 Complex tmp = xmin (a.data (ja), b.data (jb));
7750 ja++; 7752 if (tmp != 0.)
7751 ja_lt_max= ja < ja_max; 7753 {
7752 jb++; 7754 r.data (jx) = tmp;
7753 jb_lt_max= jb < jb_max; 7755 r.ridx (jx) = a.ridx (ja);
7754 } 7756 jx++;
7755 } 7757 }
7756 r.cidx (i+1) = jx; 7758 ja++;
7759 ja_lt_max= ja < ja_max;
7760 jb++;
7761 jb_lt_max= jb < jb_max;
7762 }
7763 }
7764 r.cidx (i+1) = jx;
7765 }
7766
7767 r.maybe_compress ();
7757 } 7768 }
7758
7759 r.maybe_compress ();
7760 } 7769 }
7761 else 7770 else
7762 { 7771 (*current_liboctave_error_handler) ("matrix size mismatch");
7763 if (a_nr == 0 || a_nc == 0)
7764 r.resize (a_nr, a_nc);
7765 else if (b_nr == 0 || b_nc == 0)
7766 r.resize (b_nr, b_nc);
7767 else
7768 gripe_nonconformant ("min", a_nr, a_nc, b_nr, b_nc);
7769 }
7770 7772
7771 return r; 7773 return r;
7772 } 7774 }
7773 7775
7774 SparseComplexMatrix 7776 SparseComplexMatrix
7804 SparseComplexMatrix 7806 SparseComplexMatrix
7805 max (const SparseComplexMatrix& a, const SparseComplexMatrix& b) 7807 max (const SparseComplexMatrix& a, const SparseComplexMatrix& b)
7806 { 7808 {
7807 SparseComplexMatrix r; 7809 SparseComplexMatrix r;
7808 7810
7809 octave_idx_type a_nr = a.rows (); 7811 if ((a.rows () == b.rows ()) && (a.cols () == b.cols ()))
7810 octave_idx_type a_nc = a.cols ();
7811 octave_idx_type b_nr = b.rows ();
7812 octave_idx_type b_nc = b.cols ();
7813
7814 if (a_nr == b_nr && a_nc == b_nc)
7815 { 7812 {
7816 r = SparseComplexMatrix (a_nr, a_nc, (a.nnz () + b.nnz ())); 7813 octave_idx_type a_nr = a.rows ();
7817 7814 octave_idx_type a_nc = a.cols ();
7818 octave_idx_type jx = 0; 7815
7819 r.cidx (0) = 0; 7816 octave_idx_type b_nr = b.rows ();
7820 for (octave_idx_type i = 0 ; i < a_nc ; i++) 7817 octave_idx_type b_nc = b.cols ();
7818
7819 if (a_nr == 0 || b_nc == 0)
7820 return SparseComplexMatrix (a_nr, a_nc);
7821 if (a.nnz () == 0)
7822 return SparseComplexMatrix (b);
7823 if (b.nnz () == 0)
7824 return SparseComplexMatrix (a);
7825
7826 if (a_nr != b_nr || a_nc != b_nc)
7827 gripe_nonconformant ("min", a_nr, a_nc, b_nr, b_nc);
7828 else
7821 { 7829 {
7822 octave_idx_type ja = a.cidx (i); 7830 r = SparseComplexMatrix (a_nr, a_nc, (a.nnz () + b.nnz ()));
7823 octave_idx_type ja_max = a.cidx (i+1); 7831
7824 bool ja_lt_max= ja < ja_max; 7832 octave_idx_type jx = 0;
7825 7833 r.cidx (0) = 0;
7826 octave_idx_type jb = b.cidx (i); 7834 for (octave_idx_type i = 0 ; i < a_nc ; i++)
7827 octave_idx_type jb_max = b.cidx (i+1); 7835 {
7828 bool jb_lt_max = jb < jb_max; 7836 octave_idx_type ja = a.cidx (i);
7829 7837 octave_idx_type ja_max = a.cidx (i+1);
7830 while (ja_lt_max || jb_lt_max ) 7838 bool ja_lt_max= ja < ja_max;
7831 { 7839
7832 octave_quit (); 7840 octave_idx_type jb = b.cidx (i);
7833 if ((! jb_lt_max) || 7841 octave_idx_type jb_max = b.cidx (i+1);
7834 (ja_lt_max && (a.ridx (ja) < b.ridx (jb)))) 7842 bool jb_lt_max = jb < jb_max;
7835 { 7843
7836 Complex tmp = xmax (a.data (ja), 0.); 7844 while (ja_lt_max || jb_lt_max )
7837 if (tmp != 0.) 7845 {
7838 { 7846 octave_quit ();
7839 r.ridx (jx) = a.ridx (ja); 7847 if ((! jb_lt_max) ||
7840 r.data (jx) = tmp; 7848 (ja_lt_max && (a.ridx (ja) < b.ridx (jb))))
7841 jx++; 7849 {
7842 } 7850 Complex tmp = xmax (a.data (ja), 0.);
7843 ja++; 7851 if (tmp != 0.)
7844 ja_lt_max= ja < ja_max; 7852 {
7845 } 7853 r.ridx (jx) = a.ridx (ja);
7846 else if (( !ja_lt_max ) || 7854 r.data (jx) = tmp;
7847 (jb_lt_max && (b.ridx (jb) < a.ridx (ja)) ) ) 7855 jx++;
7848 { 7856 }
7849 Complex tmp = xmax (0., b.data (jb)); 7857 ja++;
7850 if (tmp != 0.) 7858 ja_lt_max= ja < ja_max;
7851 { 7859 }
7852 r.ridx (jx) = b.ridx (jb); 7860 else if (( !ja_lt_max ) ||
7853 r.data (jx) = tmp; 7861 (jb_lt_max && (b.ridx (jb) < a.ridx (ja)) ) )
7854 jx++; 7862 {
7855 } 7863 Complex tmp = xmax (0., b.data (jb));
7856 jb++; 7864 if (tmp != 0.)
7857 jb_lt_max= jb < jb_max; 7865 {
7858 } 7866 r.ridx (jx) = b.ridx (jb);
7859 else 7867 r.data (jx) = tmp;
7860 { 7868 jx++;
7861 Complex tmp = xmax (a.data (ja), b.data (jb)); 7869 }
7862 if (tmp != 0.) 7870 jb++;
7863 { 7871 jb_lt_max= jb < jb_max;
7864 r.data (jx) = tmp; 7872 }
7865 r.ridx (jx) = a.ridx (ja); 7873 else
7866 jx++; 7874 {
7867 } 7875 Complex tmp = xmax (a.data (ja), b.data (jb));
7868 ja++; 7876 if (tmp != 0.)
7869 ja_lt_max= ja < ja_max; 7877 {
7870 jb++; 7878 r.data (jx) = tmp;
7871 jb_lt_max= jb < jb_max; 7879 r.ridx (jx) = a.ridx (ja);
7872 } 7880 jx++;
7873 } 7881 }
7874 r.cidx (i+1) = jx; 7882 ja++;
7883 ja_lt_max= ja < ja_max;
7884 jb++;
7885 jb_lt_max= jb < jb_max;
7886 }
7887 }
7888 r.cidx (i+1) = jx;
7889 }
7890
7891 r.maybe_compress ();
7875 } 7892 }
7876
7877 r.maybe_compress ();
7878 } 7893 }
7879 else 7894 else
7880 { 7895 (*current_liboctave_error_handler) ("matrix size mismatch");
7881 if (a_nr == 0 || a_nc == 0)
7882 r.resize (a_nr, a_nc);
7883 else if (b_nr == 0 || b_nc == 0)
7884 r.resize (b_nr, b_nc);
7885 else
7886 gripe_nonconformant ("max", a_nr, a_nc, b_nr, b_nc);
7887 }
7888 7896
7889 return r; 7897 return r;
7890 } 7898 }
7891 7899
7892 SPARSE_SMS_CMP_OPS (SparseComplexMatrix, 0.0, real, Complex, 7900 SPARSE_SMS_CMP_OPS (SparseComplexMatrix, 0.0, real, Complex,