friend PIBinaryStream & operator<<(PIBinaryStream
& s, const PIMathVector & v);
template
friend PIBinaryStream & operator>>(PIBinaryStream
& s, PIMathVector & v);
public:
//! \~english Constructor with size and initial value
//! \~russian Конструктор с размером и начальным значением
//! \param size The initial size of the vector
//! \param new_value The initial value for all elements
PIMathVector(const uint size = 0, const Type & new_value = Type()) { c.resize(size, new_value); }
//! \~english Constructor from PIVector
//! \~russian Конструктор из PIVector
//! \param val The PIVector to copy from
PIMathVector(const PIVector & val) { c = val; }
//! \~english Constructor from move PIVector
//! \~russian Конструктор из move PIVector
//! \param val The PIVector to move from
PIMathVector(PIVector && val): c(std::move(val)) {}
//! \~english Constructor from initializer list
//! \~russian Конструктор из списка инициализации
//! \param init_list The initializer list to copy from
PIMathVector(std::initializer_list init_list) { c = PIVector(init_list); }
//! \~english Constructor from fixed-size vector
//! \~russian Конструктор из фиксированного вектора
//! \param val The fixed-size vector to copy from
template
PIMathVector(const PIMathVectorT & val) {
c.resize(Size);
PIMV_FOR c[i] = val[i];
}
//! \~english Create vector from two points (st -> fn)
//! \~russian Создать вектор из двух точек (st -> fn)
//! \param st The start point
//! \param fn The finish point
//! \returns Vector from st to fn
static PIMathVector fromTwoPoints(const _CVector & st, const _CVector & fn) {
assert(st.size() == fn.size());
_CVector v(st.size());
for (uint i = 0; i < v.size(); ++i)
v.c[i] = fn[i] - st[i];
}
//! \~english Create zero vector of specified size
//! \~russian Создать нулевой вектор указанного размера
//! \param size The size of the vector
//! \returns Zero vector
static PIMathVector zeros(const uint size) { return PIMathVector(size, Type()); }
//! \~english Create vector with all elements set to 1
//! \~russian Создать вектор со всеми элементами, равными 1
//! \param size The size of the vector
//! \returns Vector filled with ones
static PIMathVector ones(const uint size) { return PIMathVector(size, Type(1)); }
//! \~english Create vector with values in arithmetic progression
//! \~russian Создать вектор со значениями в арифметической прогрессии
//! \param start The start value
//! \param stop The stop value (exclusive)
//! \param step The step between values
//! \returns Vector with arithmetic progression
static PIMathVector arange(const Type start, const Type stop, const Type step = Type(1)) {
PIVector v;
for (Type i = start; i < stop; i += step)
v << i;
return PIMathVector(std::move(v));
}
//! \~english Get vector size
//! \~russian Получить размер вектора
//! \returns The dynamic size of the vector
uint size() const { return c.size(); }
//! \~english Resize the vector
//! \~russian Изменить размер вектора
//! \param size The new size
//! \param new_value The value for new elements
//! \returns Reference to this vector
_CVector & resize(uint size, const Type & new_value = Type()) {
c.resize(size, new_value);
return *this;
}
//! \~english Get resized copy of the vector
//! \~russian Получить копию вектора с измененным размером
//! \param size The new size
//! \param new_value The value for new elements
//! \returns New vector with new size
_CVector resized(uint size, const Type & new_value = Type()) {
_CVector tv = _CVector(*this);
tv.resize(size, new_value);
return tv;
}
//! \~english Fill vector with a single value
//! \~russian Заполнить вектор одним значением
//! \param v The value to fill
//! \returns Reference to this vector
_CVector & fill(const Type & v) {
c.fill(v);
return *this;
}
//! \~english Add value to all elements
//! \~russian Прибавить значение ко всем элементам
//! \param v The value to add
//! \returns Reference to this vector
_CVector & move(const Type & v) {
PIMV_FOR c[i] += v;
return *this;
}
//! \~english Add vector to this vector
//! \~russian Прибавить вектор к этому вектору
//! \param v The vector to add
//! \returns Reference to this vector
_CVector & move(const _CVector & v) {
assert(c.size() == v.size());
PIMV_FOR c[i] += v[i];
return *this;
}
//! \~english Swap two elements
//! \~russian Поменять два элемента местами
//! \param f First element index
//! \param s Second element index
//! \returns Reference to this vector
_CVector & swapElements(uint f, uint s) {
piSwap(c[f], c[s]);
return *this;
}
//! \~english Get squared length of vector
//! \~russian Получить квадрат длины вектора
//! \returns Sum of squares of all elements
Type lengthSqr() const {
Type tv(0);
PIMV_FOR tv += c[i] * c[i];
return tv;
}
//! \~english Get length of vector
//! \~russian Получить длину вектора
//! \returns Square root of lengthSqr
Type length() const { return std::sqrt(lengthSqr()); }
//! \~english Get Manhattan length (sum of absolute values)
//! \~russian Получить манхэттенскую длину (сумма абсолютных значений)
//! \returns Sum of absolute values of all elements
Type manhattanLength() const {
Type tv(0);
PIMV_FOR tv += piAbs(c[i]);
return tv;
}
//! \~english Get cosine of angle between two vectors
//! \~russian Получить косинус угла между двумя векторами
//! \param v The other vector
//! \returns cos(angle)
Type angleCos(const _CVector & v) const {
assert(c.size() == v.size());
Type tv = v.length() * length();
assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP);
return dot(v) / tv;
}
//! \~english Get sine of angle between two vectors
//! \~russian Получить синус угла между двумя векторами
//! \param v The other vector
//! \returns sin(angle)
Type angleSin(const _CVector & v) const {
assert(c.size() == v.size());
Type tv = angleCos(v);
return std::sqrt(Type(1) - tv * tv);
}
//! \~english Get angle in radians between two vectors
//! \~russian Получить угол в радианах между двумя векторами
//! \param v The other vector
//! \returns Angle in radians
Type angleRad(const _CVector & v) const { return std::acos(angleCos(v)); }
//! \~english Get angle in degrees between two vectors
//! \~russian Получить угол в градусах между двумя векторами
//! \param v The other vector
//! \returns Angle in degrees
Type angleDeg(const _CVector & v) const { return toDeg(angleRad(v)); }
//! \~english Get projection of this vector onto another vector
//! \~russian Получить проекцию этого вектора на другой вектор
//! \param v The vector to project onto
//! \returns Projection vector
_CVector projection(const _CVector & v) {
assert(c.size() == v.size());
Type tv = v.length();
assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP);
return v * (dot(v) / tv);
}
//! \~english Normalize vector in place
//! \~russian Нормализовать вектор на месте
//! \returns Reference to this vector
_CVector & normalize() {
Type tv = length();
assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP);
if (tv == Type(1)) return *this;
PIMV_FOR c[i] /= tv;
return *this;
}
//! \~english Get normalized copy of vector
//! \~russian Получить нормализованную копию вектора
//! \returns New normalized vector
_CVector normalized() {
_CVector tv(*this);
tv.normalize();
return tv;
}
//! \~english Check if vector is null (all elements zero)
//! \~russian Проверить, является ли вектор нулевым (все элементы нули)
//! \returns true if vector is null
bool isNull() const {
PIMV_FOR if (c[i] != Type(0)) return false;
return true;
}
//! \~english Check if vector is valid (non-empty)
//! \~russian Проверить, валиден ли вектор (не пустой)
//! \returns true if vector is valid
bool isValid() const { return !c.isEmpty(); }
//! \~english Check if vectors are orthogonal
//! \~russian Проверить, перпендикулярны ли векторы
//! \param v The other vector
//! \returns true if vectors are orthogonal
bool isOrtho(const _CVector & v) const { return dot(v) == Type(0); }
//! \~english Get element at index (non-const)
//! \~russian Получить элемент по индексу (non-const)
//! \param index Element index
//! \returns Reference to element
Type & operator[](uint index) { return c[index]; }
//! \~english Get element at index (const)
//! \~russian Получить элемент по индексу (const)
//! \param index Element index
//! \returns Copy of element
const Type & operator[](uint index) const { return c[index]; }
//! \~english Get element at index (const version)
//! \~russian Получить элемент по индексу (версия const)
//! \param index Element index
//! \returns Copy of element
Type at(uint index) const { return c[index]; }
//! \~english Assign value to all elements
//! \~russian Присвоить значение всем элементам
//! \param v The value to assign
//! \returns Reference to this vector
_CVector & operator=(const Type & v) {
PIMV_FOR c[i] = v;
return *this;
}
//! \~english Check equality with another vector
//! \~russian Проверить равенство с другим вектором
//! \param v The vector to compare with
//! \returns true if all elements are equal
bool operator==(const _CVector & v) const { return c == v.c; }
//! \~english Check inequality with another vector
//! \~russian Проверить неравенство с другим вектором
//! \param v The vector to compare with
//! \returns true if any element differs
bool operator!=(const _CVector & v) const { return c != v.c; }
//! \~english Add vector to this vector
//! \~russian Прибавить вектор к этому вектору
//! \param v The vector to add
void operator+=(const _CVector & v) {
assert(c.size() == v.size());
PIMV_FOR c[i] += v[i];
}
//! \~english Subtract vector from this vector
//! \~russian Вычесть вектор из этого вектора
//! \param v The vector to subtract
void operator-=(const _CVector & v) {
assert(c.size() == v.size());
PIMV_FOR c[i] -= v[i];
}
//! \~english Multiply all elements by scalar
//! \~russian Умножить все элементы на скаляр
//! \param v The scalar to multiply by
void operator*=(const Type & v) { PIMV_FOR c[i] *= v; }
//! \~english Divide all elements by scalar
//! \~russian Разделить все элементы на скаляр
//! \param v The scalar to divide by
void operator/=(const Type & v) {
assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP);
PIMV_FOR c[i] /= v;
}
//! \~english Unary minus operator
//! \~russian Унарный оператор минус
//! \returns New vector with negated elements
_CVector operator-() const {
_CVector tv(c.size());
PIMV_FOR tv[i] = -c[i];
return tv;
}
//! \~english Add two vectors
//! \~russian Сложить два вектора
//! \param v The vector to add
//! \returns New vector with sum of elements
_CVector operator+(const _CVector & v) const {
assert(c.size() == v.size());
_CVector tv(*this);
PIMV_FOR tv[i] += v[i];
return tv;
}
//! \~english Subtract two vectors
//! \~russian Вычесть два вектора
//! \param v The vector to subtract
//! \returns New vector with difference of elements
_CVector operator-(const _CVector & v) const {
assert(c.size() == v.size());
_CVector tv(*this);
PIMV_FOR tv[i] -= v[i];
return tv;
}
//! \~english Multiply vector by scalar
//! \~russian Умножить вектор на скаляр
//! \param v The scalar to multiply by
//! \returns New vector with scaled elements
_CVector operator*(const Type & v) const {
_CVector tv(*this);
PIMV_FOR tv[i] *= v;
return tv;
}
//! \~english Divide vector by scalar
//! \~russian Разделить вектор на скаляр
//! \param v The scalar to divide by
//! \returns New vector with scaled elements
_CVector operator/(const Type & v) const {
assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP);
_CVector tv(*this);
PIMV_FOR tv[i] /= v;
return tv;
}
//! \~english Compute cross product with another vector (3D only)
//! \~russian Вычислить векторное произведение с другим вектором (только 3D)
//! \param v The other vector
//! \returns Cross product vector
_CVector cross(const _CVector & v) const {
assert(c.size() == 3);
assert(v.size() == 3);
_CVector tv(3);
tv[0] = c[1] * v[2] - v[1] * c[2];
tv[1] = c[2] * v[0] - v[2] * c[0];
tv[2] = c[0] * v[1] - v[0] * c[1];
return tv;
}
//! \~english Compute dot product with another vector
//! \~russian Вычислить скалярное произведение с другим вектором
//! \param v The other vector
//! \returns Dot product (sum of element-wise products)
Type dot(const _CVector & v) const {
assert(c.size() == v.size());
Type tv(0);
PIMV_FOR tv += c[i] * v[i];
return tv;
}
//! \~english Element-wise multiplication with another vector
//! \~russian Покомпонентное умножение с другим вектором
//! \param v The other vector
//! \returns New vector with element-wise products
_CVector mul(const _CVector & v) const {
assert(c.size() == v.size());
_CVector tv(*this);
PIMV_FOR tv[i] *= v[i];
return tv;
}
//! \~english Element-wise multiplication with scalar
//! \~russian Покомпонентное умножение на скаляр
//! \param v The scalar to multiply by
//! \returns New vector with scaled elements
_CVector mul(const Type & v) const { return (*this) * v; }
//! \~english Element-wise division by another vector
//! \~russian Покомпонентное деление на другой вектор
//! \param v The vector to divide by
//! \returns New vector with element-wise quotients
_CVector div(const _CVector & v) const {
assert(c.size() == v.size());
_CVector tv(*this);
PIMV_FOR {
assert(std::abs(v[i]) > PIMATHVECTOR_ZERO_CMP);
tv[i] /= v[i];
}
return tv;
}
//! \~english Element-wise division by scalar
//! \~russian Покомпонентное деление на скаляр
//! \param v The scalar to divide by
//! \returns New vector with scaled elements
_CVector div(const Type & v) const { return (*this) / v; }
//! \~english Get distance from this point to line defined by two points
//! \~russian Получить расстояние от этой точки до линии, заданной двумя точками
//! \param lp0 First point on the line
//! \param lp1 Second point on the line
//! \returns Distance from point to line
Type distToLine(const _CVector & lp0, const _CVector & lp1) {
assert(c.size() == lp0.size());
assert(c.size() == lp1.size());
_CVector a = _CVector::fromTwoPoints(lp0, lp1);
Type tv = a.length();
assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP);
_CVector b = _CVector::fromTwoPoints(lp0, *this);
return piAbs(a[0] * b[1] - a[1] * b[0]) / tv;
}
//! \~english Convert to PIVector
//! \~russian Преобразовать в PIVector
//! \returns PIVector with same elements
PIVector toVector() const { return c; }
//! \~english Apply function to each element (const)
//! \~russian Применить функцию к каждому элементу (const)
//! \param f The function to apply
void forEach(std::function f) const { c.forEach(f); }
//! \~english Apply function to each element
//! \~russian Применить функцию к каждому элементу
//! \param f The function to apply
//! \returns Reference to this vector
_CVector & forEach(std::function f) {
c.forEach(f);
return *this;
}
//! \~english Get pointer to underlying data
//! \~russian Получить указатель на внутренние данные
//! \returns Pointer to first element
inline Type * data() { return c.data(); }
//! \~english Get pointer to underlying data (const)
//! \~russian Получить указатель на внутренние данные (const)
//! \returns Pointer to first element
inline const Type * data() const { return c.data(); }
//! \~english Static cross product of two vectors
//! \~russian Статическое векторное произведение двух векторов
//! \param v1 First vector
//! \param v2 Second vector
//! \returns Cross product vector
static _CVector cross(const _CVector & v1, const _CVector & v2) { return v1.cross(v2); }
//! \~english Static dot product of two vectors
//! \~russian Статическое скалярное произведение двух векторов
//! \param v1 First vector
//! \param v2 Second vector
//! \returns Dot product
static Type dot(const _CVector & v1, const _CVector & v2) { return v1.dot(v2); }
//! \~english Static element-wise multiplication of two vectors
//! \~russian Статическое покомпонентное умножение двух векторов
//! \param v1 First vector
//! \param v2 Second vector
//! \returns New vector with element-wise products
static _CVector mul(const _CVector & v1, const _CVector & v2) { return v1.mul(v2); }
//! \~english Static scalar multiplication (scalar * vector)
//! \~russian Статическое скалярное умножение (скаляр * вектор)
//! \param v1 Scalar
//! \param v2 Vector
//! \returns Scaled vector
static _CVector mul(const Type & v1, const _CVector & v2) { return v2 * v1; }
//! \~english Static scalar multiplication (vector * scalar)
//! \~russian Статическое скалярное умножение (вектор * скаляр)
//! \param v1 Vector
//! \param v2 Scalar
//! \returns Scaled vector
static _CVector mul(const _CVector & v1, const Type & v2) { return v1 * v2; }
//! \~english Static element-wise division of two vectors
//! \~russian Статическое покомпонентное деление двух векторов
//! \param v1 First vector
//! \param v2 Second vector
//! \returns New vector with element-wise quotients
static _CVector div(const _CVector & v1, const _CVector & v2) { return v1.div(v2); }
//! \~english Static scalar division (vector / scalar)
//! \~russian Статическое скалярное деление (вектор / скаляр)
//! \param v1 Vector
//! \param v2 Scalar
//! \returns Scaled vector
static _CVector div(const _CVector & v1, const Type & v2) { return v1 / v2; }
private:
PIVector c;
};
template
inline PIMathVector operator*(const Type & x, const PIMathVector & v) {
return v * x;
}
#undef PIMV_FOR
#ifdef PIP_STD_IOSTREAM
//! \~english Output vector to stream
//! \~russian Вывести вектор в поток
//! \param s The output stream
//! \param v The vector to output
//! \returns Reference to the stream
template
inline std::ostream & operator<<(std::ostream & s, const PIMathVector & v) {
s << "{";
for (uint i = 0; i < v.size(); ++i) {
s << v[i];
if (i < v.size() - 1) s << ", ";
}
s << "}";
return s;
}
#endif
//! \~english Output vector to PIP stream
//! \~russian Вывести вектор в поток PIP
//! \param s The PIP output stream
//! \param v The vector to output
//! \returns Reference to the stream
template
inline PICout operator<<(PICout s, const PIMathVector & v) {
s.space();
s.saveAndSetControls(0);
s << "Vector{";
for (uint i = 0; i < v.size(); ++i) {
s << v[i];
if (i < v.size() - 1) s << ", ";
}
s << "}";
s.restoreControls();
return s;
}
//! \~english Serialize vector to binary stream
//! \~russian Сериализовать вектор в бинарный поток
//! \param s The binary stream
//! \param v The vector to serialize
//! \returns Reference to the stream
template
inline PIBinaryStream & operator<<(PIBinaryStream
& s, const PIMathVector & v) {
s << v.c;
return s;
}
//! \~english Deserialize vector from binary stream
//! \~russian Десериализовать вектор из бинарного потока
//! \param s The binary stream
//! \param v The vector to deserialize
//! \returns Reference to the stream
template
inline PIBinaryStream & operator>>(PIBinaryStream
& s, PIMathVector & v) {
s >> v.c;
return s;
}
//! \~english 32-bit integer dynamic vector
//! \~russian Динамический вектор с 32-битными целыми числами
typedef PIMathVector PIMathVectori;
//! \~english Double precision dynamic vector
//! \~russian Динамический вектор с числами двойной точности
typedef PIMathVector PIMathVectord;
#endif // PIMATHVECTOR_H