MC_double_vector_vector.cpp

Go to the documentation of this file.

#include <MC_int_vector.hpp>

#include <MC_double_vector_vector.hpp>

namespace mesh_conv
{

    MC_double_vector_vector::MC_double_vector_vector(){}
    MC_double_vector_vector::MC_double_vector_vector(const MC_double_vector& v0){double_vec_list.push_back(v0);}
    MC_double_vector_vector::MC_double_vector_vector(const MC_double_vector& v0,const MC_double_vector& v1)
    {double_vec_list.push_back(v0);double_vec_list.push_back(v1);}
    MC_double_vector_vector::MC_double_vector_vector(const MC_double_vector& v0,const MC_double_vector& v1,const MC_double_vector& v2)
    {double_vec_list.push_back(v0);double_vec_list.push_back(v1);double_vec_list.push_back(v2);}
    MC_double_vector_vector::MC_double_vector_vector(const MC_double_vector& v0,const MC_double_vector& v1,const MC_double_vector& v2,const MC_double_vector& v3)
    {double_vec_list.push_back(v0);double_vec_list.push_back(v1);double_vec_list.push_back(v2);double_vec_list.push_back(v3);}

    MC_double_vector_vector::MC_double_vector_vector(const std::vector <MC_double_vector>& vec)
        :double_vec_list(vec)
    {}

    inline void MC_double_vector_vector::assert_bounds(const int& u) const
    {
        if(u<0 || u>=int(double_vec_list.size()))
        {std::cout<<"Assert mesh_conv::MC_double_vector_vector::assert_bounds("<<u<<") failed, because size="<<double_vec_list.size()<<std::endl;}
    }

    const MC_double_vector& MC_double_vector_vector::operator()(const int& index) const
    {assert_bounds(index);return double_vec_list[index];}
    MC_double_vector& MC_double_vector_vector::operator()(const int& index)
    {assert_bounds(index);return double_vec_list[index];}
    const MC_double_vector& MC_double_vector_vector::operator[](const int& index) const
    {assert_bounds(index);return double_vec_list[index];}
    MC_double_vector& MC_double_vector_vector::operator[](const int& index)
    {assert_bounds(index);return double_vec_list[index];}

    int MC_double_vector_vector::size() const
    {return double_vec_list.size();}


    void MC_double_vector_vector::clear(){double_vec_list.clear();}
    MC_double_vector_vector& MC_double_vector_vector::resize(const int& new_size)
    {
        int N=double_vec_list.size();
        if(N==new_size) //same size
            return *this;

        if(new_size<0)
        {std::cout<<"Error in MC_double_vector_vector::resize("<<new_size<<") new size must be >0"<<std::endl;exit(-1);}

        double_vec_list.resize(new_size);
        return *this;
    }
    MC_double_vector_vector& MC_double_vector_vector::add(const MC_double_vector& val){double_vec_list.push_back(val);return *this;}
    MC_double_vector_vector operator<<(const MC_double_vector_vector& vec,const MC_double_vector& value)
    {return MC_double_vector_vector(vec).add(value);}
    MC_double_vector_vector& MC_double_vector_vector::add(const MC_double_vector_vector& val)
    {
        int N=val.size();
        for(int k=0;k<N;++k)
            double_vec_list.push_back(val[k]);
        return *this;
    }
    MC_double_vector_vector operator<<(const MC_double_vector_vector& vec,const MC_double_vector_vector& to_add)
    {return MC_double_vector_vector(vec).add(to_add);}
    MC_double_vector_vector& MC_double_vector_vector::set(const int& k_index,const MC_double_vector& new_value)
    {
        if(k_index<0)
        {std::cout<<"Error in MC_double_vector_vector::set("<<k_index<<","<<new_value<<"), index must be >0"<<std::endl;exit(-1);}
        if(k_index>=size())
            double_vec_list.resize(k_index+1);
        double_vec_list[k_index]=new_value;
        return *this;
    }
    MC_double_vector_vector& MC_double_vector_vector::set(const MC_int_vector& k_index,const MC_double_vector_vector& new_value)
    {
        MC_double_vector_vector v_new_value=new_value;
        if(new_value.size()!=1 && new_value.size()!=k_index.size())
        {std::cout<<"Error in MC_double_vector_vector::set(MC_int_vector,MC_double_vector_vector), size are not correct: "<<k_index.size()<<","<<new_value.size()<<std::endl;exit(-1);}
        if(new_value.size()==1)
            v_new_value=MC_double_vector_vector::repeat(new_value.first(),k_index.size());


        int N=v_new_value.size();
        for(int k=0;k<N;k++)
            set(k_index[k],v_new_value[k]);
        return *this;
    }
    std::pair <MC_double_vector_vector,MC_double_vector> MC_double_vector_vector::delete_index(const int& index_to_delete) const
    {
        if(index_to_delete<0 || index_to_delete>=size())
        {std::cout<<"Error in MC_double_vector_vector::delete("<<index_to_delete<<", when size="<<size()<<std::endl;exit(-1);}
        MC_double_vector_vector new_vec;
        int N=size();
        for(int k=0;k<N;++k)
            if(k!=index_to_delete)
                new_vec.add(double_vec_list[k]);
        return std::pair <MC_double_vector_vector,MC_double_vector>(new_vec,double_vec_list[index_to_delete]);
    }
    std::pair <MC_double_vector_vector,MC_double_vector_vector> MC_double_vector_vector::delete_index(const MC_int_vector& index_to_delete) const
    {
        std::set <int> set_index=index_to_delete.to_set();
        MC_double_vector_vector new_vec;
        MC_double_vector_vector deleted_vec;
        int N=size();
        for(int k=0;k<N;k++)
        {
            if(set_index.find(k)!=set_index.end())
                new_vec.add(double_vec_list[k]);
            else
                deleted_vec.add(double_vec_list[k]);
        }
        return std::pair <MC_double_vector_vector,MC_double_vector_vector> (new_vec,deleted_vec);
    }

    MC_double_vector_vector MC_double_vector_vector::repeat(const MC_double_vector& input,const int& N_repeat)
    {
        if(N_repeat<0)
        {std::cout<<"Error in MC_double_vector_vector::repeat(MC_double_vector,"<<N_repeat<<"), repeat number must be >0"<<std::endl;exit(-1);}

        MC_double_vector_vector vec(input);
        for(int k=1;k<N_repeat;++k)
            vec.add(input);
        return vec;
    }

    const MC_double_vector& MC_double_vector_vector::first() const
    {
        if(size()>0)
            return double_vec_list[0];
        else
        {
            std::cout<<"Error, call MC_double_vector_vector::first() with size=0"<<std::endl;exit(-1);
            exit(-1);
        }
    }
    MC_double_vector& MC_double_vector_vector::first()
    {
        if(size()>0)
            return double_vec_list[0];
        else
        {
            std::cout<<"Error, call MC_double_vector_vector::first() with size=0"<<std::endl;exit(-1);
            exit(-1);
        }
    }
    const MC_double_vector& MC_double_vector_vector::last() const
    {
        if(size()>0)
            return double_vec_list[size()-1];
        else
        {std::cout<<"Error, call MC_double_vector::last() with size=0"<<std::endl;exit(-1);}
    }
    MC_double_vector& MC_double_vector_vector::last()
    {
        if(size()>0)
            return double_vec_list[size()-1];
        else
        {std::cout<<"Error, call MC_double_vector::last() with size=0"<<std::endl;exit(-1);}
    }

    std::ostream& operator<<(std::ostream& stream,const MC_double_vector_vector& input)
    {
        int N=input.size();
        for(int k=0;k<N-1;k++)
            stream<<"("<<input[k]<<"); ";
        if(N>0)
            stream<<"("<<input[N-1]<<")";
        return stream;
    }
    MC_double_vector_vector operator+(const MC_double_vector_vector& vec,const double& to_add)
    {

        int N=vec.size();
        MC_double_vector_vector res;res.resize(N);
        for(int k=0;k<N;++k)
            res[k]=vec[k]+to_add;
        return res;
    }
    MC_double_vector_vector operator-(const MC_double_vector_vector& vec,const double& to_add)
    {
        int N=vec.size();
        MC_double_vector_vector res(N);res.resize(N);
        for(int k=0;k<N;++k)
            res[k]=vec[k]-to_add;
        return res;
    }

    MC_double_vector_vector::MC_double_vector_vector(const std::list <MC_double_vector>& vec)
    {
        for(std::list <MC_double_vector> :: const_iterator it=vec.begin();it!=vec.end();++it)
            add(*it);
    }

    const MC_double_vector* MC_double_vector_vector::pointer() const {return &double_vec_list[0];}
    MC_double_vector* MC_double_vector_vector::pointer_unprotected() {return &double_vec_list[0];}

    MC_double_vector_vector MC_double_vector_vector::operator()(const MC_int_vector& index) const
    {
        int N=size();
        int N2=index.size();
        MC_double_vector_vector new_vec;new_vec.resize(N2);
        for(int k=0;k<N2;++k)
        {
            if(index[k]<0 || index[k]>N)
            {std::cout<<"Error in MC_double_vector_vector::operator()(MC_double_vector), value index["<<k<<"]="<<index[k]<<" not correct for size="<<N<<std::endl;exit(-1);}
            new_vec[k]=double_vec_list[index[k]];
        }
        return new_vec;
    }
    MC_double_vector_vector MC_double_vector_vector::operator[](const MC_int_vector& index) const
    {return (*this)(index);}

    MC_double_vector_vector MC_double_vector_vector::empty(const int& N)
    {
        MC_double_vector_vector vec;vec.resize(N);
        return vec;
    }

}