Mercurial > hg > octave-lyh

comparison liboctave/Array.h @ 9773:01f897d8a130

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
optimize memory manipulation by arrays & indexing
author Jaroslav Hajek <highegg@gmail.com>
date Tue, 03 Nov 2009 11:35:59 +0100
parents b4fdfee405b5
children 6dafc60dde31
comparison
equal deleted inserted replaced
9772:3ac8ea48279b 9773:01f897d8a130
36 #include "idx-vector.h" 36 #include "idx-vector.h"
37 #include "lo-traits.h" 37 #include "lo-traits.h"
38 #include "lo-utils.h" 38 #include "lo-utils.h"
39 #include "oct-sort.h" 39 #include "oct-sort.h"
40 #include "quit.h" 40 #include "quit.h"
41 #include "oct-mem.h"
41 42
42 // One dimensional array class. Handles the reference counting for 43 // One dimensional array class. Handles the reference counting for
43 // all the derived classes. 44 // all the derived classes.
44 45
45 template <class T> 46 template <class T>
59 T *data; 60 T *data;
60 octave_idx_type len; 61 octave_idx_type len;
61 int count; 62 int count;
62 63
63 ArrayRep (T *d, octave_idx_type l, bool copy = false) 64 ArrayRep (T *d, octave_idx_type l, bool copy = false)
64 : data (copy ? new T [l] : d), len (l), count (1) 65 : data (copy ? octave_new<T> (l) : d), len (l), count (1)
65 { 66 {
66 if (copy) 67 if (copy)
67 std::copy (d, d + l, data); 68 octave_ucopy (l, d, data);
68 } 69 }
69 70
70 ArrayRep (void) : data (0), len (0), count (1) { } 71 ArrayRep (void) : data (0), len (0), count (1) { }
71 72
72 explicit ArrayRep (octave_idx_type n) : data (new T [n]), len (n), count (1) { } 73 explicit ArrayRep (octave_idx_type n) : data (octave_new<T> (n)), len (n), count (1) { }
73 74
74 explicit ArrayRep (octave_idx_type n, const T& val) 75 explicit ArrayRep (octave_idx_type n, const T& val)
75 : data (new T [n]), len (n), count (1) 76 : data (octave_new<T> (n)), len (n), count (1)
76 { 77 {
77 std::fill (data, data + n, val); 78 octave_fill (n, val, data);
78 } 79 }
79 80
80 ArrayRep (const ArrayRep& a) 81 ArrayRep (const ArrayRep& a)
81 : data (new T [a.len]), len (a.len), count (1) 82 : data (octave_new<T> (a.len)), len (a.len), count (1)
82 { 83 {
83 std::copy (a.data, a.data + a.len, data); 84 octave_ucopy (a.len, a.data, data);
84 } 85 }
85 86
86 ~ArrayRep (void) { delete [] data; } 87 ~ArrayRep (void) { octave_delete<T> (data); }
87 88
88 octave_idx_type length (void) const { return len; } 89 octave_idx_type length (void) const { return len; }
89 90
90 private: 91 private:
91 92
166 167
167 template <class U> 168 template <class U>
168 T * 169 T *
169 coerce (const U *a, octave_idx_type len) 170 coerce (const U *a, octave_idx_type len)
170 { 171 {
171 T *retval = new T [len]; 172 T *retval = octave_new<T> (len);
172 173
173 for (octave_idx_type i = 0; i < len; i++) 174 for (octave_idx_type i = 0; i < len; i++)
174 retval[i] = T (a[i]); 175 retval[i] = T (a[i]);
175 176
176 return retval; 177 return retval;
731 { return ArrayClass::xelem (i, j, k); } 732 { return ArrayClass::xelem (i, j, k); }
732 T& operator () (const Array<octave_idx_type>& ra_idx) 733 T& operator () (const Array<octave_idx_type>& ra_idx)
733 { return ArrayClass::xelem (ra_idx); } 734 { return ArrayClass::xelem (ra_idx); }
734 }; 735 };
735 736
736 #endif
737
738 template <class T> 737 template <class T>
739 std::ostream& 738 std::ostream&
740 operator << (std::ostream& os, const Array<T>& a); 739 operator << (std::ostream& os, const Array<T>& a);
740
741 #endif
741 742
742 /* 743 /*
743 ;;; Local Variables: *** 744 ;;; Local Variables: ***
744 ;;; mode: C++ *** 745 ;;; mode: C++ ***
745 ;;; End: *** 746 ;;; End: ***