Loading...
Searching...
No Matches
RigidVector.h
Go to the documentation of this file.
//# RigidVector.h: Fast Vector classes with fixed (templated) length
//# Copyright (C) 1996,1999,2001
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef SCIMATH_RIGIDVECTOR_H
#define SCIMATH_RIGIDVECTOR_H
#include <casacore/casa/aips.h>
#include <casacore/casa/Arrays/Vector.h>
#include <casacore/casa/BasicSL/Complex.h>
#include <casacore/casa/iosfwd.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# forward
template <class T, Int n> class SquareMatrix;
// <summary> Fast Vector classes with fixed (templated) length </summary>
// <use visibility=export>
// <reviewed reviewer="" date="yyyy/mm/dd" tests="" demos="">
// </reviewed>
// <prerequisite>
// <li> Vector
// <li> Complex
// </prerequisite>
//
// <etymology>
// RigidVector is a vector with a size fixed at compile time, i.e. Rigid
// as compared to the normal Vector class.
// </etymology>
//
// <synopsis>
// RigidVector is a specialized Vector class for short (<25 elements) vectors.
// It has a size fixed at compile time, avoids new and delete and uses
// copy semantics throughout.
// Unlike Vectors, RigidVectors have fixed zero origin and no strides,
// allowing fast indexing.
// The more common mathematical operations are defined for RigidVector,
// allowing element by element arithmetic, innerproduct and matrix
// multiplication (by a SquareMatrix). Conversion to and from normal
// vectors is provided.
// </synopsis>
//
// <example>
// <srcblock>
// // Create two RigidVectors
// RigidVector<Float,3> rv1(1.0,2.0,3.0),rv2(3.0,2.0,1.0);
// // Compute sum
// RigidVector<Float,3> rv3=rv1+rv2;
// // Compute innerproduct
// Float inprod=rv1*rv2;
// // Write out results
// cout << "rv1+rv2="<< rv3 <<", rv1*rv2="<< inprod<<endl;
// </srcblock>
// </example>
//
// <motivation>
// The standard Vector class is rather inefficient for short vectors, this
// class is designed for speed and simplicity.
// </motivation>
//
// <templating arg=T>
// <li> this class is meant for computation and assumes operators
// +,-,* to be defined.
// </templating>
//
// <thrown>
// <li> no exceptions
// </thrown>
//
// <todo asof="1996/11/07">
// <li> not all operations defined for Vectors are defined
// <li> default implementation of innerProduct is wrong for Complex vectors
// </todo>
template <class T, Int n> class RigidVector {
//# friends (could be out of line if compiler accepted that)
// Add two RigidVectors.
friend RigidVector<T,n> operator+(const RigidVector<T,n>& l,
const RigidVector<T,n>& r) {
RigidVector<T,n> result=l;
return result+=r;
}
// Subtract two RigidVectors.
friend RigidVector<T,n> operator-(const RigidVector<T,n>& l,
const RigidVector<T,n>& r) {
RigidVector<T,n> result=l;
return result-=r;
}
// The innerproduct of 2 RigidVectors.
friend T operator*(const RigidVector<T,n>& l,
const RigidVector<T,n>& r) {
T sum=T(0);
for (Int i=0; i<n; i++) sum+=l.v_p[i]*r.v_p[i];
return sum;
}
// Multiply a RigidVector by a scalar.
friend RigidVector<T,n> operator*(const T& f, const RigidVector<T,n>& v) {
RigidVector<T,n> r(v);
return r*=f;
}
// Multiply a RigidVector by a scalar.
friend RigidVector<T,n> operator*(const RigidVector<T,n>& v, const T& f) {
RigidVector<T,n> r(v);
return r*=f;
}
// Write out a RigidVector using the Vector output method.
friend ostream& operator<<(ostream& os, const RigidVector<T,n>& v) {
os << v.vector();
return os;
}
// Special matrix multiply of Complex matrix * Float vector.
friend RigidVector<Complex,4> operator*(const SquareMatrix<Complex,4>& m,
const RigidVector<Float,4>& v);
public:
// RigidVector(Int dummy) {
// for (Int i=0; i<n; i++) v_p[i]=T(0);
// }
// Default constructor
RigidVector() {
for (Int i=0; i<n; i++) v_p[i]=T(0);
}
// Construct from scalar, sets all elements to c
RigidVector(const T& c) {
for (Int i=0; i<n; i++) v_p[i]=c;
}
// Construct a 2-element vector, fails for wrong size vectors.
RigidVector(const T& v0, const T& v1) {
if (n!=2) exit(1);
v_p[0]=v0; v_p[1]=v1;
}
// Construct a 3-element vector, fails for wrong size vectors.
RigidVector(const T& v0, const T& v1, const T& v2) {
if (n!=3) exit(1);
v_p[0]=v0; v_p[1]=v1; v_p[2]=v2;
}
// Construct a 4-element vector, fails for wrong size vectors.
RigidVector(const T& v0, const T& v1, const T& v2, const T& v3) {
if (n!=4) exit(1);
v_p[0]=v0; v_p[1]=v1; v_p[2]=v2; v_p[3]=v3;
}
// Construct a 5-element vector, fails for wrong size vectors.
RigidVector(const T& v0, const T& v1, const T& v2, const T& v3,
const T& v4) {
if (n!=5) exit(1);
v_p[0]=v0; v_p[1]=v1; v_p[2]=v2; v_p[3]=v3; v_p[4]=v4;
}
// Construct a 6-element vector, fails for wrong size vectors.
RigidVector(const T& v0, const T& v1, const T& v2, const T& v3,
const T& v4, const T& v5) {
if (n!=6) exit(1);
v_p[0]=v0; v_p[1]=v1; v_p[2]=v2; v_p[3]=v3; v_p[4]=v4; v_p[5]=v5;
}
// Construct from a c-array (copy semantics)
RigidVector(const T v[n]) {
for (Int i=0; i<n; i++) v_p[i]=v[i];
}
// Construct from a Vector.
RigidVector(const Vector<T> & v) {
for (Int i=0; i<n; i++) v_p[i]=v(i);
}
// Copy constructor, copy semantics.
RigidVector(const RigidVector<T,n>& v) {
for (Int i=0; i<n; i++) v_p[i]=v.v_p[i];
}
// Assign from a RigidVector.
RigidVector<T,n>& operator=(const RigidVector<T,n>& v) {
for (Int i=0; i<n; i++) v_p[i]=v.v_p[i];
return *this;
}
// Assign from a Vector.
RigidVector<T,n>& operator=(const Vector<T>& v) {
for (Int i=0; i<n; i++) v_p[i]=v(i);
return *this;
}
// Assign a scalar, sets all elements to c.
RigidVector<T,n>& operator=(const T& c) {
for (Int i=0; i<n; i++) v_p[i]=c;
return *this;
}
// Negation
RigidVector<T,n>& operator-() {
for (Int i=0; i<n ;i++) v_p[i]=-v_p[i];
return *this;
}
// Addition
RigidVector<T,n>& operator+=(const RigidVector<T,n>& v) {
for (Int i=0; i<n; i++) v_p[i]+=v.v_p[i];
return *this;
}
RigidVector<T,n>& operator*=(const RigidVector<T,n>& v) {
for (Int i=0; i<n; i++) v_p[i]*=v.v_p[i];
return *this;
}
// Subtraction
RigidVector<T,n>& operator-=(const RigidVector<T,n>& v) {
for (Int i=0; i<n; i++) v_p[i]-=v.v_p[i];
return *this;
}
// Multiplication by scalar.
RigidVector<T,n>& operator*=(const T& val) {
for (Int i=0; i<n; i++) v_p[i]*=val;
return *this;
}
// Multiply vector by matrix: v*=M is equivalent to v=M*v;
RigidVector<T,n>& operator*=(const SquareMatrix<T,n>& m);
// Indexing by reference
T& operator()(Int i) { return v_p[i];}
// Indexing by const reference
const T& operator()(Int i) const { return v_p[i];}
//# Get const access to the underlying c-array
//#const T*& cArray() const { return v_p;}
// Convert to a regular Vector
Vector<T> vector() const {
Vector<T> v(n);
for (Int i=0; i<n; i++) v(i)=v_p[i];
return v;
}
// Square Root
RigidVector<T,n> sqrt(const RigidVector<T,n>& v);
// // The following are needed for Image<RigidVector>
// static IPosition shape() {return IPosition(1,n);}
// static void* newCopyInfo (const TableRecord& record,
// const IPosition& sourceElementShape);
// static void deleteCopyInfo (void*);
// static void set (void* copyInfo, void* out,
// const Array<T>& in,
// const IPosition& shape);
// static void get (void* copyInfo, Array<T>& out,
// const void* in,
// const IPosition& shape);
protected:
T v_p[n];
};
// <summary> Mathematical operations involving RigidVectors </summary>
// <group name=math>
//#Fails to compile
//#// Multiply vector by matrix.
//#template <class T, Int n>
//#inline RigidVector<T,n> operator*(const SquareMatrix<T,n>& m,
//# const RigidVector<T,n>& v) {
//# RigidVector<T,n> result(v);
//# return result*=m;
//#}
// Multiply vector by matrix.
inline RigidVector<Float,4> operator*(const SquareMatrix<Float,4>& m,
const RigidVector<Float,4>& v) {
RigidVector<Float,4> result(v);
return result*=m;
}
// Multiply vector by matrix.
inline RigidVector<Complex,4> operator*(const SquareMatrix<Complex,4>& m,
const RigidVector<Complex,4>& v) {
RigidVector<Complex,4> result(v);
return result*=m;
}
// </group>
} //# NAMESPACE CASACORE - END
#ifndef CASACORE_NO_AUTO_TEMPLATES
#include <casacore/scimath/Mathematics/RigidVector.tcc>
#endif //# CASACORE_NO_AUTO_TEMPLATES
#endif
casacore::RigidVector
Definition RigidVector.h:99
casacore::RigidVector::RigidVector
RigidVector(const RigidVector< T, n > &v)
Copy constructor, copy semantics.
Definition RigidVector.h:187
casacore::RigidVector::operator-=
RigidVector< T, n > & operator-=(const RigidVector< T, n > &v)
Subtraction.
Definition RigidVector.h:220
casacore::RigidVector::RigidVector
RigidVector(const T v[n])
Construct from a c-array (copy semantics).
Definition RigidVector.h:179
casacore::RigidVector::RigidVector
RigidVector(const T &v0, const T &v1)
Construct a 2-element vector, fails for wrong size vectors.
Definition RigidVector.h:152
casacore::RigidVector::RigidVector
RigidVector(const Vector< T > &v)
Construct from a Vector.
Definition RigidVector.h:183
casacore::RigidVector::operator=
RigidVector< T, n > & operator=(const T &c)
Assign a scalar, sets all elements to c.
Definition RigidVector.h:201
casacore::RigidVector::vector
Vector< T > vector() const
Convert to a regular Vector.
Definition RigidVector.h:239
casacore::RigidVector::RigidVector
RigidVector(const T &v0, const T &v1, const T &v2, const T &v3)
Construct a 4-element vector, fails for wrong size vectors.
Definition RigidVector.h:162
casacore::RigidVector::operator<<
friend ostream & operator<<(ostream &os, const RigidVector< T, n > &v)
Write out a RigidVector using the Vector output method.
Definition RigidVector.h:132
casacore::RigidVector::operator-
RigidVector< T, n > & operator-()
Negation.
Definition RigidVector.h:206
casacore::RigidVector::operator*=
RigidVector< T, n > & operator*=(const T &val)
Multiplication by scalar.
Definition RigidVector.h:225
casacore::RigidVector::RigidVector
RigidVector()
RigidVector(Int dummy) { for (Int i=0; i<n; i++) v_p[i]=T(0); } Default constructor.
Definition RigidVector.h:144
casacore::RigidVector::operator=
RigidVector< T, n > & operator=(const RigidVector< T, n > &v)
Assign from a RigidVector.
Definition RigidVector.h:191
casacore::RigidVector::operator-
friend RigidVector< T, n > operator-(const RigidVector< T, n > &l, const RigidVector< T, n > &r)
Subtract two RigidVectors.
Definition RigidVector.h:109
casacore::RigidVector::sqrt
RigidVector< T, n > sqrt(const RigidVector< T, n > &v)
Square Root.
casacore::RigidVector::operator*
friend RigidVector< Complex, 4 > operator*(const SquareMatrix< Complex, 4 > &m, const RigidVector< Float, 4 > &v)
Special matrix multiply of Complex matrix * Float vector.
casacore::RigidVector::operator*
friend RigidVector< T, n > operator*(const T &f, const RigidVector< T, n > &v)
Multiply a RigidVector by a scalar.
Definition RigidVector.h:122
casacore::RigidVector::operator*
friend RigidVector< T, n > operator*(const RigidVector< T, n > &v, const T &f)
Multiply a RigidVector by a scalar.
Definition RigidVector.h:127
casacore::RigidVector::operator+=
RigidVector< T, n > & operator+=(const RigidVector< T, n > &v)
Addition.
Definition RigidVector.h:211
casacore::RigidVector::operator()
T & operator()(Int i)
Indexing by reference.
Definition RigidVector.h:233
casacore::RigidVector::RigidVector
RigidVector(const T &v0, const T &v1, const T &v2, const T &v3, const T &v4)
Construct a 5-element vector, fails for wrong size vectors.
Definition RigidVector.h:167
casacore::RigidVector::operator()
const T & operator()(Int i) const
Indexing by const reference.
Definition RigidVector.h:235
casacore::RigidVector::RigidVector
RigidVector(const T &c)
Construct from scalar, sets all elements to c.
Definition RigidVector.h:148
casacore::RigidVector::RigidVector
RigidVector(const T &v0, const T &v1, const T &v2)
Construct a 3-element vector, fails for wrong size vectors.
Definition RigidVector.h:157
casacore::RigidVector::operator=
RigidVector< T, n > & operator=(const Vector< T > &v)
Assign from a Vector.
Definition RigidVector.h:196
casacore::RigidVector::RigidVector
RigidVector(const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5)
Construct a 6-element vector, fails for wrong size vectors.
Definition RigidVector.h:173
casacore::RigidVector::operator*=
RigidVector< T, n > & operator*=(const SquareMatrix< T, n > &m)
Multiply vector by matrix: v*=M is equivalent to v=M*v;.
casacore::RigidVector::operator+
friend RigidVector< T, n > operator+(const RigidVector< T, n > &l, const RigidVector< T, n > &r)
Add two RigidVectors.
Definition RigidVector.h:103
casacore::RigidVector::operator*
friend T operator*(const RigidVector< T, n > &l, const RigidVector< T, n > &r)
The innerproduct of 2 RigidVectors.
Definition RigidVector.h:115
casacore::RigidVector::operator*=
RigidVector< T, n > & operator*=(const RigidVector< T, n > &v)
Definition RigidVector.h:215
casacore::RigidVector::v_p
T v_p[n]
// The following are needed for Image<RigidVector>
Definition RigidVector.h:264
casacore::SquareMatrix
Definition SquareMatrix.h:104
casacore::Vector
Definition Vector.h:82
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::sum
LatticeExprNode sum(const LatticeExprNode &expr)
casacore::Int
int Int
Definition aipstype.h:48
casacore::RigidVector_global_functions_math
Mathematical operations involving RigidVectors .
Definition RigidVector.h:270
casacore::RigidVector_global_functions_math::operator*
RigidVector< Complex, 4 > operator*(const SquareMatrix< Complex, 4 > &m, const RigidVector< Complex, 4 > &v)
Multiply vector by matrix.
Definition RigidVector.h:285
casacore::RigidVector_global_functions_math::operator*
RigidVector< Float, 4 > operator*(const SquareMatrix< Float, 4 > &m, const RigidVector< Float, 4 > &v)
Multiply vector by matrix.
Definition RigidVector.h:279