Mercurial > hg > octave-lyh

comparison liboctave/Array.cc @ 10314:07ebe522dac2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
untabify liboctave C++ sources
author John W. Eaton <jwe@octave.org>
date Thu, 11 Feb 2010 12:23:32 -0500
parents 6ffed9bb5598
children 12884915a8e4
comparison
equal deleted inserted replaced
10313:f3b65e1ae355 10314:07ebe522dac2
124 dim_vector new_dimensions = dimensions; 124 dim_vector new_dimensions = dimensions;
125 125
126 int k = 0; 126 int k = 0;
127 127
128 for (int i = 0; i < ndims (); i++) 128 for (int i = 0; i < ndims (); i++)
129 { 129 {
130 if (dimensions(i) == 1) 130 if (dimensions(i) == 1)
131 dims_changed = true; 131 dims_changed = true;
132 else 132 else
133 new_dimensions(k++) = dimensions(i); 133 new_dimensions(k++) = dimensions(i);
134 } 134 }
135 135
136 if (dims_changed) 136 if (dims_changed)
137 { 137 {
138 switch (k) 138 switch (k)
139 { 139 {
140 case 0: 140 case 0:
141 new_dimensions = dim_vector (1, 1); 141 new_dimensions = dim_vector (1, 1);
142 break; 142 break;
143 143
144 case 1: 144 case 1:
145 { 145 {
146 octave_idx_type tmp = new_dimensions(0); 146 octave_idx_type tmp = new_dimensions(0);
147 147
148 new_dimensions.resize (2); 148 new_dimensions.resize (2);
149 149
150 new_dimensions(0) = tmp; 150 new_dimensions(0) = tmp;
151 new_dimensions(1) = 1; 151 new_dimensions(1) = 1;
152 } 152 }
153 break; 153 break;
154 154
155 default: 155 default:
156 new_dimensions.resize (k); 156 new_dimensions.resize (k);
157 break; 157 break;
158 } 158 }
159 } 159 }
160 160
161 retval = Array<T> (*this, new_dimensions); 161 retval = Array<T> (*this, new_dimensions);
162 } 162 }
163 163
164 return retval; 164 return retval;
446 // Find dimension vector of permuted array. 446 // Find dimension vector of permuted array.
447 for (int i = 0; i < perm_vec_len; i++) 447 for (int i = 0; i < perm_vec_len; i++)
448 { 448 {
449 octave_idx_type perm_elt = perm_vec.elem (i); 449 octave_idx_type perm_elt = perm_vec.elem (i);
450 if (perm_elt >= perm_vec_len || perm_elt < 0) 450 if (perm_elt >= perm_vec_len || perm_elt < 0)
451 { 451 {
452 (*current_liboctave_error_handler) 452 (*current_liboctave_error_handler)
453 ("%s: permutation vector contains an invalid element", 453 ("%s: permutation vector contains an invalid element",
454 inv ? "ipermute" : "permute"); 454 inv ? "ipermute" : "permute");
455 455
456 return retval; 456 return retval;
457 } 457 }
458 458
459 if (checked[perm_elt]) 459 if (checked[perm_elt])
460 { 460 {
461 (*current_liboctave_error_handler) 461 (*current_liboctave_error_handler)
462 ("%s: permutation vector cannot contain identical elements", 462 ("%s: permutation vector cannot contain identical elements",
463 inv ? "ipermute" : "permute"); 463 inv ? "ipermute" : "permute");
464 464
465 return retval; 465 return retval;
466 } 466 }
467 else 467 else
468 { 468 {
469 checked[perm_elt] = true; 469 checked[perm_elt] = true;
470 identity = identity && perm_elt == i; 470 identity = identity && perm_elt == i;
471 } 471 }
1188 1188
1189 bool isfill = rhs.numel () == 1; 1189 bool isfill = rhs.numel () == 1;
1190 octave_idx_type il = i.length (rdv(0)), jl = j.length (rdv(1)); 1190 octave_idx_type il = i.length (rdv(0)), jl = j.length (rdv(1));
1191 rhdv.chop_all_singletons (); 1191 rhdv.chop_all_singletons ();
1192 bool match = (isfill 1192 bool match = (isfill
1193 || (rhdv.length () == 2 && il == rhdv(0) && jl == rhdv(1))); 1193 || (rhdv.length () == 2 && il == rhdv(0) && jl == rhdv(1)));
1194 match = match || (il == 1 && jl == rhdv(0) && rhdv(1) == 1); 1194 match = match || (il == 1 && jl == rhdv(0) && rhdv(1) == 1);
1195 1195
1196 if (match) 1196 if (match)
1197 { 1197 {
1198 bool all_colons = (i.is_colon_equiv (rdv(0)) 1198 bool all_colons = (i.is_colon_equiv (rdv(0))
1553 else if (nr > 1 && nc > 1) 1553 else if (nr > 1 && nc > 1)
1554 { 1554 {
1555 Array<T> result (dim_vector (nc, nr)); 1555 Array<T> result (dim_vector (nc, nr));
1556 1556
1557 for (octave_idx_type j = 0; j < nc; j++) 1557 for (octave_idx_type j = 0; j < nc; j++)
1558 for (octave_idx_type i = 0; i < nr; i++) 1558 for (octave_idx_type i = 0; i < nr; i++)
1559 result.xelem (j, i) = xelem (i, j); 1559 result.xelem (j, i) = xelem (i, j);
1560 1560
1561 return result; 1561 return result;
1562 } 1562 }
1563 else 1563 else
1564 { 1564 {
1596 // on some compilers. 1596 // on some compilers.
1597 T buf[64]; 1597 T buf[64];
1598 1598
1599 octave_idx_type ii = 0, jj; 1599 octave_idx_type ii = 0, jj;
1600 for (jj = 0; jj < (nc - 8 + 1); jj += 8) 1600 for (jj = 0; jj < (nc - 8 + 1); jj += 8)
1601 { 1601 {
1602 for (ii = 0; ii < (nr - 8 + 1); ii += 8) 1602 for (ii = 0; ii < (nr - 8 + 1); ii += 8)
1603 { 1603 {
1604 // Copy to buffer 1604 // Copy to buffer
1605 for (octave_idx_type j = jj, k = 0, idxj = jj * nr; 1605 for (octave_idx_type j = jj, k = 0, idxj = jj * nr;
1606 j < jj + 8; j++, idxj += nr) 1606 j < jj + 8; j++, idxj += nr)
1607 for (octave_idx_type i = ii; i < ii + 8; i++) 1607 for (octave_idx_type i = ii; i < ii + 8; i++)
1608 buf[k++] = xelem (i + idxj); 1608 buf[k++] = xelem (i + idxj);
1609 1609
1610 // Copy from buffer 1610 // Copy from buffer
1611 for (octave_idx_type i = ii, idxi = ii * nc; i < ii + 8; 1611 for (octave_idx_type i = ii, idxi = ii * nc; i < ii + 8;
1612 i++, idxi += nc) 1612 i++, idxi += nc)
1613 for (octave_idx_type j = jj, k = i - ii; j < jj + 8; 1613 for (octave_idx_type j = jj, k = i - ii; j < jj + 8;
1614 j++, k+=8) 1614 j++, k+=8)
1615 result.xelem (j + idxi) = fcn (buf[k]); 1615 result.xelem (j + idxi) = fcn (buf[k]);
1616 } 1616 }
1617 1617
1618 if (ii < nr) 1618 if (ii < nr)
1619 for (octave_idx_type j = jj; j < jj + 8; j++) 1619 for (octave_idx_type j = jj; j < jj + 8; j++)
1620 for (octave_idx_type i = ii; i < nr; i++) 1620 for (octave_idx_type i = ii; i < nr; i++)
1621 result.xelem (j, i) = fcn (xelem (i, j)); 1621 result.xelem (j, i) = fcn (xelem (i, j));
1622 } 1622 }
1623 1623
1624 for (octave_idx_type j = jj; j < nc; j++) 1624 for (octave_idx_type j = jj; j < nc; j++)
1625 for (octave_idx_type i = 0; i < nr; i++) 1625 for (octave_idx_type i = 0; i < nr; i++)
1626 result.xelem (j, i) = fcn (xelem (i, j)); 1626 result.xelem (j, i) = fcn (xelem (i, j));
1627 1627
1628 return result; 1628 return result;
1629 } 1629 }
1630 else 1630 else
1631 { 1631 {
1632 Array<T> result (dim_vector (nc, nr)); 1632 Array<T> result (dim_vector (nc, nr));
1633 1633
1634 for (octave_idx_type j = 0; j < nc; j++) 1634 for (octave_idx_type j = 0; j < nc; j++)
1635 for (octave_idx_type i = 0; i < nr; i++) 1635 for (octave_idx_type i = 0; i < nr; i++)
1636 result.xelem (j, i) = fcn (xelem (i, j)); 1636 result.xelem (j, i) = fcn (xelem (i, j));
1637 1637
1638 return result; 1638 return result;
1639 } 1639 }
1640 } 1640 }
1641 1641
1695 for (int i = nd - 1; i >= 0; i--) 1695 for (int i = nd - 1; i >= 0; i--)
1696 { 1696 {
1697 if (delete_dims) 1697 if (delete_dims)
1698 { 1698 {
1699 if (dimensions(i) != 1) 1699 if (dimensions(i) != 1)
1700 { 1700 {
1701 delete_dims = false; 1701 delete_dims = false;
1702 1702
1703 new_dims = dim_vector (i + 1, dimensions(i)); 1703 new_dims = dim_vector (i + 1, dimensions(i));
1704 } 1704 }
1705 } 1705 }
1706 else 1706 else
1707 new_dims(i) = dimensions(i); 1707 new_dims(i) = dimensions(i);
1708 } 1708 }
1709 1709
1710 if (nd != new_dims.length ()) 1710 if (nd != new_dims.length ())
1711 dimensions = new_dims; 1711 dimensions = new_dims;
1712 } 1712 }
1755 return m; 1755 return m;
1756 1756
1757 if (stride == 1) 1757 if (stride == 1)
1758 { 1758 {
1759 for (octave_idx_type j = 0; j < iter; j++) 1759 for (octave_idx_type j = 0; j < iter; j++)
1760 { 1760 {
1761 // copy and partition out NaNs. 1761 // copy and partition out NaNs.
1762 // FIXME: impact on integer types noticeable? 1762 // FIXME: impact on integer types noticeable?
1763 octave_idx_type kl = 0, ku = ns; 1763 octave_idx_type kl = 0, ku = ns;
1764 for (octave_idx_type i = 0; i < ns; i++) 1764 for (octave_idx_type i = 0; i < ns; i++)
1765 { 1765 {
1769 else 1769 else
1770 v[kl++] = tmp; 1770 v[kl++] = tmp;
1771 } 1771 }
1772 1772
1773 // sort. 1773 // sort.
1774 lsort.sort (v, kl); 1774 lsort.sort (v, kl);
1775 1775
1776 if (ku < ns) 1776 if (ku < ns)
1777 { 1777 {
1778 // NaNs are in reverse order 1778 // NaNs are in reverse order
1779 std::reverse (v + ku, v + ns); 1779 std::reverse (v + ku, v + ns);
1780 if (mode == DESCENDING) 1780 if (mode == DESCENDING)
1781 std::rotate (v, v + ku, v + ns); 1781 std::rotate (v, v + ku, v + ns);
1782 } 1782 }
1783 1783
1784 v += ns; 1784 v += ns;
1785 ov += ns; 1785 ov += ns;
1786 } 1786 }
1787 } 1787 }
1788 else 1788 else
1789 { 1789 {
1790 OCTAVE_LOCAL_BUFFER (T, buf, ns); 1790 OCTAVE_LOCAL_BUFFER (T, buf, ns);
1791 1791
1792 for (octave_idx_type j = 0; j < iter; j++) 1792 for (octave_idx_type j = 0; j < iter; j++)
1793 { 1793 {
1794 octave_idx_type offset = j; 1794 octave_idx_type offset = j;
1795 octave_idx_type offset2 = 0; 1795 octave_idx_type offset2 = 0;
1796 1796
1797 while (offset >= stride) 1797 while (offset >= stride)
1798 { 1798 {
1799 offset -= stride; 1799 offset -= stride;
1800 offset2++; 1800 offset2++;
1801 } 1801 }
1802 1802
1803 offset += offset2 * stride * ns; 1803 offset += offset2 * stride * ns;
1804 1804
1805 // gather and partition out NaNs. 1805 // gather and partition out NaNs.
1806 // FIXME: impact on integer types noticeable? 1806 // FIXME: impact on integer types noticeable?
1807 octave_idx_type kl = 0, ku = ns; 1807 octave_idx_type kl = 0, ku = ns;
1808 for (octave_idx_type i = 0; i < ns; i++) 1808 for (octave_idx_type i = 0; i < ns; i++)
1809 { 1809 {
1813 else 1813 else
1814 buf[kl++] = tmp; 1814 buf[kl++] = tmp;
1815 } 1815 }
1816 1816
1817 // sort. 1817 // sort.
1818 lsort.sort (buf, kl); 1818 lsort.sort (buf, kl);
1819 1819
1820 if (ku < ns) 1820 if (ku < ns)
1821 { 1821 {
1822 // NaNs are in reverse order 1822 // NaNs are in reverse order
1823 std::reverse (buf + ku, buf + ns); 1823 std::reverse (buf + ku, buf + ns);
1824 if (mode == DESCENDING) 1824 if (mode == DESCENDING)
1825 std::rotate (buf, buf + ku, buf + ns); 1825 std::rotate (buf, buf + ku, buf + ns);
1826 } 1826 }
1827 1827
1828 // scatter. 1828 // scatter.
1829 for (octave_idx_type i = 0; i < ns; i++) 1829 for (octave_idx_type i = 0; i < ns; i++)
1830 v[i*stride + offset] = buf[i]; 1830 v[i*stride + offset] = buf[i];
1831 } 1831 }
1832 } 1832 }
1833 1833
1834 return m; 1834 return m;
1835 } 1835 }
1836 1836
1837 template <class T> 1837 template <class T>
1838 Array<T> 1838 Array<T>
1839 Array<T>::sort (Array<octave_idx_type> &sidx, int dim, 1839 Array<T>::sort (Array<octave_idx_type> &sidx, int dim,
1840 sortmode mode) const 1840 sortmode mode) const
1841 { 1841 {
1842 if (dim < 0 || dim >= ndims ()) 1842 if (dim < 0 || dim >= ndims ())
1843 { 1843 {
1844 (*current_liboctave_error_handler) 1844 (*current_liboctave_error_handler)
1845 ("sort: invalid dimension"); 1845 ("sort: invalid dimension");
1877 return m; 1877 return m;
1878 1878
1879 if (stride == 1) 1879 if (stride == 1)
1880 { 1880 {
1881 for (octave_idx_type j = 0; j < iter; j++) 1881 for (octave_idx_type j = 0; j < iter; j++)
1882 { 1882 {
1883 // copy and partition out NaNs. 1883 // copy and partition out NaNs.
1884 // FIXME: impact on integer types noticeable? 1884 // FIXME: impact on integer types noticeable?
1885 octave_idx_type kl = 0, ku = ns; 1885 octave_idx_type kl = 0, ku = ns;
1886 for (octave_idx_type i = 0; i < ns; i++) 1886 for (octave_idx_type i = 0; i < ns; i++)
1887 { 1887 {
1899 kl++; 1899 kl++;
1900 } 1900 }
1901 } 1901 }
1902 1902
1903 // sort. 1903 // sort.
1904 lsort.sort (v, vi, kl); 1904 lsort.sort (v, vi, kl);
1905 1905
1906 if (ku < ns) 1906 if (ku < ns)
1907 { 1907 {
1908 // NaNs are in reverse order 1908 // NaNs are in reverse order
1909 std::reverse (v + ku, v + ns); 1909 std::reverse (v + ku, v + ns);
1913 std::rotate (v, v + ku, v + ns); 1913 std::rotate (v, v + ku, v + ns);
1914 std::rotate (vi, vi + ku, vi + ns); 1914 std::rotate (vi, vi + ku, vi + ns);
1915 } 1915 }
1916 } 1916 }
1917 1917
1918 v += ns; 1918 v += ns;
1919 vi += ns; 1919 vi += ns;
1920 ov += ns; 1920 ov += ns;
1921 } 1921 }
1922 } 1922 }
1923 else 1923 else
1924 { 1924 {
1925 OCTAVE_LOCAL_BUFFER (T, buf, ns); 1925 OCTAVE_LOCAL_BUFFER (T, buf, ns);
1926 OCTAVE_LOCAL_BUFFER (octave_idx_type, bufi, ns); 1926 OCTAVE_LOCAL_BUFFER (octave_idx_type, bufi, ns);
1927 1927
1928 for (octave_idx_type j = 0; j < iter; j++) 1928 for (octave_idx_type j = 0; j < iter; j++)
1929 { 1929 {
1930 octave_idx_type offset = j; 1930 octave_idx_type offset = j;
1931 octave_idx_type offset2 = 0; 1931 octave_idx_type offset2 = 0;
1932 1932
1933 while (offset >= stride) 1933 while (offset >= stride)
1934 { 1934 {
1935 offset -= stride; 1935 offset -= stride;
1936 offset2++; 1936 offset2++;
1937 } 1937 }
1938 1938
1939 offset += offset2 * stride * ns; 1939 offset += offset2 * stride * ns;
1940 1940
1941 // gather and partition out NaNs. 1941 // gather and partition out NaNs.
1942 // FIXME: impact on integer types noticeable? 1942 // FIXME: impact on integer types noticeable?
1943 octave_idx_type kl = 0, ku = ns; 1943 octave_idx_type kl = 0, ku = ns;
1944 for (octave_idx_type i = 0; i < ns; i++) 1944 for (octave_idx_type i = 0; i < ns; i++)
1945 { 1945 {
1957 kl++; 1957 kl++;
1958 } 1958 }
1959 } 1959 }
1960 1960
1961 // sort. 1961 // sort.
1962 lsort.sort (buf, bufi, kl); 1962 lsort.sort (buf, bufi, kl);
1963 1963
1964 if (ku < ns) 1964 if (ku < ns)
1965 { 1965 {
1966 // NaNs are in reverse order 1966 // NaNs are in reverse order
1967 std::reverse (buf + ku, buf + ns); 1967 std::reverse (buf + ku, buf + ns);
1972 std::rotate (bufi, bufi + ku, bufi + ns); 1972 std::rotate (bufi, bufi + ku, bufi + ns);
1973 } 1973 }
1974 } 1974 }
1975 1975
1976 // scatter. 1976 // scatter.
1977 for (octave_idx_type i = 0; i < ns; i++) 1977 for (octave_idx_type i = 0; i < ns; i++)
1978 v[i*stride + offset] = buf[i]; 1978 v[i*stride + offset] = buf[i];
1979 for (octave_idx_type i = 0; i < ns; i++) 1979 for (octave_idx_type i = 0; i < ns; i++)
1980 vi[i*stride + offset] = bufi[i]; 1980 vi[i*stride + offset] = bufi[i];
1981 } 1981 }
1982 } 1982 }
1983 1983
1984 return m; 1984 return m;
1985 } 1985 }
1986 1986
2010 2010
2011 if (! mode) 2011 if (! mode)
2012 { 2012 {
2013 // Auto-detect mode. 2013 // Auto-detect mode.
2014 compare_fcn_type compare 2014 compare_fcn_type compare
2015 = safe_comparator (ASCENDING, *this, false); 2015 = safe_comparator (ASCENDING, *this, false);
2016 2016
2017 if (compare (elem (n-1), elem (0))) 2017 if (compare (elem (n-1), elem (0)))
2018 mode = DESCENDING; 2018 mode = DESCENDING;
2019 else 2019 else
2020 mode = ASCENDING; 2020 mode = ASCENDING;
2063 2063
2064 if (! mode) 2064 if (! mode)
2065 { 2065 {
2066 // Auto-detect mode. 2066 // Auto-detect mode.
2067 compare_fcn_type compare 2067 compare_fcn_type compare
2068 = safe_comparator (ASCENDING, *this, false); 2068 = safe_comparator (ASCENDING, *this, false);
2069 2069
2070 octave_idx_type i; 2070 octave_idx_type i;
2071 for (i = 0; i < cols (); i++) 2071 for (i = 0; i < cols (); i++)
2072 { 2072 {
2073 T l = elem (0, i), u = elem (rows () - 1, i); 2073 T l = elem (0, i), u = elem (rows () - 1, i);
2476 { 2476 {
2477 octave_idx_type nnr = dv (0); 2477 octave_idx_type nnr = dv (0);
2478 octave_idx_type nnc = dv (1); 2478 octave_idx_type nnc = dv (1);
2479 2479
2480 if (nnr == 0 || nnc == 0) 2480 if (nnr == 0 || nnc == 0)
2481 ; // do nothing 2481 ; // do nothing
2482 else if (nnr != 1 && nnc != 1) 2482 else if (nnr != 1 && nnc != 1)
2483 { 2483 {
2484 if (k > 0) 2484 if (k > 0)
2485 nnc -= k; 2485 nnc -= k;
2486 else if (k < 0) 2486 else if (k < 0)
2487 nnr += k; 2487 nnr += k;
2488 2488
2489 if (nnr > 0 && nnc > 0) 2489 if (nnr > 0 && nnc > 0)
2490 { 2490 {
2491 octave_idx_type ndiag = (nnr < nnc) ? nnr : nnc; 2491 octave_idx_type ndiag = (nnr < nnc) ? nnr : nnc;
2492 2492
2493 d.resize (dim_vector (ndiag, 1)); 2493 d.resize (dim_vector (ndiag, 1));
2494 2494
2495 if (k > 0) 2495 if (k > 0)
2496 { 2496 {
2497 for (octave_idx_type i = 0; i < ndiag; i++) 2497 for (octave_idx_type i = 0; i < ndiag; i++)
2498 d.xelem (i) = elem (i, i+k); 2498 d.xelem (i) = elem (i, i+k);
2499 } 2499 }
2500 else if (k < 0) 2500 else if (k < 0)
2501 { 2501 {
2502 for (octave_idx_type i = 0; i < ndiag; i++) 2502 for (octave_idx_type i = 0; i < ndiag; i++)
2503 d.xelem (i) = elem (i-k, i); 2503 d.xelem (i) = elem (i-k, i);
2504 } 2504 }
2505 else 2505 else
2506 { 2506 {
2507 for (octave_idx_type i = 0; i < ndiag; i++) 2507 for (octave_idx_type i = 0; i < ndiag; i++)
2508 d.xelem (i) = elem (i, i); 2508 d.xelem (i) = elem (i, i);
2509 } 2509 }
2510 } 2510 }
2511 else 2511 else
2512 (*current_liboctave_error_handler) 2512 (*current_liboctave_error_handler)
2513 ("diag: requested diagonal out of range"); 2513 ("diag: requested diagonal out of range");
2514 } 2514 }
2515 else if (nnr != 0 && nnc != 0) 2515 else if (nnr != 0 && nnc != 0)
2516 { 2516 {
2517 octave_idx_type roff = 0; 2517 octave_idx_type roff = 0;
2518 octave_idx_type coff = 0; 2518 octave_idx_type coff = 0;
2519 if (k > 0) 2519 if (k > 0)
2520 { 2520 {
2521 roff = 0; 2521 roff = 0;
2522 coff = k; 2522 coff = k;
2523 } 2523 }
2524 else if (k < 0) 2524 else if (k < 0)
2525 { 2525 {
2526 roff = -k; 2526 roff = -k;
2527 coff = 0; 2527 coff = 0;
2528 } 2528 }
2529 2529
2530 if (nnr == 1) 2530 if (nnr == 1)
2531 { 2531 {
2532 octave_idx_type n = nnc + std::abs (k); 2532 octave_idx_type n = nnc + std::abs (k);
2533 d = Array<T> (dim_vector (n, n), resize_fill_value ()); 2533 d = Array<T> (dim_vector (n, n), resize_fill_value ());
2534 2534
2535 for (octave_idx_type i = 0; i < nnc; i++) 2535 for (octave_idx_type i = 0; i < nnc; i++)
2536 d.xelem (i+roff, i+coff) = elem (0, i); 2536 d.xelem (i+roff, i+coff) = elem (0, i);
2537 } 2537 }
2538 else 2538 else
2539 { 2539 {
2540 octave_idx_type n = nnr + std::abs (k); 2540 octave_idx_type n = nnr + std::abs (k);
2541 d = Array<T> (dim_vector (n, n), resize_fill_value ()); 2541 d = Array<T> (dim_vector (n, n), resize_fill_value ());
2542 2542
2543 for (octave_idx_type i = 0; i < nnr; i++) 2543 for (octave_idx_type i = 0; i < nnr; i++)
2544 d.xelem (i+roff, i+coff) = elem (i, 0); 2544 d.xelem (i+roff, i+coff) = elem (i, 0);
2545 } 2545 }
2546 } 2546 }
2547 } 2547 }
2548 2548
2549 return d; 2549 return d;
2550 } 2550 }
2551 2551
2603 2603
2604 // Number of times the first 2d-array is to be displayed. 2604 // Number of times the first 2d-array is to be displayed.
2605 2605
2606 octave_idx_type m = 1; 2606 octave_idx_type m = 1;
2607 for (int i = 2; i < n_dims; i++) 2607 for (int i = 2; i < n_dims; i++)
2608 m *= a_dims(i); 2608 m *= a_dims(i);
2609 2609
2610 if (m == 1) 2610 if (m == 1)
2611 { 2611 {
2612 octave_idx_type rows = 0; 2612 octave_idx_type rows = 0;
2613 octave_idx_type cols = 0; 2613 octave_idx_type cols = 0;
2614 2614
2615 switch (n_dims) 2615 switch (n_dims)
2616 { 2616 {
2617 case 2: 2617 case 2:
2618 rows = a_dims(0); 2618 rows = a_dims(0);
2619 cols = a_dims(1); 2619 cols = a_dims(1);
2620 2620
2621 for (octave_idx_type j = 0; j < rows; j++) 2621 for (octave_idx_type j = 0; j < rows; j++)
2622 { 2622 {
2623 ra_idx(0) = j; 2623 ra_idx(0) = j;
2624 for (octave_idx_type k = 0; k < cols; k++) 2624 for (octave_idx_type k = 0; k < cols; k++)
2625 { 2625 {
2626 ra_idx(1) = k; 2626 ra_idx(1) = k;
2627 os << " " << a.elem(ra_idx); 2627 os << " " << a.elem(ra_idx);
2628 } 2628 }
2629 os << "\n"; 2629 os << "\n";
2630 } 2630 }
2631 break; 2631 break;
2632 2632
2633 default: 2633 default:
2634 rows = a_dims(0); 2634 rows = a_dims(0);
2635 2635
2636 for (octave_idx_type k = 0; k < rows; k++) 2636 for (octave_idx_type k = 0; k < rows; k++)
2637 { 2637 {
2638 ra_idx(0) = k; 2638 ra_idx(0) = k;
2639 os << " " << a.elem(ra_idx); 2639 os << " " << a.elem(ra_idx);
2640 } 2640 }
2641 break; 2641 break;
2642 } 2642 }
2643 2643
2644 os << "\n"; 2644 os << "\n";
2645 } 2645 }
2646 else 2646 else
2647 { 2647 {
2651 for (int i = 0; i < m; i++) 2651 for (int i = 0; i < m; i++)
2652 { 2652 {
2653 os << "\n(:,:,"; 2653 os << "\n(:,:,";
2654 2654
2655 for (int j = 2; j < n_dims - 1; j++) 2655 for (int j = 2; j < n_dims - 1; j++)
2656 os << ra_idx(j) + 1 << ","; 2656 os << ra_idx(j) + 1 << ",";
2657 2657
2658 os << ra_idx(n_dims - 1) + 1 << ") = \n"; 2658 os << ra_idx(n_dims - 1) + 1 << ") = \n";
2659 2659
2660 for (octave_idx_type j = 0; j < rows; j++) 2660 for (octave_idx_type j = 0; j < rows; j++)
2661 { 2661 {
2662 ra_idx(0) = j; 2662 ra_idx(0) = j;
2663 2663
2664 for (octave_idx_type k = 0; k < cols; k++) 2664 for (octave_idx_type k = 0; k < cols; k++)
2665 { 2665 {
2666 ra_idx(1) = k; 2666 ra_idx(1) = k;
2667 os << " " << a.elem(ra_idx); 2667 os << " " << a.elem(ra_idx);
2668 } 2668 }
2669 2669
2670 os << "\n"; 2670 os << "\n";
2671 } 2671 }
2672 2672
2673 os << "\n"; 2673 os << "\n";
2674 2674
2675 if (i != m - 1) 2675 if (i != m - 1)
2676 increment_index (ra_idx, a_dims, 2); 2676 increment_index (ra_idx, a_dims, 2);
2677 } 2677 }
2678 } 2678 }
2679 } 2679 }
2680 2680
2681 return os; 2681 return os;