MC_int_vector_vector.cpp

Go to the documentation of this file.

#include <MC_int_vector_vector.hpp>


namespace mesh_conv
{

    MC_int_vector_vector::MC_int_vector_vector(){}
    MC_int_vector_vector::MC_int_vector_vector(const MC_int_vector& v0){int_vec_list.push_back(v0);}
    MC_int_vector_vector::MC_int_vector_vector(const MC_int_vector& v0,const MC_int_vector& v1)
    {int_vec_list.push_back(v0);int_vec_list.push_back(v1);}
    MC_int_vector_vector::MC_int_vector_vector(const MC_int_vector& v0,const MC_int_vector& v1,const MC_int_vector& v2)
    {int_vec_list.push_back(v0);int_vec_list.push_back(v1);int_vec_list.push_back(v2);}
    MC_int_vector_vector::MC_int_vector_vector(const MC_int_vector& v0,const MC_int_vector& v1,const MC_int_vector& v2,const MC_int_vector& v3)
    {int_vec_list.push_back(v0);int_vec_list.push_back(v1);int_vec_list.push_back(v2);int_vec_list.push_back(v3);}

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

    const MC_int_vector& MC_int_vector_vector::operator()(const int& index) const
    {assert_bounds(index);return int_vec_list[index];}
    MC_int_vector& MC_int_vector_vector::operator()(const int& index)
    {assert_bounds(index);return int_vec_list[index];}
    const MC_int_vector& MC_int_vector_vector::operator[](const int& index) const
    {assert_bounds(index);return int_vec_list[index];}
    MC_int_vector& MC_int_vector_vector::operator[](const int& index)
    {assert_bounds(index);return int_vec_list[index];}

    int MC_int_vector_vector::size() const
    {return int_vec_list.size();}


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

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

        int_vec_list.resize(new_size);
        return *this;
    }
    MC_int_vector_vector& MC_int_vector_vector::add(const MC_int_vector& val){int_vec_list.push_back(val);return *this;}
    MC_int_vector_vector operator<<(const MC_int_vector_vector& vec,const MC_int_vector& value)
    {return MC_int_vector_vector(vec).add(value);}
    MC_int_vector_vector& MC_int_vector_vector::add(const MC_int_vector_vector& val)
    {
        int N=val.size();
        for(int k=0;k<N;++k)
            int_vec_list.push_back(val[k]);
        return *this;
    }
    MC_int_vector_vector operator<<(const MC_int_vector_vector& vec,const MC_int_vector_vector& to_add)
    {return MC_int_vector_vector(vec).add(to_add);}
    MC_int_vector_vector& MC_int_vector_vector::set(const int& k_index,const MC_int_vector& new_value)
    {
        if(k_index<0)
        {std::cout<<"Error in MC_int_vector_vector::set("<<k_index<<","<<new_value<<"), index must be >0"<<std::endl;exit(-1);}
        if(k_index>=size())
            int_vec_list.resize(k_index+1);
        int_vec_list[k_index]=new_value;
        return *this;
    }
    MC_int_vector_vector& MC_int_vector_vector::set(const MC_int_vector& k_index,const MC_int_vector_vector& new_value)
    {
        MC_int_vector_vector v_new_value=new_value;
        if(new_value.size()!=1 && new_value.size()!=k_index.size())
        {std::cout<<"Error in MC_int_vector_vector::set(MC_int_vector,MC_int_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_int_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_int_vector_vector,MC_int_vector> MC_int_vector_vector::delete_index(const int& index_to_delete) const
    {
        if(index_to_delete<0 || index_to_delete>=size())
        {std::cout<<"Error in MC_int_vector_vector::delete("<<index_to_delete<<", when size="<<size()<<std::endl;exit(-1);}
        MC_int_vector_vector new_vec;
        int N=size();
        for(int k=0;k<N;++k)
            if(k!=index_to_delete)
                new_vec.add(int_vec_list[k]);
        return std::pair <MC_int_vector_vector,MC_int_vector>(new_vec,int_vec_list[index_to_delete]);
    }
    std::pair <MC_int_vector_vector,MC_int_vector_vector> MC_int_vector_vector::delete_index(const MC_int_vector& index_to_delete) const
    {
        std::set <int> set_index=index_to_delete.to_set();
        MC_int_vector_vector new_vec;
        MC_int_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(int_vec_list[k]);
            else
                deleted_vec.add(int_vec_list[k]);
        }
        return std::pair <MC_int_vector_vector,MC_int_vector_vector> (new_vec,deleted_vec);
    }

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

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

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

    std::ostream& operator<<(std::ostream& stream,const MC_int_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_int_vector_vector operator+(const MC_int_vector_vector& vec,const int& to_add)
    {

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

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

    const MC_int_vector* MC_int_vector_vector::pointer() const{return &int_vec_list[0];}
    MC_int_vector* MC_int_vector_vector::pointer_unprotected(){return &int_vec_list[0];}

    MC_int_vector_vector MC_int_vector_vector::empty(const int& N)
    {MC_int_vector_vector vec;vec.resize(N);return vec;}
    MC_int_vector_vector MC_int_vector_vector::operator()(const MC_int_vector& index) const
    {
        int N=index.size();
        MC_int_vector_vector vec=MC_int_vector_vector::empty(N);

        int N_current=size();
        for(int k=0;k<N;++k)
        {
            int u=index[k];
            if(u<0 || u>=N_current)
            {std::cout<<"Error in MC_int_vector_vector::operator()(MC_int_vector ), at position k="<<k<<"/"<<N<<", index "<<u<<"is not correct for size "<<N_current<<std::endl;exit(-1);}
            vec[k]=int_vec_list[u];
        }
        return vec;
    }




}