GNU Octave 7.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
MArray.h
Go to the documentation of this file.
1////////////////////////////////////////////////////////////////////////
2//
3// Copyright (C) 1993-2022 The Octave Project Developers
4//
5// See the file COPYRIGHT.md in the top-level directory of this
6// distribution or <https://octave.org/copyright/>.
7//
8// This file is part of Octave.
9//
10// Octave is free software: you can redistribute it and/or modify it
11// under the terms of the GNU General Public License as published by
12// the Free Software Foundation, either version 3 of the License, or
13// (at your option) any later version.
14//
15// Octave is distributed in the hope that it will be useful, but
16// WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18// GNU General Public License for more details.
19//
20// You should have received a copy of the GNU General Public License
21// along with Octave; see the file COPYING. If not, see
22// <https://www.gnu.org/licenses/>.
23//
24////////////////////////////////////////////////////////////////////////
25
26#if ! defined (octave_MArray_h)
27#define octave_MArray_h 1
28
29#include "octave-config.h"
30
31#include "Array.h"
32#include "MArray-fwd.h"
33#include "mx-inlines.cc"
34
35template <typename T> OCTARRAY_API MArray<T>& operator += (MArray<T>&, const T&);
36template <typename T> OCTARRAY_API MArray<T>& operator -= (MArray<T>&, const T&);
37template <typename T> OCTARRAY_API MArray<T>& operator *= (MArray<T>&, const T&);
38template <typename T> OCTARRAY_API MArray<T>& operator /= (MArray<T>&, const T&);
39template <typename T> OCTARRAY_API MArray<T>& operator += (MArray<T>&, const MArray<T>&);
40template <typename T> OCTARRAY_API MArray<T>& operator -= (MArray<T>&, const MArray<T>&);
41template <typename T> OCTARRAY_API MArray<T>& product_eq (MArray<T>&, const MArray<T>&);
42template <typename T> OCTARRAY_API MArray<T>& quotient_eq (MArray<T>&, const MArray<T>&);
43template <typename T> OCTARRAY_API MArray<T> operator + (const MArray<T>&);
44template <typename T> OCTARRAY_API MArray<T> operator - (const MArray<T>&);
45template <typename T> OCTARRAY_API MArray<T> operator + (const MArray<T>&, const T&);
46template <typename T> OCTARRAY_API MArray<T> operator - (const MArray<T>&, const T&);
47template <typename T> OCTARRAY_API MArray<T> operator * (const MArray<T>&, const T&);
48template <typename T> OCTARRAY_API MArray<T> operator / (const MArray<T>&, const T&);
49template <typename T> OCTARRAY_API MArray<T> operator + (const T&, const MArray<T>&);
50template <typename T> OCTARRAY_API MArray<T> operator - (const T&, const MArray<T>&);
51template <typename T> OCTARRAY_API MArray<T> operator * (const T&, const MArray<T>&);
52template <typename T> OCTARRAY_API MArray<T> operator / (const T&, const MArray<T>&);
53template <typename T> OCTARRAY_API MArray<T> operator + (const MArray<T>&, const MArray<T>&);
54template <typename T> OCTARRAY_API MArray<T> operator - (const MArray<T>&, const MArray<T>&);
55template <typename T> OCTARRAY_API MArray<T> quotient (const MArray<T>&, const MArray<T>&);
56template <typename T> OCTARRAY_API MArray<T> product (const MArray<T>&, const MArray<T>&);
57
58//! Template for N-dimensional array classes with like-type math operators.
59template <typename T>
60class
61OCTARRAY_API
62MArray : public Array<T>
63{
64public:
65
66 MArray (void) : Array<T> () { }
67
68 explicit MArray (const dim_vector& dv)
69 : Array<T> (dv) { }
70
71 explicit MArray (const dim_vector& dv, const T& val)
72 : Array<T> (dv, val) { }
73
74 MArray (const MArray<T>& a) : Array<T> (a) { }
75
76 template <typename U>
77 MArray (const Array<U>& a) : Array<T> (a) { }
78
79 ~MArray (void) = default;
80
81 MArray<T>& operator = (const MArray<T>& a)
82 {
83 Array<T>::operator = (a);
84 return *this;
85 }
86
87 MArray<T> reshape (const dim_vector& new_dims) const
88 { return Array<T>::reshape (new_dims); }
89
90 MArray<T> permute (const Array<octave_idx_type>& vec,
91 bool inv = false) const
92 { return Array<T>::permute (vec, inv); }
93
94 MArray<T> ipermute (const Array<octave_idx_type>& vec) const
95 { return Array<T>::ipermute (vec); }
96
97 MArray squeeze (void) const { return Array<T>::squeeze (); }
98
99 MArray<T> transpose (void) const
100 { return Array<T>::transpose (); }
101
102 MArray<T> hermitian (T (*fcn) (const T&) = nullptr) const
103 { return Array<T>::hermitian (fcn); }
104
105 //! Performs indexed accumulative addition.
106 //@{
107 OCTARRAY_API void idx_add (const octave::idx_vector& idx, T val);
108 OCTARRAY_API void
109 idx_add (const octave::idx_vector& idx, const MArray<T>& vals);
110 //@}
111
112 OCTARRAY_API void
113 idx_min (const octave::idx_vector& idx, const MArray<T>& vals);
114
115 OCTARRAY_API void
116 idx_max (const octave::idx_vector& idx, const MArray<T>& vals);
117
118 OCTARRAY_API void
119 idx_add_nd (const octave::idx_vector& idx, const MArray<T>& vals,
120 int dim = -1);
121
122 OCTARRAY_API void changesign (void);
123
124private:
125 OCTARRAY_API static void instantiation_guard ();
126};
127
128// Define all the MArray forwarding functions for return type R and
129// MArray element type T
130#define MARRAY_FORWARD_DEFS(B, R, T) \
131 inline R operator += (R& x, const T& y) \
132 { \
133 return R (operator += (dynamic_cast<B<T>&> (x), (y))); \
134 } \
135 inline R operator -= (R& x, const T& y) \
136 { \
137 return R (operator -= (dynamic_cast<B<T>&> (x), (y))); \
138 } \
139 inline R operator *= (R& x, const T& y) \
140 { \
141 return R (operator *= (dynamic_cast<B<T>&> (x), (y))); \
142 } \
143 inline R operator /= (R& x, const T& y) \
144 { \
145 return R (operator /= (dynamic_cast<B<T>&> (x), (y))); \
146 } \
147 inline R operator += (R& x, const R& y) \
148 { \
149 return R (operator += (dynamic_cast<B<T>&> (x), \
150 dynamic_cast<const B<T>&> (y))); \
151 } \
152 inline R operator -= (R& x, const R& y) \
153 { \
154 return R (operator -= (dynamic_cast<B<T>&> (x), \
155 dynamic_cast<const B<T>&> (y))); \
156 } \
157 inline R product_eq (R& x, const R& y) \
158 { \
159 return R (product_eq (dynamic_cast<B<T>&> (x), \
160 dynamic_cast<const B<T>&> (y))); \
161 } \
162 inline R quotient_eq (R& x, const R& y) \
163 { \
164 return R (quotient_eq (dynamic_cast<B<T>&> (x), \
165 dynamic_cast<const B<T>&> (y))); \
166 } \
167 inline R operator + (const R& x) \
168 { \
169 return R (operator + (dynamic_cast<const B<T>&> (x))); \
170 } \
171 inline R operator - (const R& x) \
172 { \
173 return R (operator - (dynamic_cast<const B<T>&> (x))); \
174 } \
175 inline R operator + (const R& x, const T& y) \
176 { \
177 return R (operator + (dynamic_cast<const B<T>&> (x), (y))); \
178 } \
179 inline R operator - (const R& x, const T& y) \
180 { \
181 return R (operator - (dynamic_cast<const B<T>&> (x), (y))); \
182 } \
183 inline R operator * (const R& x, const T& y) \
184 { \
185 return R (operator * (dynamic_cast<const B<T>&> (x), (y))); \
186 } \
187 inline R operator / (const R& x, const T& y) \
188 { \
189 return R (operator / (dynamic_cast<const B<T>&> (x), (y))); \
190 } \
191 inline R operator + (const T& x, const R& y) \
192 { \
193 return R (operator + ( (x), dynamic_cast<const B<T>&> (y))); \
194 } \
195 inline R operator - (const T& x, const R& y) \
196 { \
197 return R (operator - ( (x), dynamic_cast<const B<T>&> (y))); \
198 } \
199 inline R operator * (const T& x, const R& y) \
200 { \
201 return R (operator * ( (x), dynamic_cast<const B<T>&> (y))); \
202 } \
203 inline R operator / (const T& x, const R& y) \
204 { \
205 return R (operator / ( (x), dynamic_cast<const B<T>&> (y))); \
206 } \
207 inline R operator + (const R& x, const R& y) \
208 { \
209 return R (operator + (dynamic_cast<const B<T>&> (x), \
210 dynamic_cast<const B<T>&> (y))); \
211 } \
212 inline R operator - (const R& x, const R& y) \
213 { \
214 return R (operator - (dynamic_cast<const B<T>&> (x), \
215 dynamic_cast<const B<T>&> (y))); \
216 } \
217 inline R product (const R& x, const R& y) \
218 { \
219 return R (product (dynamic_cast<const B<T>&> (x), \
220 dynamic_cast<const B<T>&> (y))); \
221 } \
222 inline R quotient (const R& x, const R& y) \
223 { \
224 return R (quotient (dynamic_cast<const B<T>&> (x), \
225 dynamic_cast<const B<T>&> (y))); \
226 }
227
228// Instantiate all the MArray friends for MArray element type T.
229#define INSTANTIATE_MARRAY_FRIENDS(T, API) \
230 template API MArray<T>& operator += (MArray<T>&, const T&); \
231 template API MArray<T>& operator -= (MArray<T>&, const T&); \
232 template API MArray<T>& operator *= (MArray<T>&, const T&); \
233 template API MArray<T>& operator /= (MArray<T>&, const T&); \
234 template API MArray<T>& operator += (MArray<T>&, const MArray<T>&); \
235 template API MArray<T>& operator -= (MArray<T>&, const MArray<T>&); \
236 template API MArray<T>& product_eq (MArray<T>&, const MArray<T>&); \
237 template API MArray<T>& quotient_eq (MArray<T>&, const MArray<T>&); \
238 template API MArray<T> operator + (const MArray<T>&); \
239 template API MArray<T> operator - (const MArray<T>&); \
240 template API MArray<T> operator + (const MArray<T>&, const T&); \
241 template API MArray<T> operator - (const MArray<T>&, const T&); \
242 template API MArray<T> operator * (const MArray<T>&, const T&); \
243 template API MArray<T> operator / (const MArray<T>&, const T&); \
244 template API MArray<T> operator + (const T&, const MArray<T>&); \
245 template API MArray<T> operator - (const T&, const MArray<T>&); \
246 template API MArray<T> operator * (const T&, const MArray<T>&); \
247 template API MArray<T> operator / (const T&, const MArray<T>&); \
248 template API MArray<T> operator + (const MArray<T>&, const MArray<T>&); \
249 template API MArray<T> operator - (const MArray<T>&, const MArray<T>&); \
250 template API MArray<T> quotient (const MArray<T>&, const MArray<T>&); \
251 template API MArray<T> product (const MArray<T>&, const MArray<T>&);
252
253// Instantiate all the MDiagArray2 friends for MDiagArray2 element type T.
254#define INSTANTIATE_MDIAGARRAY2_FRIENDS(T, API) \
255 template API MDiagArray2<T> operator + (const MDiagArray2<T>&); \
256 template API MDiagArray2<T> operator - (const MDiagArray2<T>&); \
257 template API MDiagArray2<T> operator * (const MDiagArray2<T>&, const T&); \
258 template API MDiagArray2<T> operator / (const MDiagArray2<T>&, const T&); \
259 template API MDiagArray2<T> operator * (const T&, const MDiagArray2<T>&); \
260 template API MDiagArray2<T> operator + (const MDiagArray2<T>&, \
261 const MDiagArray2<T>&); \
262 template API MDiagArray2<T> operator - (const MDiagArray2<T>&, \
263 const MDiagArray2<T>&); \
264 template API MDiagArray2<T> product (const MDiagArray2<T>&, \
265 const MDiagArray2<T>&);
266
267#endif
MArray
class OCTARRAY_API MArray
Definition: MArray-fwd.h:31
operator+=
OCTARRAY_API MArray< T > & operator+=(MArray< T > &, const T &)
Definition: MArray.cc:228
quotient
OCTARRAY_API MArray< T > quotient(const MArray< T > &, const MArray< T > &)
Definition: MArray.cc:359
product_eq
OCTARRAY_API MArray< T > & product_eq(MArray< T > &, const MArray< T > &)
Definition: MArray.cc:296
operator-
OCTARRAY_API MArray< T > operator-(const MArray< T > &)
Definition: MArray.cc:370
operator+
OCTARRAY_API MArray< T > operator+(const MArray< T > &)
Definition: MArray.cc:363
operator*
OCTARRAY_API MArray< T > operator*(const MArray< T > &, const T &)
Definition: MArray.cc:328
operator*=
OCTARRAY_API MArray< T > & operator*=(MArray< T > &, const T &)
Definition: MArray.cc:250
quotient_eq
OCTARRAY_API MArray< T > & quotient_eq(MArray< T > &, const MArray< T > &)
Definition: MArray.cc:307
product
OCTARRAY_API MArray< T > product(const MArray< T > &, const MArray< T > &)
Definition: MArray.cc:358
operator-=
OCTARRAY_API MArray< T > & operator-=(MArray< T > &, const T &)
Definition: MArray.cc:239
operator/=
OCTARRAY_API MArray< T > & operator/=(MArray< T > &, const T &)
Definition: MArray.cc:261
operator/
OCTARRAY_API MArray< T > operator/(const MArray< T > &, const T &)
Definition: MArray.cc:329
Array::transpose
OCTARRAY_API Array< T, Alloc > transpose(void) const
Size of the specified dimension.
Definition: Array.cc:1603
Array::squeeze
OCTARRAY_API Array< T, Alloc > squeeze(void) const
Chop off leading singleton dimensions.
Definition: Array.cc:117
Array::ipermute
Array< T, Alloc > ipermute(const Array< octave_idx_type > &vec) const
Size of the specified dimension.
Definition: Array.h:602
Array::operator=
Array< T, Alloc > & operator=(const Array< T, Alloc > &a)
Definition: Array.h:359
Array::hermitian
OCTARRAY_API Array< T, Alloc > hermitian(T(*fcn)(const T &)=nullptr) const
Size of the specified dimension.
Definition: Array.cc:1646
Array::permute
OCTARRAY_API Array< T, Alloc > permute(const Array< octave_idx_type > &vec, bool inv=false) const
Size of the specified dimension.
Definition: Array.cc:431
Array::reshape
Array< T, Alloc > reshape(octave_idx_type nr, octave_idx_type nc) const
Size of the specified dimension.
Definition: Array.h:595
MArray
Template for N-dimensional array classes with like-type math operators.
Definition: MArray.h:63
MArray::permute
MArray< T > permute(const Array< octave_idx_type > &vec, bool inv=false) const
Definition: MArray.h:90
MArray::~MArray
~MArray(void)=default
MArray::hermitian
MArray< T > hermitian(T(*fcn)(const T &)=nullptr) const
Definition: MArray.h:102
MArray::MArray
MArray(const Array< U > &a)
Definition: MArray.h:77
MArray::reshape
MArray< T > reshape(const dim_vector &new_dims) const
Definition: MArray.h:87
MArray::squeeze
MArray squeeze(void) const
Definition: MArray.h:97
MArray::MArray
MArray(const dim_vector &dv, const T &val)
Definition: MArray.h:71
MArray::ipermute
MArray< T > ipermute(const Array< octave_idx_type > &vec) const
Definition: MArray.h:94
MArray::transpose
MArray< T > transpose(void) const
Definition: MArray.h:99
MArray::MArray
MArray(const MArray< T > &a)
Definition: MArray.h:74
MArray::MArray
MArray(void)
Definition: MArray.h:66
MArray::MArray
MArray(const dim_vector &dv)
Definition: MArray.h:68
dim_vector
Vector representing the dimensions (size) of an Array.
Definition: dim-vector.h:94
octave::idx_vector
Definition: idx-vector.h:60
idx_max
static const octave_idx_type idx_max
Definition: dlmread.cc:51