// Copyright (C) 2003 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#undef DLIB_VECTOR_ABSTRACT_
#ifdef DLIB_VECTOR_ABSTRACT_
#include "../serialize.h"
#include <functional>
#include <iostream>
#include "../matrix/matrix_abstract.h"
namespace dlib
{
template <
typename T,
long NR = 3
>
class vector : public matrix<T,NR,1>
{
/*!
REQUIREMENTS ON T
T should be some object that provides an interface that is
compatible with double, float, int, long and the like.
REQUIREMENTS ON NR
NR == 3 || NR == 2
INITIAL VALUE
x() == 0
y() == 0
z() == 0
WHAT THIS OBJECT REPRESENTS
This object represents a three dimensional vector. If NR == 2 then
this object is limited to representing points on the XY plane where
Z is set to 0.
Also note that this object performs the appropriate integer and
floating point conversions and promotions when vectors of mixed
type are used together. For example:
vector<int,3> vi;
vector<double,2> vd;
vd + vi == a vector<double,3> object type since that is what
is needed to contain the result of vi+vd without
any loss of information.
!*/
public:
typedef T type;
vector (
);
/*!
ensures
- #*this has been properly initialized
!*/
vector (
const T _x,
const T _y,
const T _z
);
/*!
requires
- NR == 3
ensures
- #x() == _x
- #y() == _y
- #z() == _z
!*/
vector (
const T _x,
const T _y
);
/*!
requires
- NR == 2
ensures
- #x() == _x
- #y() == _y
- #z() == 0
!*/
template <typename U, long NRv>
vector (
const vector<U,NRv>& v
);
/*!
ensures
- Initializes *this with the contents of v and does any rounding if necessary and also
takes care of converting between 2 and 3 dimensional vectors.
- if (U is a real valued type like float or double and T is an integral type like long) then
- if (NR == 3) then
- #x() == floor(v.x() + 0.5)
- #y() == floor(v.y() + 0.5)
- #z() == floor(v.z() + 0.5)
- else // NR == 2
- #x() == floor(v.x() + 0.5)
- #y() == floor(v.y() + 0.5)
- #z() == 0
- else
- if (NR == 3) then
- #x() == v.x()
- #y() == v.y()
- #z() == v.z()
- else // NR == 2
- #x() == v.x()
- #y() == v.y()
- #z() == 0
!*/
template <typename EXP>
vector (
const matrix_exp<EXP>& m
);
/*!
requires
- m.size() == NR
- m.nr() == 1 || m.nc() == 1 (i.e. m must be a row or column matrix)
ensures
- Initializes *this with the contents of m and does any rounding if necessary and also
takes care of converting between 2 and 3 dimensional vectors.
- if (m contains real valued values like float or double and T is an integral type like long) then
- #x() == floor(m(0) + 0.5)
- #y() == floor(m(1) + 0.5)
- if (NR == 3) then
- #z() == floor(m(2) + 0.5)
- else
- #z() == 0
- else
- #x() == m(0)
- #y() == m(1)
- if (NR == 3) then
- #z() == m(2)
- else
- #z() == 0
!*/
~vector (
);
/*!
ensures
- all resources associated with *this have been released
!*/
double length(
) const;
/*!
ensures
- returns the length of the vector
!*/
double length_squared(
) const;
/*!
ensures
- returns length()*length()
!*/
T& x (
);
/*!
ensures
- returns a reference to the x component of the vector
!*/
T& y (
);
/*!
ensures
- returns a reference to the y component of the vector
!*/
T& z (
);
/*!
requires
- NR == 3 (this function actually doesn't exist when NR != 3)
ensures
- returns a reference to the z component of the vector
!*/
const T& x (
) const;
/*!
ensures
- returns a const reference to the x component of the vector
!*/
const T& y (
) const;
/*!
ensures
- returns a const reference to the y component of the vector
!*/
const T& z (
) const;
/*!
ensures
- if (NR == 3) then
- returns a const reference to the z component of the vector
- else
- return 0
(there isn't really a z in this case so we just return 0)
!*/
T dot (
const vector& rhs
) const;
/*!
ensures
- returns the result of the dot product between *this and rhs
!*/
vector<T,3> cross (
const vector& rhs
) const;
/*!
ensures
- returns the result of the cross product between *this and rhs
!*/
vector<double,NR> normalize (
) const;
/*!
ensures
- returns a vector with length() == 1 and in the same direction as *this
!*/
vector operator+ (
const vector& rhs
) const;
/*!
ensures
- returns the result of adding *this to rhs
!*/
vector operator- (
const vector& rhs
) const;
/*!
ensures
- returns the result of subtracting rhs from *this
!*/
vector operator- (
) const;
/*!
ensures
- returns -1*(*this)
!*/
vector operator/ (
const T rhs
) const;
/*!
ensures
- returns the result of dividing *this by rhs
!*/
vector& operator= (
const vector& rhs
);
/*!
ensures
- #x() == rhs.x()
- #y() == rhs.y()
- #z() == rhs.z()
- returns #*this
!*/
vector& operator += (
const vector& rhs
);
/*!
ensures
- #*this == *this + rhs
- returns #*this
!*/
vector& operator -= (
const vector& rhs
);
/*!
ensures
- #*this == *this - rhs
- returns #*this
!*/
vector& operator *= (
const T rhs
);
/*!
ensures
- #*this == *this * rhs
- returns #*this
!*/
vector& operator /= (
const T rhs
);
/*!
ensures
- #*this == *this / rhs
- returns #*this
!*/
template <typename U, long NR2>
bool operator== (
const vector<U,NR2>& rhs
) const;
/*!
ensures
- if (x() == rhs.x() && y() == rhs.y() && z() == rhs.z()) then
- returns true
- else
- returns false
!*/
template <typename U, long NR2>
bool operator!= (
const vector<U,NR2>& rhs
) const;
/*!
ensures
- returns !((*this) == rhs)
!*/
void swap (
vector& item
);
/*!
ensures
- swaps *this and item
!*/
};
// ----------------------------------------------------------------------------------------
template<typename T, typename U, long NR>
vector operator* (
const vector<T,NR> & lhs,
const U rhs
);
/*!
ensures
- returns the result of multiplying the scalar rhs by lhs
!*/
template<typename T, typename U, long NR>
vector operator* (
const U lhs,
const vector<T,NR> & rhs
);
/*!
ensures
- returns the result of multiplying the scalar lhs by rhs
!*/
template<typename T, long NR>
inline void swap (
vector<T,NR> & a,
vector<T,NR> & b
) { a.swap(b); }
/*!
provides a global swap function
!*/
template<typename T, long NR>
void serialize (
const vector<T,NR>& item,
std::ostream& out
);
/*!
provides serialization support
!*/
template<typename T, long NR>
void deserialize (
vector<T,NR>& item,
std::istream& in
);
/*!
provides deserialization support
!*/
template<typename T>
std::ostream& operator<< (
std::ostream& out,
const vector<T,3>& item
);
/*!
ensures
- writes item to out in the form "(x, y, z)"
!*/
template<typename T>
std::istream& operator>>(
std::istream& in,
vector<T,3>& item
);
/*!
ensures
- reads a vector from the input stream in and stores it in #item.
The data in the input stream should be of the form (x, y, z)
!*/
template<typename T>
std::ostream& operator<< (
std::ostream& out,
const vector<T,2>& item
);
/*!
ensures
- writes item to out in the form "(x, y)"
!*/
template<typename T>
std::istream& operator>>(
std::istream& in,
vector<T,2>& item
);
/*!
ensures
- reads a vector from the input stream in and stores it in #item.
The data in the input stream should be of the form (x, y)
!*/
// ----------------------------------------------------------------------------------------
/*!A point
This is just a typedef of the vector object.
!*/
typedef vector<long,2> point;
/*!A dpoint
This is just a typedef of the vector object.
!*/
typedef vector<double,2> dpoint;
// ----------------------------------------------------------------------------------------
}
namespace std
{
/*!
Define std::less<vector<T,3> > so that you can use vectors in the associative containers.
!*/
template<typename T>
struct less<dlib::vector<T,3> > : public binary_function<dlib::vector<T,3> ,dlib::vector<T,3> ,bool>
{
inline bool operator() (const dlib::vector<T,3> & a, const dlib::vector<T,3> & b) const
{
if (a.x() < b.x()) return true;
else if (a.x() > b.x()) return false;
else if (a.y() < b.y()) return true;
else if (a.y() > b.y()) return false;
else if (a.z() < b.z()) return true;
else if (a.z() > b.z()) return false;
else return false;
}
};
/*!
Define std::less<vector<T,2> > so that you can use vector<T,2>s in the associative containers.
!*/
template<typename T>
struct less<dlib::vector<T,2> > : public binary_function<dlib::vector<T,2> ,dlib::vector<T,2> ,bool>
{
inline bool operator() (const dlib::vector<T,2> & a, const dlib::vector<T,2> & b) const
{
if (a.x() < b.x()) return true;
else if (a.x() > b.x()) return false;
else if (a.y() < b.y()) return true;
else if (a.y() > b.y()) return false;
else return false;
}
};
}
#endif // DLIB_VECTOR_ABSTRACT_