Mercurial > hg > octave-nkf

comparison liboctave/idx-vector.cc @ 10487:942386d6d1a5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
style fixes
author John W. Eaton <jwe@octave.org>
date Fri, 02 Apr 2010 15:15:41 -0400
parents 4e64fbbd5c58
children d47802f0e557
comparison
equal deleted inserted replaced
10486:4e64fbbd5c58 10487:942386d6d1a5
224 convert_index (octave_idx_type i, bool& conv_error, 224 convert_index (octave_idx_type i, bool& conv_error,
225 octave_idx_type& ext) 225 octave_idx_type& ext)
226 { 226 {
227 if (i <= 0) 227 if (i <= 0)
228 conv_error = true; 228 conv_error = true;
229 if (ext < i) ext = i; 229
230 if (ext < i)
231 ext = i;
232
230 return i - 1; 233 return i - 1;
231 } 234 }
232 235
233 inline octave_idx_type 236 inline octave_idx_type
234 convert_index (double x, bool& conv_error, octave_idx_type& ext) 237 convert_index (double x, bool& conv_error, octave_idx_type& ext)
235 { 238 {
236 octave_idx_type i = static_cast<octave_idx_type> (x); 239 octave_idx_type i = static_cast<octave_idx_type> (x);
240
237 if (static_cast<double> (i) != x) 241 if (static_cast<double> (i) != x)
238 conv_error = true; 242 conv_error = true;
239 243
240 return convert_index (i, conv_error, ext); 244 return convert_index (i, conv_error, ext);
241 } 245 }
250 inline octave_idx_type 254 inline octave_idx_type
251 convert_index (octave_int<T> x, bool& conv_error, 255 convert_index (octave_int<T> x, bool& conv_error,
252 octave_idx_type& ext) 256 octave_idx_type& ext)
253 { 257 {
254 octave_idx_type i = octave_int<octave_idx_type> (x).value (); 258 octave_idx_type i = octave_int<octave_idx_type> (x).value ();
259
255 return convert_index (i, conv_error, ext); 260 return convert_index (i, conv_error, ext);
256 } 261 }
257 262
258 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_scalar_rep); 263 DEFINE_OCTAVE_ALLOCATOR(idx_vector::idx_scalar_rep);
259 264
260 template <class T> 265 template <class T>
261 idx_vector::idx_scalar_rep::idx_scalar_rep (T x) 266 idx_vector::idx_scalar_rep::idx_scalar_rep (T x)
262 { 267 {
263 octave_idx_type dummy = 0; 268 octave_idx_type dummy = 0;
269
264 data = convert_index (x, err, dummy); 270 data = convert_index (x, err, dummy);
265 if (err) gripe_invalid_index (); 271
272 if (err)
273 gripe_invalid_index ();
266 } 274 }
267 275
268 idx_vector::idx_scalar_rep::idx_scalar_rep (octave_idx_type i) 276 idx_vector::idx_scalar_rep::idx_scalar_rep (octave_idx_type i)
269 : data (i) 277 : data (i)
270 { 278 {
276 } 284 }
277 285
278 octave_idx_type 286 octave_idx_type
279 idx_vector::idx_scalar_rep::checkelem (octave_idx_type i) const 287 idx_vector::idx_scalar_rep::checkelem (octave_idx_type i) const
280 { 288 {
281 if (i != 0) gripe_index_out_of_range (); 289 if (i != 0)
290 gripe_index_out_of_range ();
291
282 return data; 292 return data;
283 } 293 }
284 294
285 idx_vector::idx_base_rep * 295 idx_vector::idx_base_rep *
286 idx_vector::idx_scalar_rep::sort_idx (Array<octave_idx_type>& idx) 296 idx_vector::idx_scalar_rep::sort_idx (Array<octave_idx_type>& idx)
319 octave_idx_type *d = new octave_idx_type[len]; 329 octave_idx_type *d = new octave_idx_type[len];
320 for (octave_idx_type i = 0; i < len; i++) 330 for (octave_idx_type i = 0; i < len; i++)
321 d[i] = convert_index (nda.xelem (i), err, ext); 331 d[i] = convert_index (nda.xelem (i), err, ext);
322 data = d; 332 data = d;
323 333
324 if (err) gripe_invalid_index (); 334 if (err)
335 gripe_invalid_index ();
325 } 336 }
326 } 337 }
327 338
328 // Note that this makes a shallow copy of the index array. 339 // Note that this makes a shallow copy of the index array.
329 340
343 max = k; 354 max = k;
344 } 355 }
345 356
346 ext = max + 1; 357 ext = max + 1;
347 358
348 if (err) gripe_invalid_index (); 359 if (err)
360 gripe_invalid_index ();
349 } 361 }
350 } 362 }
351 363
352 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda, 364 idx_vector::idx_vector_rep::idx_vector_rep (const Array<octave_idx_type>& inda,
353 octave_idx_type _ext, direct) 365 octave_idx_type _ext, direct)
354 : data (inda.data ()), len (inda.numel ()), ext (_ext), 366 : data (inda.data ()), len (inda.numel ()), ext (_ext),
355 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ()) 367 aowner (new Array<octave_idx_type> (inda)), orig_dims (inda.dims ())
356 { 368 {
357 // No checking. 369 // No checking.
358 if (ext < 0) 370 if (ext < 0)
359 { 371 {
360 octave_idx_type max = -1; 372 octave_idx_type max = -1;
397 409
398 octave_idx_type ntot = bnda.length (); 410 octave_idx_type ntot = bnda.length ();
399 411
400 octave_idx_type k = 0; 412 octave_idx_type k = 0;
401 for (octave_idx_type i = 0; i < ntot; i++) 413 for (octave_idx_type i = 0; i < ntot; i++)
402 if (bnda.xelem (i)) d[k++] = i; 414 if (bnda.xelem (i))
415 d[k++] = i;
403 416
404 data = d; 417 data = d;
405 418
406 ext = d[k-1] + 1; 419 ext = d[k-1] + 1;
407 } 420 }
593 606
594 std::ostream& 607 std::ostream&
595 idx_vector::idx_vector_rep::print (std::ostream& os) const 608 idx_vector::idx_vector_rep::print (std::ostream& os) const
596 { 609 {
597 os << '['; 610 os << '[';
611
598 for (octave_idx_type ii = 0; ii < len - 1; ii++) 612 for (octave_idx_type ii = 0; ii < len - 1; ii++)
599 os << data[ii] << ',' << ' '; 613 os << data[ii] << ',' << ' ';
600 if (len > 0) os << data[len-1]; os << ']'; 614
615 if (len > 0)
616 os << data[len-1]; os << ']';
601 617
602 return os; 618 return os;
603 } 619 }
604 620
605 Array<double> 621 Array<double>
706 722
707 std::ostream& 723 std::ostream&
708 idx_vector::idx_mask_rep::print (std::ostream& os) const 724 idx_vector::idx_mask_rep::print (std::ostream& os) const
709 { 725 {
710 os << '['; 726 os << '[';
727
711 for (octave_idx_type ii = 0; ii < ext - 1; ii++) 728 for (octave_idx_type ii = 0; ii < ext - 1; ii++)
712 os << data[ii] << ',' << ' '; 729 os << data[ii] << ',' << ' ';
713 if (ext > 0) os << data[ext-1]; os << ']'; 730
731 if (ext > 0)
732 os << data[ext-1]; os << ']';
714 733
715 return os; 734 return os;
716 } 735 }
717 736
718 Array<bool> 737 Array<bool>
785 rep = new idx_range_rep (r); 804 rep = new idx_range_rep (r);
786 805
787 chkerr (); 806 chkerr ();
788 } 807 }
789 808
790 bool idx_vector::maybe_reduce (octave_idx_type n, const idx_vector& j, 809 bool
791 octave_idx_type nj) 810 idx_vector::maybe_reduce (octave_idx_type n, const idx_vector& j,
811 octave_idx_type nj)
792 { 812 {
793 bool reduced = false; 813 bool reduced = false;
794 814
795 // Empty index always reduces. 815 // Empty index always reduces.
796 if (rep->length (n) == 0) 816 if (rep->length (n) == 0)
816 { 836 {
817 case class_colon: 837 case class_colon:
818 // (:,:) reduces to (:) 838 // (:,:) reduces to (:)
819 reduced = true; 839 reduced = true;
820 break; 840 break;
841
821 case class_scalar: 842 case class_scalar:
822 { 843 {
823 // (i,:) reduces to a range. 844 // (i,:) reduces to a range.
824 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); 845 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep);
825 octave_idx_type k = r->get_data (); 846 octave_idx_type k = r->get_data ();
826 *this = new idx_range_rep (k, nj, n, DIRECT); 847 *this = new idx_range_rep (k, nj, n, DIRECT);
827 reduced = true; 848 reduced = true;
828 break;
829 } 849 }
850 break;
851
830 case class_range: 852 case class_range:
831 { 853 {
832 // (i:k:end,:) reduces to a range if i <= k and k divides n. 854 // (i:k:end,:) reduces to a range if i <= k and k divides n.
833 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); 855 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep);
834 octave_idx_type s = r->get_start (), l = r->length (n); 856 octave_idx_type s = r->get_start (), l = r->length (n);
836 if (l*t == n) 858 if (l*t == n)
837 { 859 {
838 *this = new idx_range_rep (s, l * nj, t, DIRECT); 860 *this = new idx_range_rep (s, l * nj, t, DIRECT);
839 reduced = true; 861 reduced = true;
840 } 862 }
841 break;
842 } 863 }
864 break;
865
843 default: 866 default:
844 break; 867 break;
845 } 868 }
846 break; 869 break;
870
847 case class_range: 871 case class_range:
848 switch (rep->idx_class ()) 872 switch (rep->idx_class ())
849 { 873 {
850 case class_colon: 874 case class_colon:
851 { 875 {
855 { 879 {
856 octave_idx_type sj = rj->get_start (), lj = rj->length (nj); 880 octave_idx_type sj = rj->get_start (), lj = rj->length (nj);
857 *this = new idx_range_rep (sj * n, lj * n, 1, DIRECT); 881 *this = new idx_range_rep (sj * n, lj * n, 1, DIRECT);
858 reduced = true; 882 reduced = true;
859 } 883 }
860 break;
861 } 884 }
885 break;
886
862 case class_scalar: 887 case class_scalar:
863 { 888 {
864 // (k,i:d:j) reduces to a range. 889 // (k,i:d:j) reduces to a range.
865 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); 890 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep);
866 idx_range_rep * rj = dynamic_cast<idx_range_rep *> (j.rep); 891 idx_range_rep * rj = dynamic_cast<idx_range_rep *> (j.rep);
867 octave_idx_type k = r->get_data (); 892 octave_idx_type k = r->get_data ();
868 octave_idx_type sj = rj->get_start (), lj = rj->length (nj); 893 octave_idx_type sj = rj->get_start (), lj = rj->length (nj);
869 octave_idx_type tj = rj->get_step (); 894 octave_idx_type tj = rj->get_step ();
870 *this = new idx_range_rep (n * sj + k, lj, n * tj, DIRECT); 895 *this = new idx_range_rep (n * sj + k, lj, n * tj, DIRECT);
871 reduced = true; 896 reduced = true;
872 break;
873 } 897 }
898 break;
899
874 case class_range: 900 case class_range:
875 { 901 {
876 // (i:k:end,p:q) reduces to a range if i <= k and k divides n. 902 // (i:k:end,p:q) reduces to a range if i <= k and k divides n.
877 // (ones (1, m), ones (1, n)) reduces to (ones (1, m*n)) 903 // (ones (1, m), ones (1, n)) reduces to (ones (1, m*n))
878 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); 904 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep);
884 if ((l*t == n && tj == 1) || (t == 0 && tj == 0)) 910 if ((l*t == n && tj == 1) || (t == 0 && tj == 0))
885 { 911 {
886 *this = new idx_range_rep (s + n * sj, l * lj, t, DIRECT); 912 *this = new idx_range_rep (s + n * sj, l * lj, t, DIRECT);
887 reduced = true; 913 reduced = true;
888 } 914 }
889 break;
890 } 915 }
916 break;
917
891 default: 918 default:
892 break; 919 break;
893 } 920 }
894 break; 921 break;
922
895 case class_scalar: 923 case class_scalar:
896 switch (rep->idx_class ()) 924 switch (rep->idx_class ())
897 { 925 {
898 case class_scalar: 926 case class_scalar:
899 { 927 {
901 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); 929 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep);
902 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep); 930 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep);
903 octave_idx_type k = r->get_data () + n * rj->get_data (); 931 octave_idx_type k = r->get_data () + n * rj->get_data ();
904 *this = new idx_scalar_rep (k, DIRECT); 932 *this = new idx_scalar_rep (k, DIRECT);
905 reduced = true; 933 reduced = true;
906 break;
907 } 934 }
935 break;
936
908 case class_range: 937 case class_range:
909 { 938 {
910 // (i:d:j,k) reduces to a range. 939 // (i:d:j,k) reduces to a range.
911 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); 940 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep);
912 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep); 941 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep);
913 octave_idx_type s = r->get_start (), l = r->length (nj); 942 octave_idx_type s = r->get_start (), l = r->length (nj);
914 octave_idx_type t = r->get_step (); 943 octave_idx_type t = r->get_step ();
915 octave_idx_type k = rj->get_data (); 944 octave_idx_type k = rj->get_data ();
916 *this = new idx_range_rep (n * k + s, l, t, DIRECT); 945 *this = new idx_range_rep (n * k + s, l, t, DIRECT);
917 reduced = true; 946 reduced = true;
918 break;
919 } 947 }
948 break;
949
920 case class_colon: 950 case class_colon:
921 { 951 {
922 // (:,k) reduces to a range. 952 // (:,k) reduces to a range.
923 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep); 953 idx_scalar_rep * rj = dynamic_cast<idx_scalar_rep *> (j.rep);
924 octave_idx_type k = rj->get_data (); 954 octave_idx_type k = rj->get_data ();
925 *this = new idx_range_rep (n * k, n, 1, DIRECT); 955 *this = new idx_range_rep (n * k, n, 1, DIRECT);
926 reduced = true; 956 reduced = true;
927 break;
928 } 957 }
958 break;
959
929 default: 960 default:
930 break; 961 break;
931 } 962 }
932 break; 963 break;
964
933 default: 965 default:
934 break; 966 break;
935 } 967 }
936 968
937 return reduced; 969 return reduced;
940 bool 972 bool
941 idx_vector::is_cont_range (octave_idx_type n, 973 idx_vector::is_cont_range (octave_idx_type n,
942 octave_idx_type& l, octave_idx_type& u) const 974 octave_idx_type& l, octave_idx_type& u) const
943 { 975 {
944 bool res = false; 976 bool res = false;
977
945 switch (rep->idx_class ()) 978 switch (rep->idx_class ())
946 { 979 {
947 case class_colon: 980 case class_colon:
948 l = 0; u = n; 981 l = 0; u = n;
949 res = true; 982 res = true;
950 break; 983 break;
984
951 case class_range: 985 case class_range:
952 { 986 {
953 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); 987 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep);
954 if (r->get_step () == 1) 988 if (r->get_step () == 1)
955 { 989 {
957 u = l + r->length (n); 991 u = l + r->length (n);
958 res = true; 992 res = true;
959 } 993 }
960 } 994 }
961 break; 995 break;
996
962 case class_scalar: 997 case class_scalar:
963 { 998 {
964 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); 999 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep);
965 l = r->get_data (); 1000 l = r->get_data ();
966 u = l + 1; 1001 u = l + 1;
967 res = true; 1002 res = true;
968 } 1003 }
969 break; 1004 break;
1005
970 case class_mask: 1006 case class_mask:
971 { 1007 {
972 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep); 1008 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep);
973 octave_idx_type ext = r->extent (0), len = r->length (0); 1009 octave_idx_type ext = r->extent (0), len = r->length (0);
974 if (ext == len) 1010 if (ext == len)
976 l = 0; 1012 l = 0;
977 u = len; 1013 u = len;
978 res = true; 1014 res = true;
979 } 1015 }
980 } 1016 }
1017
981 default: 1018 default:
982 break; 1019 break;
983 } 1020 }
984 1021
985 return res; 1022 return res;
987 1024
988 octave_idx_type 1025 octave_idx_type
989 idx_vector::increment (void) const 1026 idx_vector::increment (void) const
990 { 1027 {
991 octave_idx_type retval = 0; 1028 octave_idx_type retval = 0;
1029
992 switch (rep->idx_class ()) 1030 switch (rep->idx_class ())
993 { 1031 {
994 case class_colon: 1032 case class_colon:
995 retval = 1; 1033 retval = 1;
1034 // fall through...
1035
996 case class_range: 1036 case class_range:
997 retval = dynamic_cast<idx_range_rep *> (rep) -> get_step (); 1037 retval = dynamic_cast<idx_range_rep *> (rep) -> get_step ();
998 break; 1038 break;
1039
999 case class_vector: 1040 case class_vector:
1000 { 1041 {
1001 if (length (0) > 1) 1042 if (length (0) > 1)
1002 retval = elem (1) - elem (0); 1043 retval = elem (1) - elem (0);
1003 } 1044 }
1045 break;
1046
1004 default: 1047 default:
1005 break; 1048 break;
1006 } 1049 }
1050
1007 return retval; 1051 return retval;
1008 } 1052 }
1009 1053
1010 const octave_idx_type * 1054 const octave_idx_type *
1011 idx_vector::raw (void) 1055 idx_vector::raw (void)
1012 { 1056 {
1013 if (rep->idx_class () != class_vector) 1057 if (rep->idx_class () != class_vector)
1014 *this = idx_vector (as_array (), extent (0)); 1058 *this = idx_vector (as_array (), extent (0));
1015 1059
1016 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); 1060 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep);
1061
1017 assert (r != 0); 1062 assert (r != 0);
1063
1018 return r->get_data (); 1064 return r->get_data ();
1019 } 1065 }
1020 1066
1021 void 1067 void
1022 idx_vector::copy_data (octave_idx_type *data) const 1068 idx_vector::copy_data (octave_idx_type *data) const
1026 switch (rep->idx_class ()) 1072 switch (rep->idx_class ())
1027 { 1073 {
1028 case class_colon: 1074 case class_colon:
1029 current_liboctave_error_handler ("colon not allowed"); 1075 current_liboctave_error_handler ("colon not allowed");
1030 break; 1076 break;
1077
1031 case class_range: 1078 case class_range:
1032 { 1079 {
1033 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); 1080 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep);
1034 octave_idx_type start = r->get_start (), step = r->get_step (); 1081 octave_idx_type start = r->get_start (), step = r->get_step ();
1035 octave_idx_type i, j; 1082 octave_idx_type i, j;
1036 if (step == 1) 1083 if (step == 1)
1037 for (i = start, j = start + len; i < j; i++) *data++ = i; 1084 for (i = start, j = start + len; i < j; i++) *data++ = i;
1038 else if (step == -1) 1085 else if (step == -1)
1039 for (i = start, j = start - len; i > j; i--) *data++ = i; 1086 for (i = start, j = start - len; i > j; i--) *data++ = i;
1040 else 1087 else
1041 for (i = 0, j = start; i < len; i++, j += step) *data++ = j; 1088 for (i = 0, j = start; i < len; i++, j += step) *data++ = j;
1042 } 1089 }
1043 break; 1090 break;
1091
1044 case class_scalar: 1092 case class_scalar:
1045 { 1093 {
1046 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); 1094 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep);
1047 *data = r->get_data (); 1095 *data = r->get_data ();
1048 } 1096 }
1049 break; 1097 break;
1098
1050 case class_vector: 1099 case class_vector:
1051 { 1100 {
1052 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); 1101 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep);
1053 const octave_idx_type *rdata = r->get_data (); 1102 const octave_idx_type *rdata = r->get_data ();
1054 copy_or_memcpy (len, rdata, data); 1103 copy_or_memcpy (len, rdata, data);
1055 } 1104 }
1056 break; 1105 break;
1106
1057 default: 1107 default:
1058 assert (false); 1108 assert (false);
1059 break; 1109 break;
1060 } 1110 }
1061
1062 } 1111 }
1063 1112
1064 idx_vector 1113 idx_vector
1065 idx_vector::complement (octave_idx_type n) const 1114 idx_vector::complement (octave_idx_type n) const
1066 { 1115 {
1077 cnt--; 1126 cnt--;
1078 } 1127 }
1079 } 1128 }
1080 1129
1081 octave_idx_type len = cnt, *data = new octave_idx_type[len]; 1130 octave_idx_type len = cnt, *data = new octave_idx_type[len];
1131
1082 for (octave_idx_type i = 0, j = 0; i < n; i++) 1132 for (octave_idx_type i = 0, j = 0; i < n; i++)
1083 if (left[i]) data[j++] = i; 1133 if (left[i])
1134 data[j++] = i;
1084 1135
1085 return new idx_vector_rep (data, len, 1136 return new idx_vector_rep (data, len,
1086 len ? data[len-1]+1 : 0, 1137 len ? data[len-1]+1 : 0,
1087 dim_vector (1, len), DIRECT); 1138 dim_vector (1, len), DIRECT);
1088 } 1139 }
1109 { 1160 {
1110 retval = false; 1161 retval = false;
1111 break; 1162 break;
1112 } 1163 }
1113 } 1164 }
1114
1115 } 1165 }
1116 1166
1117 return retval; 1167 return retval;
1118 } 1168 }
1119 1169
1124 { 1174 {
1125 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep); 1175 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep);
1126 const bool *data = r->get_data (); 1176 const bool *data = r->get_data ();
1127 octave_idx_type ext = r->extent (0), len = r->length (0); 1177 octave_idx_type ext = r->extent (0), len = r->length (0);
1128 octave_idx_type *idata = new octave_idx_type [len]; 1178 octave_idx_type *idata = new octave_idx_type [len];
1179
1129 for (octave_idx_type i = 0, j = 0; i < ext; i++) 1180 for (octave_idx_type i = 0, j = 0; i < ext; i++)
1130 if (data[i]) 1181 if (data[i])
1131 idata[j++] = i; 1182 idata[j++] = i;
1183
1132 ext = len > 0 ? idata[len - 1] : 0; 1184 ext = len > 0 ? idata[len - 1] : 0;
1133 return new idx_vector_rep (idata, len, ext, r->orig_dimensions (), DIRECT); 1185
1186 return new idx_vector_rep (idata, len, ext, r->orig_dimensions (),
1187 DIRECT);
1134 } 1188 }
1135 else 1189 else
1136 return *this; 1190 return *this;
1137 } 1191 }
1138 1192
1143 iclass = idx_class (); 1197 iclass = idx_class ();
1144 switch (iclass) 1198 switch (iclass)
1145 { 1199 {
1146 case class_colon: 1200 case class_colon:
1147 break; 1201 break;
1202
1148 case class_range: 1203 case class_range:
1149 { 1204 {
1150 idx_range_rep * r = dynamic_cast<idx_range_rep *> (rep); 1205 idx_range_rep *r = dynamic_cast<idx_range_rep *> (rep);
1151 range = r->unconvert (); 1206 range = r->unconvert ();
1152 } 1207 }
1153 break; 1208 break;
1209
1154 case class_scalar: 1210 case class_scalar:
1155 { 1211 {
1156 idx_scalar_rep * r = dynamic_cast<idx_scalar_rep *> (rep); 1212 idx_scalar_rep *r = dynamic_cast<idx_scalar_rep *> (rep);
1157 scalar = r->unconvert (); 1213 scalar = r->unconvert ();
1158 } 1214 }
1159 break; 1215 break;
1216
1160 case class_vector: 1217 case class_vector:
1161 { 1218 {
1162 idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); 1219 idx_vector_rep *r = dynamic_cast<idx_vector_rep *> (rep);
1163 array = r->unconvert (); 1220 array = r->unconvert ();
1164 } 1221 }
1165 break; 1222 break;
1223
1166 case class_mask: 1224 case class_mask:
1167 { 1225 {
1168 idx_mask_rep * r = dynamic_cast<idx_mask_rep *> (rep); 1226 idx_mask_rep *r = dynamic_cast<idx_mask_rep *> (rep);
1169 mask = r->unconvert (); 1227 mask = r->unconvert ();
1170 } 1228 }
1171 break; 1229 break;
1230
1172 default: 1231 default:
1173 assert (false); 1232 assert (false);
1174 break; 1233 break;
1175 } 1234 }
1176 } 1235 }
1197 1256
1198 octave_idx_type 1257 octave_idx_type
1199 idx_vector::ones_count () const 1258 idx_vector::ones_count () const
1200 { 1259 {
1201 octave_idx_type n = 0; 1260 octave_idx_type n = 0;
1261
1202 if (is_colon ()) 1262 if (is_colon ())
1203 n = 1; 1263 n = 1;
1204 else 1264 else
1205 for (octave_idx_type i = 0; i < length (1); i++) 1265 {
1206 if (xelem (i) == 0) n++; 1266 for (octave_idx_type i = 0; i < length (1); i++)
1267 if (xelem (i) == 0)
1268 n++;
1269 }
1270
1207 return n; 1271 return n;
1208 } 1272 }
1209 1273
1210 // Instantiate the octave_int constructors we want. 1274 // Instantiate the octave_int constructors we want.
1211 #define INSTANTIATE_SCALAR_VECTOR_REP_CONST(T) \ 1275 #define INSTANTIATE_SCALAR_VECTOR_REP_CONST(T) \