Patch for ArrayN.cc (operator <<)

[Heine Kolltveit]

This code is just for improved output readability. Even better output
(using pr-output.cc) and more functionality for multidimensional arrays is
coming soon.

Heine Kolltveit


*** octave/liboctave/ArrayN.cc  Tue Jul 29 15:07:34 2003
--- ../ver1/liboctave/ArrayN.cc Tue Jul 29 15:07:25 2003
*************** increment_index (Array<int>& ra_idx, con
*** 199,204 ****
--- 226,251 ----
      }
  }

+
+ static inline void
+ increment_index (Array<int>& ra_idx, const Array<int>& dimensions, int
start_dimension)
+ {
+   ra_idx(start_dimension)++;
+
+   int n = ra_idx.length () - 1;
+
+   for (int i = start_dimension; i < n; i++)
+     {
+       if (ra_idx(i) < dimensions(i))
+       break;
+       else
+       {
+         ra_idx(i) = 0;
+         ra_idx(i+1)++;
+       }
+     }
+ }
+
  template <class T>
  void
  ArrayN<T>::resize (const Array<int>& dims)
*************** template <class T>
*** 354,378 ****
  std::ostream&
  operator << (std::ostream& os, const ArrayN<T>& a)
  {
!   Array<int> dims = a.dimensions;

!   int n_dims = dims.length ();

!   os << n_dims << "-dimensional array (";

!   for (int i = 0; i < n_dims - 1; i++)
!     os << dims(i) << "x";
!   os << dims(n_dims-1) << ")\n\n";

!   os << "data:\n";

-   int n = ArrayN<T>::get_size (dims);

-   //  for (int i = 0; i < n; i++)
-   //    os << a.elem (i) << "\n";

-   return os;
- }

  /*
  ;;; Local Variables: ***
--- 448,556 ----
  std::ostream&
  operator << (std::ostream& os, const ArrayN<T>& a)
  {
!   Array<int> a_dims = a.dimensions;

!   int n_dims = a_dims.length ();

!   os << n_dims << "-dimensional array";

!   if (n_dims)
!     {
!       os << " (";
!       for (int i = 0; i < n_dims - 1; i++)
!         {
!           os << a_dims(i) << "x";
!         }
!       os << a_dims(n_dims-1) << ")";
!     }
!   os <<"\n\n";
!   if (n_dims)
!     {
!       os << "data:";
!
!       Array<int> ra_idx (n_dims,0);
!
!
!       int m = 1; //Number of times the first 2d-array is to be displayed.
!       for(int i = 2; i < n_dims; i++)
!         {
!           m *= a_dims(i);
!         }
!
!       if (m == 1)
!         {
!           int rows = 0;
!           int cols = 0;
!           switch (n_dims)
!             {
!             case 2:  // 2-dimensional
!                 rows = a_dims(0);
!                 cols = a_dims(1);
!               for (int j = 0; j < rows; j++)
!                 {
!                   ra_idx(0) = j;
!                   for (int k = 0; k < cols; k++)
!                     {
!                       ra_idx(1) = k;
!                       os << " " << a.elem(ra_idx);
!                     }
!                   os << "\n";
!                 }
!               break;
!             case 1:  // 1-dimensional
!               rows = a_dims(0);
!               for (int k = 0; k < rows; k++)
!                 {
!                   ra_idx(0) = k;
!                   os << " " << a.elem(ra_idx);
!                 }
!               break;
!             default:
!               (*current_liboctave_error_handler)
!                 ("std::operator <<: problems with dimensions (= 0)!");
!           }
!           os << "\n";
!         }
!       else
!         {
!           int rows = a_dims(0);
!           int cols = a_dims(1);
!
!           for (int i = 0; i < m; i++)
!             {
!               os << "\n(:,:,";
!
!               for (int j = 2; j < n_dims - 1; j++)
!                 {
!                 os << ra_idx(j) + 1 << ",";
!               }
!             os << ra_idx(n_dims - 1) + 1 << ") = \n";
!
!             for (int j = 0; j < rows; j++)
!               {
!                 ra_idx(0) = j;
!                 for (int k = 0; k < cols; k++)
!                   {
!                     ra_idx(1) = k;
!                     os << " " << a.elem(ra_idx);
!                   }
!                 os << "\n";
!               }
!             os << "\n";
!
!
!             //Calculate next index
!             if (i != m - 1) //Last repetition. No need to calculate next 
index.
!               {
!                 increment_index(ra_idx, a_dims, 2);
!               }
!             }
!         }
!     }

!   return os;
! }


  /*
  ;;; Local Variables: ***



*** octave-cvs/octave/liboctave/ChangeLog       Tue Jul 29 11:57:25 2003
--- ChangeLog   Tue Jul 29 12:50:46 2003
***************
*** 1,3 ****
--- 1,8 ----
+ 2003-07-29  Heine Kolltveit <address@hidden>
+
+       * ArrayN.cc (operator <<): Increased output readability.
+       (increment_index(Array<int>&, Array<int>&, int)) new.

  2003-07-25  John W. Eaton  <address@hidden>

        * lo-mappers.cc (xmin, xmax): Handle NaN in a Matlab-compatible