Mercurial > hg > octave-nkf

comparison liboctave/MArray.h @ 1989:a4b0826e240c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1996-03-02 00:33:22 by jwe]
author jwe
date Sat, 02 Mar 1996 00:34:12 +0000
parents 1281a23a34dd
children 5668c00f9c7a
comparison
equal deleted inserted replaced
1988:7b56630a1e05 1989:a4b0826e240c
28 #if !defined (octave_MArray_h) 28 #if !defined (octave_MArray_h)
29 #define octave_MArray_h 1 29 #define octave_MArray_h 1
30 30
31 #include "Array.h" 31 #include "Array.h"
32 32
33 // Classes we declare.
34
35 template <class T> class MArray;
36 template <class T> class MArray2;
37
38 #ifndef NO_DIAG_ARRAY
39 template <class T> class MDiagArray;
40 #endif
41
42 // One dimensional array with math ops. 33 // One dimensional array with math ops.
43 34
44 template <class T> 35 template <class T>
45 class MArray : public Array<T> 36 class MArray : public Array<T>
46 { 37 {
51 public: 42 public:
52 43
53 MArray (void) : Array<T> () { } 44 MArray (void) : Array<T> () { }
54 MArray (int n) : Array<T> (n) { } 45 MArray (int n) : Array<T> (n) { }
55 MArray (int n, const T& val) : Array<T> (n, val) { } 46 MArray (int n, const T& val) : Array<T> (n, val) { }
56 MArray (const Array<T>& a) : Array<T> (a) { } 47 // MArray (const Array<T>& a) : Array<T> (a) { }
57 MArray (const MArray<T>& a) : Array<T> (a) { } 48 MArray (const MArray<T>& a) : Array<T> (a) { }
58 49
59 ~MArray (void) { } 50 ~MArray (void) { }
60 51
61 MArray<T>& operator = (const MArray<T>& a) 52 MArray<T>& operator = (const MArray<T>& a)
98 friend MArray<T> quotient (const MArray<T>& a, const MArray<T>& b); 89 friend MArray<T> quotient (const MArray<T>& a, const MArray<T>& b);
99 90
100 friend MArray<T> operator - (const MArray<T>& a); 91 friend MArray<T> operator - (const MArray<T>& a);
101 }; 92 };
102 93
103 // Two dimensional array with math ops. 94 #define INSTANTIATE_MARRAY_FRIENDS(T) \
104 95 template MArray<T> operator + (const MArray<T>& a, const T& s); \
105 template <class T> 96 template MArray<T> operator - (const MArray<T>& a, const T& s); \
106 class MArray2 : public Array2<T> 97 template MArray<T> operator * (const MArray<T>& a, const T& s); \
107 { 98 template MArray<T> operator / (const MArray<T>& a, const T& s); \
108 protected: 99 template MArray<T> operator + (const T& s, const MArray<T>& a); \
109 100 template MArray<T> operator - (const T& s, const MArray<T>& a); \
110 MArray2 (T *d, int n, int m) : Array2<T> (d, n, m) { } 101 template MArray<T> operator * (const T& s, const MArray<T>& a); \
111 102 template MArray<T> operator / (const T& s, const MArray<T>& a); \
112 public: 103 template MArray<T> operator + (const MArray<T>& a, const MArray<T>& b); \
113 104 template MArray<T> operator - (const MArray<T>& a, const MArray<T>& b); \
114 MArray2 (void) : Array2<T> () { } 105 template MArray<T> product (const MArray<T>& a, const MArray<T>& b); \
115 MArray2 (int n, int m) : Array2<T> (n, m) { } 106 template MArray<T> quotient (const MArray<T>& a, const MArray<T>& b); \
116 MArray2 (int n, int m, const T& val) : Array2<T> (n, m, val) { } 107 template MArray<T> operator - (const MArray<T>& a);
117 MArray2 (const Array2<T>& a) : Array2<T> (a) { }
118 MArray2 (const MArray2<T>& a) : Array2<T> (a) { }
119
120 #ifndef NO_DIAG_ARRAY
121 MArray2 (const MDiagArray<T>& a);
122 #endif
123
124 ~MArray2 (void) { }
125
126 MArray2<T>& operator = (const MArray2<T>& a)
127 {
128 Array2<T>::operator = (a);
129 return *this;
130 }
131
132 // element by element MArray2 by scalar ops
133
134 friend MArray2<T>& operator += (MArray2<T>& a, const T& s);
135 friend MArray2<T>& operator -= (MArray2<T>& a, const T& s);
136
137 // element by element MArray2 by MArray2 ops
138
139 friend MArray2<T>& operator += (MArray2<T>& a, const MArray2<T>& b);
140 friend MArray2<T>& operator -= (MArray2<T>& a, const MArray2<T>& b);
141
142 // element by element MArray2 by scalar ops
143
144 friend MArray2<T> operator + (const MArray2<T>& a, const T& s);
145 friend MArray2<T> operator - (const MArray2<T>& a, const T& s);
146 friend MArray2<T> operator * (const MArray2<T>& a, const T& s);
147 friend MArray2<T> operator / (const MArray2<T>& a, const T& s);
148
149 // element by element scalar by MArray2 ops
150
151 friend MArray2<T> operator + (const T& s, const MArray2<T>& a);
152 friend MArray2<T> operator - (const T& s, const MArray2<T>& a);
153 friend MArray2<T> operator * (const T& s, const MArray2<T>& a);
154 friend MArray2<T> operator / (const T& s, const MArray2<T>& a);
155
156 // element by element MArray2 by MArray2 ops
157
158 friend MArray2<T> operator + (const MArray2<T>& a, const MArray2<T>& b);
159 friend MArray2<T> operator - (const MArray2<T>& a, const MArray2<T>& b);
160
161 friend MArray2<T> product (const MArray2<T>& a, const MArray2<T>& b);
162 friend MArray2<T> quotient (const MArray2<T>& a, const MArray2<T>& b);
163
164 friend MArray2<T> operator - (const MArray2<T>& a);
165 };
166
167 // Two dimensional diagonal array with math ops.
168
169 #ifndef NO_DIAG_ARRAY
170 template <class T>
171 class MDiagArray : public DiagArray<T>
172 {
173 protected:
174
175 MDiagArray (T *d, int r, int c) : DiagArray<T> (d, r, c) { }
176
177 public:
178
179 MDiagArray (void) : DiagArray<T> () { }
180 MDiagArray (int n) : DiagArray<T> (n) { }
181 // MDiagArray (int n, const T& val) : DiagArray<T> (n, val) { }
182 MDiagArray (int r, int c) : DiagArray<T> (r, c) { }
183 MDiagArray (int r, int c, const T& val) : DiagArray<T> (r, c, val) { }
184 MDiagArray (const DiagArray<T>& a) : DiagArray<T> (a) { }
185 MDiagArray (const MDiagArray<T>& a) : DiagArray<T> (a) { }
186 MDiagArray (const MArray<T>& a) : DiagArray<T> (a) { }
187
188 ~MDiagArray (void) { }
189
190 MDiagArray<T>& operator = (const MDiagArray<T>& a)
191 {
192 DiagArray<T>::operator = (a);
193 return *this;
194 }
195
196 // element by element MDiagArray by MDiagArray ops
197
198 friend MDiagArray<T>& operator += (MDiagArray<T>& a, const MDiagArray<T>& b);
199 friend MDiagArray<T>& operator -= (MDiagArray<T>& a, const MDiagArray<T>& b);
200
201 // element by element MDiagArray by scalar ops
202
203 friend MDiagArray<T> operator * (const MDiagArray<T>& a, const T& s);
204 friend MDiagArray<T> operator / (const MDiagArray<T>& a, const T& s);
205
206 // element by element scalar by MDiagArray ops
207
208 friend MDiagArray<T> operator * (const T& s, const MDiagArray<T>& a);
209
210 // element by element MDiagArray by MDiagArray ops
211
212 friend MDiagArray<T> operator + (const MDiagArray<T>& a,
213 const MDiagArray<T>& b);
214
215 friend MDiagArray<T> operator - (const MDiagArray<T>& a,
216 const MDiagArray<T>& b);
217
218 friend MDiagArray<T> product (const MDiagArray<T>& a,
219 const MDiagArray<T>& b);
220
221 friend MDiagArray<T> operator - (const MDiagArray<T>& a);
222 };
223 #endif
224 108
225 #endif 109 #endif
226 110
227 /* 111 /*
228 ;;; Local Variables: *** 112 ;;; Local Variables: ***