Mercurial > octave-nkf
changeset 9780:6dafc60dde31
rename oct-mem functions
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Thu, 05 Nov 2009 21:13:31 +0100 |
| parents | 2941c1daf509 |
| children | ea88eece12f5 |
| files | liboctave/Array.cc liboctave/Array.h liboctave/ChangeLog liboctave/idx-vector.cc liboctave/idx-vector.h liboctave/oct-mem.h |
| diffstat | 6 files changed, 60 insertions(+), 44 deletions(-) [+] |
line wrap: on
line diff
--- a/liboctave/Array.cc Tue Nov 03 16:22:46 2009 -0500 +++ b/liboctave/Array.cc Thu Nov 05 21:13:31 2009 +0100 @@ -77,7 +77,7 @@ slice_data = rep->data; } else - octave_fill (slice_len, val, slice_data); + fill_or_memset (slice_len, val, slice_data); } template <class T> @@ -569,7 +569,7 @@ octave_idx_type step = stride[0], len = dim[0]; if (step == 1) { - octave_ucopy (len, src, dest); + copy_or_memcpy (len, src, dest); dest += len; } else @@ -832,8 +832,8 @@ { if (lev == 0) { - octave_ucopy (cext[0], src, dest); - octave_fill (dext[0] - cext[0], rfv, dest + cext[0]); + copy_or_memcpy (cext[0], src, dest); + fill_or_memset (dext[0] - cext[0], rfv, dest + cext[0]); } else { @@ -841,7 +841,7 @@ for (k = 0; k < cext[lev]; k++) do_resize_fill (src + k * sd, dest + k * dd, rfv, lev - 1); - octave_fill (dext[lev] - k * dd, rfv, dest + k * dd); + fill_or_memset (dext[lev] - k * dd, rfv, dest + k * dd); } } public: @@ -1117,7 +1117,7 @@ Array<T> tmp (Array<T> (nn), dv, 0, n); T *dest = tmp.fortran_vec (); - octave_ucopy (nx, data (), dest); + copy_or_memcpy (nx, data (), dest); dest[nx] = rfv; *this = tmp; @@ -1129,8 +1129,8 @@ T *dest = tmp.fortran_vec (); octave_idx_type n0 = std::min (n, nx), n1 = n - n0; - octave_ucopy (n0, data (), dest); - octave_fill (n1, rfv, dest + n0); + copy_or_memcpy (n0, data (), dest); + fill_or_memset (n1, rfv, dest + n0); *this = tmp; } @@ -1157,22 +1157,22 @@ const T *src = data (); if (r == rx) { - octave_ucopy (r * c0, src, dest); + copy_or_memcpy (r * c0, src, dest); dest += r * c0; } else { for (octave_idx_type k = 0; k < c0; k++) { - octave_ucopy (r0, src, dest); + copy_or_memcpy (r0, src, dest); src += rx; dest += r0; - octave_fill (r1, rfv, dest); + fill_or_memset (r1, rfv, dest); dest += r1; } } - octave_fill (r * c1, rfv, dest); + fill_or_memset (r * c1, rfv, dest); *this = tmp; } @@ -1557,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 (); - octave_ucopy (l, src, dest); - octave_ucopy (n - u, src + u, dest + l); + copy_or_memcpy (l, src, dest); + copy_or_memcpy (n - u, src + u, dest + l); *this = tmp; } else @@ -1609,9 +1609,9 @@ l *= dl; u *= dl; n *= dl; for (octave_idx_type k = 0; k < du; k++) { - octave_ucopy (l, src, dest); + copy_or_memcpy (l, src, dest); dest += l; - octave_ucopy (n - u, src + u, dest); + copy_or_memcpy (n - u, src + u, dest); dest += n - u; src += n; }
--- a/liboctave/Array.h Tue Nov 03 16:22:46 2009 -0500 +++ b/liboctave/Array.h Thu Nov 05 21:13:31 2009 +0100 @@ -62,29 +62,29 @@ int count; ArrayRep (T *d, octave_idx_type l, bool copy = false) - : data (copy ? octave_new<T> (l) : d), len (l), count (1) + : data (copy ? no_ctor_new<T> (l) : d), len (l), count (1) { if (copy) - octave_ucopy (l, d, data); + copy_or_memcpy (l, d, data); } ArrayRep (void) : data (0), len (0), count (1) { } - explicit ArrayRep (octave_idx_type n) : data (octave_new<T> (n)), len (n), count (1) { } + explicit ArrayRep (octave_idx_type n) : data (no_ctor_new<T> (n)), len (n), count (1) { } explicit ArrayRep (octave_idx_type n, const T& val) - : data (octave_new<T> (n)), len (n), count (1) + : data (no_ctor_new<T> (n)), len (n), count (1) { - octave_fill (n, val, data); + fill_or_memset (n, val, data); } ArrayRep (const ArrayRep& a) - : data (octave_new<T> (a.len)), len (a.len), count (1) + : data (no_ctor_new<T> (a.len)), len (a.len), count (1) { - octave_ucopy (a.len, a.data, data); + copy_or_memcpy (a.len, a.data, data); } - ~ArrayRep (void) { octave_delete<T> (data); } + ~ArrayRep (void) { no_ctor_delete<T> (data); } octave_idx_type length (void) const { return len; } @@ -169,7 +169,7 @@ T * coerce (const U *a, octave_idx_type len) { - T *retval = octave_new<T> (len); + T *retval = no_ctor_new<T> (len); for (octave_idx_type i = 0; i < len; i++) retval[i] = T (a[i]);
--- a/liboctave/ChangeLog Tue Nov 03 16:22:46 2009 -0500 +++ b/liboctave/ChangeLog Thu Nov 05 21:13:31 2009 +0100 @@ -1,3 +1,13 @@ +2009-11-03 Jaroslav Hajek <highegg@gmail.com> + + * oct-mem.h: Rename octave_ucopy -> copy_or_memcpy, + octave_fill -> fill_or_memset, octave_new -> no_ctor_new, + octave_delete -> no_ctor_delete. + * Array.h: Update. + * Array.cc: Update. + * idx-vector.h: Update. + * idx-vector.cc: Update. + 2009-11-03 Jaroslav Hajek <highegg@gmail.com> * oct-mem.h: New source.
--- a/liboctave/idx-vector.cc Tue Nov 03 16:22:46 2009 -0500 +++ b/liboctave/idx-vector.cc Thu Nov 05 21:13:31 2009 +0100 @@ -636,7 +636,7 @@ { idx_vector_rep * r = dynamic_cast<idx_vector_rep *> (rep); const octave_idx_type *rdata = r->get_data (); - octave_ucopy (len, rdata, data); + copy_or_memcpy (len, rdata, data); } break; default:
--- a/liboctave/idx-vector.h Tue Nov 03 16:22:46 2009 -0500 +++ b/liboctave/idx-vector.h Thu Nov 05 21:13:31 2009 +0100 @@ -518,7 +518,7 @@ switch (rep->idx_class ()) { case class_colon: - octave_ucopy (len, src, dest); + copy_or_memcpy (len, src, dest); break; case class_range: { @@ -526,7 +526,7 @@ octave_idx_type start = r->get_start (), step = r->get_step (); const T *ssrc = src + start; if (step == 1) - octave_ucopy (len, ssrc, dest); + copy_or_memcpy (len, ssrc, dest); else if (step == -1) std::reverse_copy (ssrc - len + 1, ssrc + 1, dest); else if (step == 0) @@ -576,7 +576,7 @@ switch (rep->idx_class ()) { case class_colon: - octave_ucopy (len, src, dest); + copy_or_memcpy (len, src, dest); break; case class_range: { @@ -584,7 +584,7 @@ octave_idx_type start = r->get_start (), step = r->get_step (); T *sdest = dest + start; if (step == 1) - octave_ucopy (len, src, sdest); + copy_or_memcpy (len, src, sdest); else if (step == -1) std::reverse_copy (src, src + len, sdest - len + 1); else
--- a/liboctave/oct-mem.h Tue Nov 03 16:22:46 2009 -0500 +++ b/liboctave/oct-mem.h Thu Nov 05 21:13:31 2009 +0100 @@ -39,11 +39,11 @@ // Unaliased copy. This boils down to memcpy, even for octave_int and complex types. template <class T> -inline void octave_ucopy (octave_idx_type n, const T *src, T *dest) +inline void copy_or_memcpy (octave_idx_type n, const T *src, T *dest) { std::copy (src, src + n, dest); } #define DEFINE_POD_UCOPY(T) \ -inline void octave_ucopy (octave_idx_type n, const T *src, T *dest) \ +inline void copy_or_memcpy (octave_idx_type n, const T *src, T *dest) \ { std::memcpy (dest, src, n * sizeof (T)); } DEFINE_POD_UCOPY (double) @@ -66,25 +66,31 @@ // Fill by value, with a check for zero. This boils down to memset if value is // a POD zero. template <class T> -inline void octave_fill (octave_idx_type n, const T& value, T *dest) +inline void fill_or_memset (octave_idx_type n, const T& value, T *dest) { std::fill_n (dest, n, value); } template <class T> -inline bool octave_fill_iszero (const T& value) -{ return value == T(); } +inline bool helper_is_zero_mem (const T& value) +{ + typedef typename query_integer_type<sizeof (T), false>::type IT; // get integer type of the same size. + return *(reinterpret_cast<const IT *>(&value)) == 0; +} template <class T> -inline bool octave_fill_iszero (const std::complex<T>& value) -{ return value.real () == T() && value.imag () == T(); } +inline bool helper_is_zero_mem (const std::complex<T>& value) +{ + return (helper_is_zero_mem (value.real ()) + && helper_is_zero_mem (value.imag ())); +} template <class T> -inline bool octave_fill_iszero (const octave_int<T>& value) +inline bool helper_is_zero_mem (const octave_int<T>& value) { return value.value () == T(); } #define DEFINE_POD_FILL(T) \ -inline void octave_fill (octave_idx_type n, const T& value, T *dest) \ +inline void fill_or_memset (octave_idx_type n, const T& value, T *dest) \ { \ - if (octave_fill_iszero (value)) \ + if (helper_is_zero_mem (value)) \ std::memset (dest, 0, n * sizeof (T)); \ else \ std::fill_n (dest, n, value); \ @@ -110,18 +116,18 @@ // Uninitialized allocation. Will not initialize memory for complex and octave_int. // Memory allocated by octave_new should be freed by octave_delete. template <class T> -inline T *octave_new (octave_idx_type n) +inline T *no_ctor_new (octave_idx_type n) { return new T[n]; } template <class T> -inline void octave_delete (T *ptr) +inline void no_ctor_delete (T *ptr) { delete [] ptr; } #define DEFINE_POD_NEW_DELETE(T) \ template <> \ -inline T *octave_new<T > (octave_idx_type n) \ +inline T *no_ctor_new<T > (octave_idx_type n) \ { return reinterpret_cast<T *> (new char[n * sizeof (T)]); } \ template <> \ -inline void octave_delete<T > (T *ptr) \ +inline void no_ctor_delete<T > (T *ptr) \ { delete [] reinterpret_cast<char *> (ptr); } DEFINE_POD_NEW_DELETE (Complex)