Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #ifndef EIGEN_ARRAYBASE_H
00026 #define EIGEN_ARRAYBASE_H
00027
00028 template<typename ExpressionType> class MatrixWrapper;
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049 template<typename Derived> class ArrayBase
00050 : public DenseBase<Derived>
00051 {
00052 public:
00053 #ifndef EIGEN_PARSED_BY_DOXYGEN
00054
00055 typedef ArrayBase StorageBaseType;
00056
00057 typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl;
00058
00059 using internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar,
00060 typename NumTraits<typename internal::traits<Derived>::Scalar>::Real>::operator*;
00061
00062 typedef typename internal::traits<Derived>::StorageKind StorageKind;
00063 typedef typename internal::traits<Derived>::Index Index;
00064 typedef typename internal::traits<Derived>::Scalar Scalar;
00065 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
00066 typedef typename NumTraits<Scalar>::Real RealScalar;
00067
00068 typedef DenseBase<Derived> Base;
00069 using Base::RowsAtCompileTime;
00070 using Base::ColsAtCompileTime;
00071 using Base::SizeAtCompileTime;
00072 using Base::MaxRowsAtCompileTime;
00073 using Base::MaxColsAtCompileTime;
00074 using Base::MaxSizeAtCompileTime;
00075 using Base::IsVectorAtCompileTime;
00076 using Base::Flags;
00077 using Base::CoeffReadCost;
00078
00079 using Base::derived;
00080 using Base::const_cast_derived;
00081 using Base::rows;
00082 using Base::cols;
00083 using Base::size;
00084 using Base::coeff;
00085 using Base::coeffRef;
00086 using Base::lazyAssign;
00087 using Base::operator=;
00088 using Base::operator+=;
00089 using Base::operator-=;
00090 using Base::operator*=;
00091 using Base::operator/=;
00092
00093 typedef typename Base::CoeffReturnType CoeffReturnType;
00094
00095 #endif // not EIGEN_PARSED_BY_DOXYGEN
00096
00097 #ifndef EIGEN_PARSED_BY_DOXYGEN
00098
00099
00100
00101
00102
00103 typedef Array<typename internal::traits<Derived>::Scalar,
00104 internal::traits<Derived>::RowsAtCompileTime,
00105 internal::traits<Derived>::ColsAtCompileTime,
00106 AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
00107 internal::traits<Derived>::MaxRowsAtCompileTime,
00108 internal::traits<Derived>::MaxColsAtCompileTime
00109 > PlainObject;
00110
00111
00112
00113 typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType;
00114 #endif // not EIGEN_PARSED_BY_DOXYGEN
00115
00116 #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase
00117 # include "../plugins/CommonCwiseUnaryOps.h"
00118 # include "../plugins/MatrixCwiseUnaryOps.h"
00119 # include "../plugins/ArrayCwiseUnaryOps.h"
00120 # include "../plugins/CommonCwiseBinaryOps.h"
00121 # include "../plugins/MatrixCwiseBinaryOps.h"
00122 # include "../plugins/ArrayCwiseBinaryOps.h"
00123 # ifdef EIGEN_ARRAYBASE_PLUGIN
00124 # include EIGEN_ARRAYBASE_PLUGIN
00125 # endif
00126 #undef EIGEN_CURRENT_STORAGE_BASE_CLASS
00127
00128
00129
00130
00131 Derived& operator=(const ArrayBase& other)
00132 {
00133 return internal::assign_selector<Derived,Derived>::run(derived(), other.derived());
00134 }
00135
00136 Derived& operator+=(const Scalar& scalar)
00137 { return *this = derived() + scalar; }
00138 Derived& operator-=(const Scalar& scalar)
00139 { return *this = derived() - scalar; }
00140
00141 template<typename OtherDerived>
00142 Derived& operator+=(const ArrayBase<OtherDerived>& other);
00143 template<typename OtherDerived>
00144 Derived& operator-=(const ArrayBase<OtherDerived>& other);
00145
00146 template<typename OtherDerived>
00147 Derived& operator*=(const ArrayBase<OtherDerived>& other);
00148
00149 template<typename OtherDerived>
00150 Derived& operator/=(const ArrayBase<OtherDerived>& other);
00151
00152 public:
00153 ArrayBase<Derived>& array() { return *this; }
00154 const ArrayBase<Derived>& array() const { return *this; }
00155
00156
00157
00158 MatrixWrapper<Derived> matrix() { return derived(); }
00159 const MatrixWrapper<Derived> matrix() const { return derived(); }
00160
00161
00162
00163
00164 protected:
00165 ArrayBase() : Base() {}
00166
00167 private:
00168 explicit ArrayBase(Index);
00169 ArrayBase(Index,Index);
00170 template<typename OtherDerived> explicit ArrayBase(const ArrayBase<OtherDerived>&);
00171 protected:
00172
00173 template<typename OtherDerived> Derived& operator+=(const MatrixBase<OtherDerived>& mat)
00174 {EIGEN_STATIC_ASSERT(sizeof(typename OtherDerived::Scalar)==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES);}
00175
00176 template<typename OtherDerived> Derived& operator-=(const MatrixBase<OtherDerived>& mat)
00177 {EIGEN_STATIC_ASSERT(sizeof(typename OtherDerived::Scalar)==-1,YOU_CANNOT_MIX_ARRAYS_AND_MATRICES);}
00178 };
00179
00180
00181
00182
00183
00184 template<typename Derived>
00185 template<typename OtherDerived>
00186 EIGEN_STRONG_INLINE Derived &
00187 ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other)
00188 {
00189 SelfCwiseBinaryOp<internal::scalar_difference_op<Scalar>, Derived, OtherDerived> tmp(derived());
00190 tmp = other.derived();
00191 return derived();
00192 }
00193
00194
00195
00196
00197
00198 template<typename Derived>
00199 template<typename OtherDerived>
00200 EIGEN_STRONG_INLINE Derived &
00201 ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other)
00202 {
00203 SelfCwiseBinaryOp<internal::scalar_sum_op<Scalar>, Derived, OtherDerived> tmp(derived());
00204 tmp = other.derived();
00205 return derived();
00206 }
00207
00208
00209
00210
00211
00212 template<typename Derived>
00213 template<typename OtherDerived>
00214 EIGEN_STRONG_INLINE Derived &
00215 ArrayBase<Derived>::operator*=(const ArrayBase<OtherDerived>& other)
00216 {
00217 SelfCwiseBinaryOp<internal::scalar_product_op<Scalar>, Derived, OtherDerived> tmp(derived());
00218 tmp = other.derived();
00219 return derived();
00220 }
00221
00222
00223
00224
00225
00226 template<typename Derived>
00227 template<typename OtherDerived>
00228 EIGEN_STRONG_INLINE Derived &
00229 ArrayBase<Derived>::operator/=(const ArrayBase<OtherDerived>& other)
00230 {
00231 SelfCwiseBinaryOp<internal::scalar_quotient_op<Scalar>, Derived, OtherDerived> tmp(derived());
00232 tmp = other.derived();
00233 return derived();
00234 }
00235
00236 #endif // EIGEN_ARRAYBASE_H