*** liboctave/Array.cc.orig	2004-04-20 15:42:33.000000000 +0200
--- liboctave/Array.cc	2004-04-21 01:02:39.000000000 +0200
***************
*** 560,567 ****
    if (same_size)
      return;
  
-   int old_len = length ();
- 
    typename Array<T>::ArrayRep *old_rep = rep;
    const T *old_data = data ();
  
--- 560,565 ----
***************
*** 569,584 ****
  
    rep = new typename Array<T>::ArrayRep (ts);
  
    dimensions = dv;
  
!   if (ts > 0)
      {
        Array<int> ra_idx (dimensions.length (), 0);
  
!       for (int i = 0; i < old_len; i++)
  	{
! 	  if (index_in_bounds (ra_idx, dimensions))
! 	    xelem (ra_idx) = old_data[i];
  
  	  increment_index (ra_idx, dimensions);
  	}
--- 567,592 ----
  
    rep = new typename Array<T>::ArrayRep (ts);
  
+   dim_vector dv_old = dimensions;
+   int dv_old_orig_len = dv_old.length ();
    dimensions = dv;
  
!   if (ts > 0 && dv_old_orig_len > 0)
      {
        Array<int> ra_idx (dimensions.length (), 0);
  
!       if (n > dv_old_orig_len)
! 	{
! 	  dv_old.resize (n);
! 
! 	  for (int i = dv_old_orig_len; i < n; i++)
! 	    dv_old.elem (i) = 1;
! 	}
! 
!       for (int i = 0; i < ts; i++)
  	{
! 	  if (index_in_bounds (ra_idx, dv_old))
! 	    rep->elem (i) = old_data[get_scalar_idx (ra_idx, dv_old)];
  
  	  increment_index (ra_idx, dimensions);
  	}
***************
*** 894,940 ****
    typename Array<T>::ArrayRep *old_rep = rep;
    const T *old_data = data ();
  
-   int old_len = length ();
- 
    int len = get_size (dv);
  
    rep = new typename Array<T>::ArrayRep (len);
  
    dim_vector dv_old = dimensions;
- 
    int dv_old_orig_len = dv_old.length ();
- 
-   if (n > dv_old_orig_len)
-     {
-       dv_old.resize (n);
- 
-       for (int i = dv_old_orig_len; i < n; i++)
- 	dv_old.elem (i) = 1;
-     }
- 
    dimensions = dv;
  
!   if (len > 0)
      {
        Array<int> ra_idx (dimensions.length (), 0);
  
!       // XXX FIXME XXX -- it is much simpler to fill the whole array
!       // first, but probably slower for large arrays, or if the assignment
!       // operator for the type T is expensive.  OTOH, the logic for
!       // deciding whether an element needs the copied value or the filled
!       // value might be more expensive.
  
        for (int i = 0; i < len; i++)
- 	rep->elem (i) = val;
- 
-       for (int i = 0; i < old_len; i++)
  	{
  	  if (index_in_bounds (ra_idx, dv_old))
! 	    xelem (ra_idx) = old_data[get_scalar_idx (ra_idx, dv_old)];
! 
! 	  increment_index (ra_idx, dv_old);
  	}
      }
  
    if (--old_rep->count <= 0)
      delete old_rep;
--- 902,940 ----
    typename Array<T>::ArrayRep *old_rep = rep;
    const T *old_data = data ();
  
    int len = get_size (dv);
  
    rep = new typename Array<T>::ArrayRep (len);
  
    dim_vector dv_old = dimensions;
    int dv_old_orig_len = dv_old.length ();
    dimensions = dv;
  
!   if (len > 0 && dv_old_orig_len > 0)
      {
        Array<int> ra_idx (dimensions.length (), 0);
+       
+       if (n > dv_old_orig_len)
+ 	{
+ 	  dv_old.resize (n);
  
! 	  for (int i = dv_old_orig_len; i < n; i++)
! 	    dv_old.elem (i) = 1;
! 	}
  
        for (int i = 0; i < len; i++)
  	{
  	  if (index_in_bounds (ra_idx, dv_old))
! 	    rep->elem (i) = old_data[get_scalar_idx (ra_idx, dv_old)];
! 	  else
! 	    rep->elem (i) = val;
! 	  
! 	  increment_index (ra_idx, dimensions);
  	}
      }
+   else
+     for (int i = 0; i < len; i++)
+       rep->elem (i) = val;
  
    if (--old_rep->count <= 0)
      delete old_rep;