# HG changeset patch
# User Jaroslav Hajek <highegg@gmail.com>
# Date 1257244559 -3600
# Node ID 01f897d8a1300740569505f2b40954ae58f36727
# Parent  3ac8ea48279b5ba6a2ba121d971c68bddc9df60a
optimize memory manipulation by arrays & indexing

diff --git a/liboctave/Array.cc b/liboctave/Array.cc
--- a/liboctave/Array.cc
+++ b/liboctave/Array.cc
@@ -77,7 +77,7 @@
       slice_data = rep->data;
     }
   else
-    std::fill (slice_data, slice_data + slice_len, val);
+    octave_fill (slice_len, val, slice_data);
 }
 
 template <class T>
@@ -568,7 +568,10 @@
         {
           octave_idx_type step = stride[0], len = dim[0];
           if (step == 1)
-            dest = std::copy (src, src + len, dest);
+            {
+              octave_ucopy (len, src, dest);
+              dest += len;
+            }
           else
             {
               for (octave_idx_type i = 0, j = 0; i < len; i++, j += step)
@@ -829,8 +832,8 @@
     {
       if (lev == 0)
         {
-          T* destc = std::copy (src, src + cext[0], dest);
-          std::fill (destc, dest + dext[0], rfv);
+          octave_ucopy (cext[0], src, dest);
+          octave_fill (dext[0] - cext[0], rfv, dest + cext[0]);
         }
       else
         {
@@ -838,7 +841,7 @@
           for (k = 0; k < cext[lev]; k++)
             do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1);
 
-          std::fill (dest + k * dd, dest + dext[lev], rfv);
+          octave_fill (dext[lev] - k * dd, rfv, dest + k * dd);
         }
     }
 public:
@@ -1114,7 +1117,7 @@
                   Array<T> tmp (Array<T> (nn), dv, 0, n);
                   T *dest = tmp.fortran_vec ();
 
-                  std::copy (data (), data () + nx, dest);
+                  octave_ucopy (nx, data (), dest);
                   dest[nx] = rfv;
 
                   *this = tmp;
@@ -1126,8 +1129,8 @@
               T *dest = tmp.fortran_vec ();
 
               octave_idx_type n0 = std::min (n, nx), n1 = n - n0;
-              dest = std::copy (data (), data () + n0, dest);
-              std::fill (dest, dest + n1, rfv);
+              octave_ucopy (n0, data (), dest);
+              octave_fill (n1, rfv, dest + n0);
 
               *this = tmp;
             }
@@ -1153,19 +1156,23 @@
           octave_idx_type c0 = std::min (c, cx), c1 = c - c0;
           const T *src = data ();
           if (r == rx)
-            dest = std::copy (src, src + r * c0, dest);
+            {
+              octave_ucopy (r * c0, src, dest);
+              dest += r * c0;
+            }
           else
             {
               for (octave_idx_type k = 0; k < c0; k++)
                 {
-                  dest = std::copy (src, src + r0, dest);
+                  octave_ucopy (r0, src, dest);
                   src += rx;
-                  std::fill (dest, dest + r1, rfv);
+                  dest += r0;
+                  octave_fill (r1, rfv, dest);
                   dest += r1;
                 }
             }
 
-          std::fill (dest, dest + r * c1, rfv);
+          octave_fill (r * c1, rfv, dest);
 
           *this = tmp;
         }
@@ -1550,8 +1557,8 @@
           Array<T> tmp (dim_vector (col_vec ? m : 1, !col_vec ? m : 1));
           const T *src = data ();
           T *dest = tmp.fortran_vec ();
-          dest = std::copy (src, src + l, dest);
-          dest = std::copy (src + u, src + n, dest);
+          octave_ucopy (l, src, dest);
+          octave_ucopy (n - u, src + u, dest + l);
           *this = tmp;
         }
       else
@@ -1602,8 +1609,10 @@
           l *= dl; u *= dl; n *= dl;
           for (octave_idx_type k = 0; k < du; k++)
             {
-              dest = std::copy (src, src + l, dest);
-              dest = std::copy (src + u, src + n, dest);
+              octave_ucopy (l, src, dest);
+              dest += l;
+              octave_ucopy (n - u, src + u, dest);
+              dest += n - u;
               src += n;
             }
 
diff --git a/liboctave/Array.h b/liboctave/Array.h
--- a/liboctave/Array.h
+++ b/liboctave/Array.h
@@ -38,6 +38,7 @@
 #include "lo-utils.h"
 #include "oct-sort.h"
 #include "quit.h"
+#include "oct-mem.h"
 
 // One dimensional array class.  Handles the reference counting for
 // all the derived classes.
@@ -61,29 +62,29 @@
     int count;
 
     ArrayRep (T *d, octave_idx_type l, bool copy = false) 
-      : data (copy ? new T [l] : d), len (l), count (1) 
+      : data (copy ? octave_new<T> (l) : d), len (l), count (1) 
         { 
           if (copy)
-            std::copy (d, d + l, data);
+            octave_ucopy (l, d, data);
         }
 
     ArrayRep (void) : data (0), len (0), count (1) { }
 
-    explicit ArrayRep (octave_idx_type n) : data (new T [n]), len (n), count (1) { }
+    explicit ArrayRep (octave_idx_type n) : data (octave_new<T> (n)), len (n), count (1) { }
 
     explicit ArrayRep (octave_idx_type n, const T& val)
-      : data (new T [n]), len (n), count (1)
+      : data (octave_new<T> (n)), len (n), count (1)
       {
-        std::fill (data, data + n, val);
+        octave_fill (n, val, data);
       }
 
     ArrayRep (const ArrayRep& a)
-      : data (new T [a.len]), len (a.len), count (1)
+      : data (octave_new<T> (a.len)), len (a.len), count (1)
       {
-        std::copy (a.data, a.data + a.len, data);
+        octave_ucopy (a.len, a.data, data);
       }
  
-    ~ArrayRep (void) { delete [] data; }
+    ~ArrayRep (void) { octave_delete<T> (data); }
 
     octave_idx_type length (void) const { return len; }
 
@@ -168,7 +169,7 @@
   T *
   coerce (const U *a, octave_idx_type len)
   {
-    T *retval = new T [len];
+    T *retval = octave_new<T> (len);
 
     for (octave_idx_type i = 0; i < len; i++)
       retval[i] = T (a[i]);
@@ -733,12 +734,12 @@
     { return ArrayClass::xelem (ra_idx); }
 };
 
-#endif
-
 template <class T>
 std::ostream&
 operator << (std::ostream& os, const Array<T>& a);
 
+#endif
+
 /*
 ;;; Local Variables: ***
 ;;; mode: C++ ***
diff --git a/liboctave/ChangeLog b/liboctave/ChangeLog
--- a/liboctave/ChangeLog
+++ b/liboctave/ChangeLog
@@ -1,3 +1,18 @@
+2009-11-03  Jaroslav Hajek  <highegg@gmail.com>
+
+	* oct-mem.h: New source.
+	* Makefile.in: Include it.
+	* Array.h (Array<T>::ArrayRep::ArrayRep (...)): Use octave_new,
+	octave_ucopy and octave_fill.
+	(Array<T>::ArrayRep::~ArrayRep): Use octave_delete.
+	(Array<T>::coerce): Use octave_new.
+	* Array.cc (Array<T>::fill, rec_resize_helper::do_resize_fill,
+	Array<T>::resize_fill, rec_permute_helper::do_permute,
+	Array<T>::delete_elements): Use octave_ucopy and octave_fill.
+	* idx-vector.h (index_vector::index, index_vector::assign): Use
+	octave_ucopy.
+	* idx-vector.cc (index_vector::copy_data): Ditto.
+
 2009-11-03  Jaroslav Hajek  <highegg@gmail.com>
 
 	* idx-vector.cc (idx_vector::maybe_reduce): Implement (i:k:end, :)
diff --git a/liboctave/Makefile.in b/liboctave/Makefile.in
--- a/liboctave/Makefile.in
+++ b/liboctave/Makefile.in
@@ -96,7 +96,7 @@
 	lo-ieee.h lo-mappers.h lo-math.h lo-specfun.h lo-sysdep.h \
 	lo-traits.h lo-utils.h mach-info.h md5.h oct-alloc.h oct-cmplx.h \
 	oct-env.h oct-fftw.h oct-getopt.h oct-group.h oct-inttypes.h \
-	oct-locbuf.h oct-md5.h oct-mutex.h oct-norm.h \
+	oct-locbuf.h oct-md5.h oct-mem.h oct-mutex.h oct-norm.h \
         oct-passwd.h oct-rand.h oct-rl-edit.h oct-rl-hist.h oct-shlib.h \
         oct-sort.h oct-spparms.h oct-syscalls.h oct-sparse.h oct-time.h \
         oct-uname.h pathlen.h pathsearch.h prog-args.h \
diff --git a/liboctave/idx-vector.cc b/liboctave/idx-vector.cc
--- a/liboctave/idx-vector.cc
+++ b/liboctave/idx-vector.cc
@@ -636,7 +636,7 @@
         {
           idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep);
           const octave_idx_type *rdata = r->get_data ();
-          std::copy (rdata, rdata + len, data);
+          octave_ucopy (len, rdata, data);
         }
       break;
     default:
diff --git a/liboctave/idx-vector.h b/liboctave/idx-vector.h
--- a/liboctave/idx-vector.h
+++ b/liboctave/idx-vector.h
@@ -34,6 +34,7 @@
 #include "dim-vector.h"
 #include "oct-inttypes.h"
 #include "oct-alloc.h"
+#include "oct-mem.h"
 
 template<class T> class Array;
 template<class T> class Sparse;
@@ -517,7 +518,7 @@
       switch (rep->idx_class ())
         {
         case class_colon:
-          std::copy (src, src + len, dest);
+          octave_ucopy (len, src, dest);
           break;
         case class_range:
           {
@@ -525,7 +526,7 @@
             octave_idx_type start = r->get_start (), step = r->get_step ();
             const T *ssrc = src + start;
             if (step == 1)
-              std::copy (ssrc, ssrc + len, dest);
+              octave_ucopy (len, ssrc, dest);
             else if (step == -1)
               std::reverse_copy (ssrc - len + 1, ssrc + 1, dest);
             else if (step == 0)
@@ -575,7 +576,7 @@
       switch (rep->idx_class ())
         {
         case class_colon:
-          std::copy (src, src + len, dest);
+          octave_ucopy (len, src, dest);
           break;
         case class_range:
           {
@@ -583,7 +584,7 @@
             octave_idx_type start = r->get_start (), step = r->get_step ();
             T *sdest = dest + start;
             if (step == 1)
-              std::copy (src, src + len, sdest);
+              octave_ucopy (len, src, sdest);
             else if (step == -1)
               std::reverse_copy (src, src + len, sdest - len + 1);
             else