vector.hpp

Go to the documentation of this file.

//  
//       ,---.     ,--,    .---.     ,--,    ,---.    .-. .-. 
//       | .-'   .' .')   / .-. )  .' .'     | .-'    |  \| | 
//       | `-.   |  |(_)  | | |(_) |  |  __  | `-.    |   | | 
//       | .-'   \  \     | | | |  \  \ ( _) | .-'    | |\  | 
//       |  `--.  \  `-.  \ `-' /   \  `-) ) |  `--.  | | |)| 
//       /( __.'   \____\  )---'    )\____/  /( __.'  /(  (_) 
//      (__)              (_)      (__)     (__)     (__)     
//
//  This file is part of ECOGEN.
//
//  ECOGEN is the legal property of its developers, whose names 
//  are listed in the copyright file included with this source 
//  distribution.
//
//  ECOGEN is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published 
//  by the Free Software Foundation, either version 3 of the License, 
//  or (at your option) any later version.
//  
//  ECOGEN 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 General Public License for more details.
//  
//  You should have received a copy of the GNU General Public License
//  along with ECOGEN (file LICENSE).  
//  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef INCLUDED_SIMPLE_VECTOR_HPP
#define INCLUDED_SIMPLE_VECTOR_HPP
 
#include <type_traits>
#include <array>
#include <iostream>
 
namespace math
{
 
template<typename T, std::size_t N>
class vector
{
public: // member types
 
    using data_type = std::array<T,N>;
    using value_type = typename data_type::value_type;
    using size_type = typename data_type::size_type;
    using difference_type = typename data_type::difference_type;
    using reference = typename data_type::reference;
    using const_reference = typename data_type::const_reference;
    using pointer = typename data_type::pointer;
    using const_pointer = typename data_type::const_pointer;
    using iterator = typename data_type::iterator;
    using const_iterator = typename data_type::const_iterator;
    using reverse_iterator = typename data_type::reverse_iterator;
    using const_reverse_iterator = typename data_type::const_reverse_iterator;
 
public: // ctors
 
    vector() = default;
    vector(const T& element) { data.fill(element); }
    vector(const vector&) = default;
    vector(vector&&) = default;
    explicit vector(const T* ptr) { for(unsigned int i=0; i<N; ++i) data[i] = ptr[i]; }
    template<typename T2>
    vector(const vector<T2,N>& other) { for(unsigned int i=0; i<N; ++i) data[i] = static_cast<T>(other.data[i]); }
    vector(const std::array<T,N>& _data) : data(_data) {}
    vector(std::array<T,N>&& _data) : data(std::move(_data)) {}
    
    vector& operator=(const vector&) & = default;
    vector& operator=(vector&&) & = default;
    vector& operator=(const T& element) & { data.fill(element); return *this; }
 
public: // static member functions
 
    static constexpr std::size_t size() { return N; }
    
public: // member functions
 
    reference operator[](size_type pos) { return data[pos]; }
    const_reference operator[](size_type pos) const { return data[pos]; }
    
    reference operator()(size_type i) { return data[i]; }
    const_reference operator()(size_type i) const { return data[i]; }
    
    reference front() { return data.front(); }
    const_reference front() const { return data.front(); }
    reference back() { return data.back(); }
    const_reference back() const { return data.back(); }
    reference x() { return data[0]; }
    const_reference x() const { return data[0]; }
    reference y() { return data[1]; }
    const_reference y() const { return data[1]; }
    reference z() { return data[2]; }
    const_reference z() const { return data[2]; }
    reference w() { return data[3]; }
    const_reference w() const { return data[3]; }
    
    
    friend std::ostream& operator<<(std::ostream& os, const vector& v)
    {
        os << "";
        for (unsigned int i=0; i<N; ++i)
        {
            os << v.data[i];
            if (i<N-1) os << " ";
        }
        os << "";
        return os;
    }
 
public: // iterators
 
    iterator begin() { return data.begin(); }
    const_iterator begin() const { return data.begin(); }
    const_iterator cbegin() const { return data.cbegin(); }
    iterator end() { return data.end(); }
    const_iterator end() const { return data.end(); }
    const_iterator cend() const { return data.cend(); }
    reverse_iterator rbegin() { return data.rbegin(); }
    const_reverse_iterator rbegin() const { return data.rbegin(); }
    const_reverse_iterator crbegin() const { return data.crbegin(); }
    reverse_iterator rend() { return data.rend(); }
    const_reverse_iterator rend() const { return data.rend(); }
    const_reverse_iterator crend() const { return data.crend(); }
    
public: // arithmetic member functions
 
    vector& operator+=(const vector& other) { for (unsigned int i=0; i<N; ++i) data[i]+=other[i]; return *this; }
    vector& operator+=(const T& element) { for (unsigned int i=0; i<N; ++i) data[i]+=element; return *this; }
    vector& operator-=(const vector& other) { for (unsigned int i=0; i<N; ++i) data[i]-=other[i]; return *this; }
    vector& operator-=(const T& element) { for (unsigned int i=0; i<N; ++i) data[i]-=element; return *this; }
    vector& operator*=(const vector& other) { for (unsigned int i=0; i<N; ++i) data[i]*=other[i]; return *this; }
    vector& operator*=(const T& element) { for (unsigned int i=0; i<N; ++i) data[i]*=element; return *this; }
    vector& operator/=(const vector& other) { for (unsigned int i=0; i<N; ++i) data[i]/=other[i]; return *this; }
    vector& operator/=(const T& element) { for (unsigned int i=0; i<N; ++i) data[i]/=element; return *this; }
 
public: // members
 
    data_type data;
};
 
 
template< class T, std::size_t N >
bool operator==( const math::vector<T,N>& lhs, const math::vector<T,N>& rhs ) { return lhs.data == rhs.data; }
 
template< class T, std::size_t N >
bool operator!=( const math::vector<T,N>& lhs, const math::vector<T,N>& rhs ) { return lhs.data != rhs.data; }
 
template< class T, std::size_t N >
bool operator<( const math::vector<T,N>& lhs, const math::vector<T,N>& rhs ) { return lhs.data < rhs.data; }
 
template< class T, std::size_t N >
bool operator<=( const math::vector<T,N>& lhs, const math::vector<T,N>& rhs ) { return lhs.data <= rhs.data; }
 
template< class T, std::size_t N >
bool operator>( const math::vector<T,N>& lhs, const math::vector<T,N>& rhs ) { return lhs.data > rhs.data; }
 
template< class T, std::size_t N >
bool operator>=( const math::vector<T,N>& lhs, const math::vector<T,N>& rhs ) { return lhs.data >= rhs.data; }
 
 
template<typename T, std::size_t N>
math::vector<T,N> operator-(math::vector<T,N> v) 
{
    for (unsigned int i=0; i<N; ++i) v.data[i] = -v.data[i]; 
    return std::move(v);
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator+(const math::vector<U,N>& lhs, const math::vector<V,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] += rhs[i];
    return res; 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator+(const math::vector<U,N>& lhs, const V& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] += rhs;
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator+(const V& lhs, const math::vector<U,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(rhs);
    for(unsigned int i=0; i<N; ++i) res[i] += lhs;
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator-(const math::vector<U,N>& lhs, const math::vector<V,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] -= rhs[i];
    return res; 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator-(const math::vector<U,N>& lhs, const V& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] -= rhs;
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator-(const V& lhs, const math::vector<U,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(rhs);
    for(unsigned int i=0; i<N; ++i) res[i] -= lhs;
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator*(const math::vector<U,N>& lhs, const math::vector<V,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] *= rhs[i];
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator*(const math::vector<U,N>& lhs, const V& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] *= rhs;
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator*(const V& lhs, const math::vector<U,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(rhs);
    for(unsigned int i=0; i<N; ++i) res[i] *= lhs;
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator/(const math::vector<U,N>& lhs, const math::vector<V,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] /= rhs[i];
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator/(const math::vector<U,N>& lhs, const V& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(lhs);
    for(unsigned int i=0; i<N; ++i) res[i] /= rhs;
    return std::move(res); 
}
 
template<typename U, typename V, std::size_t N>
math::vector<typename std::common_type<U,V>::type,N> operator/(const V& lhs, const math::vector<U,N>& rhs) 
{
    math::vector<typename std::common_type<U,V>::type,N> res(rhs);
    for(unsigned int i=0; i<N; ++i) res[i] = lhs/res[i];
    return std::move(res); 
}
 
 
template<typename U, typename V, std::size_t N>
typename std::common_type<U,V>::type dot(const math::vector<U,N>& lhs, const math::vector<V,N>& rhs) 
{
    typename std::common_type<U,V>::type res(lhs[0]*rhs[0]); 
    for (unsigned int i=1; i<N; ++i) 
    res+=lhs[i]*rhs[i]; 
    return std::move(res);
}
 
template<typename U, std::size_t N>
U norm2(const math::vector<U,N>& v) { return dot(v,v); }
 
template<typename U, std::size_t N>
U norm_inf(const math::vector<U,N>& v) 
{
    using namespace std;
    auto m = std::fabs(v[0]);
    for (unsigned int i=1; i<N; ++i) m = max(m,std::fabs(v[i]));
    return m; 
}
 
 
template<typename U, typename V, std::size_t N>
typename std::enable_if<N==3,math::vector<typename std::common_type<U,V>::type,N>>::type cross(const math::vector<U,N>& lhs, const math::vector<V,N>& rhs)
{
    return math::vector<typename std::common_type<U,V>::type,N>({lhs.y()*rhs.z()-lhs.z()*rhs.y(), lhs.z()*rhs.x()-lhs.x()*rhs.z(), lhs.x()*rhs.y()-lhs.y()*rhs.x()});
}
 
template<typename U, typename V, std::size_t N>
typename std::enable_if<N==2,typename std::common_type<U,V>::type>::type cross(const math::vector<U,N>& lhs, const math::vector<V,N>& rhs)
{
    return lhs.x()*rhs.y()-lhs.y()*rhs.x();
}
 
 
} // namespace math
 
 
#endif // INCLUDED_SIMPLE_VECTOR_HPP