MC_v4d.cpp

Go to the documentation of this file.

#include <MC_matrix.hpp>
#include <MC_v3d.hpp>
#include <MC_string_helper.hpp>
#include <MC_v4d.hpp>

#include <cmath>



namespace mesh_conv
{

MC_v4d::MC_v4d()
{v[0]=0;v[1]=0;v[2]=0;v[3]=0;}

MC_v4d::MC_v4d(const double& x,const double& y,const double& z,const double& w)
{v[0]=x;v[1]=y;v[2]=z;v[3]=w;}

MC_v4d::~MC_v4d(){}

const double& MC_v4d::operator()(const int& k_dim) const
{
    if(k_dim<0 || k_dim>3)
    {std::cout<<"Error in const MC_v4d("<<k_dim<<"), size must be 0,1 or 2"<<std::endl;}
    return v[k_dim];
}
double& MC_v4d::operator()(const int& k_dim)
{
    if(k_dim<0 || k_dim>3)
    {std::cout<<"Error in MC_v4d("<<k_dim<<"), size must be 0,1,2 or 3"<<std::endl;}
    return v[k_dim];
}
const double& MC_v4d::operator[](const int& k_dim) const
{
    if(k_dim<0 || k_dim>3)
    {std::cout<<"Error in const MC_v4d["<<k_dim<<"], size must be 0,1,2 or 3"<<std::endl;}
    return v[k_dim];
}
double& MC_v4d::operator[](const int& k_dim)
{
    if(k_dim<0 || k_dim>3)
    {std::cout<<"Error in MC_v4d["<<k_dim<<"], size must be 0,1,2 or 3"<<std::endl;}
    return v[k_dim];
}
MC_v4d::MC_v4d(const MC_v4d& _v)
{v[0]=_v[0];v[1]=_v[1];v[2]=_v[2];v[3]=_v[3];}

MC_v4d::MC_v4d(const double* _v)
{v[0]=_v[0];v[1]=_v[1];v[2]=_v[2];v[3]=_v[3];}

MC_v4d MC_v4d::operator-() const
{return MC_v4d(-v[0],-v[1],-v[2],-v[3]);}


MC_v4d operator+(const MC_v4d& vec,const double& to_add)
{return MC_v4d(vec[0]+to_add,vec[1]+to_add,vec[2]+to_add,vec[3]+to_add);}
MC_v4d operator-(const MC_v4d& vec,const double& to_sub)
{return MC_v4d(vec[0]-to_sub,vec[1]-to_sub,vec[2]-to_sub,vec[3]-to_sub);}
MC_v4d operator*(const MC_v4d& vec,const double& to_mult)
{return MC_v4d(vec[0]*to_mult,vec[1]*to_mult,vec[2]*to_mult,vec[3]*to_mult);}
MC_v4d operator*(const double& to_mult,const MC_v4d& vec)
{return vec*to_mult;}

MC_v4d operator/(const MC_v4d& vec,const double& to_subdiv)
{
    double epsilon=0.000001;
    if(fabs(to_subdiv)<epsilon)
    {std::cout<<"Error in MC_v4d("<<vec<<"/"<<to_subdiv<<", divide by zero"<<std::endl;exit(-1);}

    return MC_v4d(vec[0]/to_subdiv,vec[1]/to_subdiv,vec[2]/to_subdiv,vec[3]/to_subdiv);
}
MC_v4d operator+(const MC_v4d& vec,const MC_v4d& to_add)
{return MC_v4d(vec[0]+to_add[0],vec[1]+to_add[1],vec[2]+to_add[2],vec[3]+to_add[3]);}
MC_v4d operator-(const MC_v4d& vec,const MC_v4d& to_sub)
{return MC_v4d(vec[0]-to_sub[0],vec[1]-to_sub[1],vec[2]-to_sub[2],vec[3]-to_sub[3]);}

MC_v4d& MC_v4d::operator+=(const double& to_add)
{
    v[0]+=to_add;v[1]+=to_add;v[2]+=to_add;v[3]+=to_add;
    return *this;
}

MC_v4d& MC_v4d::operator-=(const double& to_sub)
{
    v[0]-=to_sub;v[1]-=to_sub;v[2]-=to_sub;v[3]-=to_sub;
    return *this;
}
MC_v4d& MC_v4d::operator*=(const double& to_mult)
{
    v[0]*=to_mult;v[1]*=to_mult;v[2]*=to_mult;v[3]*=to_mult;
    return *this;
}
MC_v4d& MC_v4d::operator/=(const double& to_subdiv)
{
    double epsilon=0.000001;
    if(fabs(to_subdiv)<epsilon)
    {std::cout<<"Error in MC_v4d("<<*this<<"/="<<to_subdiv<<", divide by zero"<<std::endl;exit(-1);}

    v[0]/=to_subdiv;v[1]/=to_subdiv;v[2]/=to_subdiv;v[3]/=to_subdiv;
    return *this;
}
MC_v4d& MC_v4d::operator+=(const MC_v4d& to_add){
    v[0]+=to_add[0];v[1]+=to_add[1];v[2]+=to_add[2];v[3]+=to_add[3];
    return *this;
}
MC_v4d& MC_v4d::operator-=(const MC_v4d& to_sub){
    v[0]-=to_sub[0];v[1]-=to_sub[1];v[2]-=to_sub[2];v[3]-=to_sub[3];return *this;
}


std::ostream& operator<<(std::ostream& stream,const MC_v4d& v)
{
    stream<<"("<<v[0]<<","<<v[1]<<","<<v[2]<<","<<v[3]<<")";
    return stream;
}

MC_v4d::MC_v4d(const std::string& s)
{
    std::vector <std::string> v_s=mesh_conv::MC_string_tokenizer::tokenize(s," (),;");

    int number_ok=0;
    for(unsigned int k=0;number_ok<3 && k<v_s.size();k++)
    {
        bool is_converted=false;
        double temp_value=MC_string_converter::value_of<double>(v_s[k],&is_converted);
        if(is_converted==true)
            v[number_ok++]=temp_value;
    }

}


    MC_v4d& operator>>(std::istream& stream,MC_v4d& vec)
    {
        int current_position=0;
        std::string temp_string;
        while(current_position<4 && stream.good())
        {
            if(stream>>temp_string)
            {
                std::vector <std::string> v_token=MC_string_tokenizer::tokenize(temp_string,",;() ");

                for(unsigned int k=0;current_position<4 && k<v_token.size();++k)
                {
                    bool is_converted=false;
                    double temp_value=MC_string_converter::value_of<double>(v_token[k],&is_converted);
                    if(is_converted==true)
                        vec[current_position++]=temp_value;
                }
            }
        }
        return vec;
    }

    MC_v4d& MC_v4d::scale(const double& sx,const double& sy,const double& sz,const double& sw)
    {v[0]*=sx;v[1]*=sy;v[2]*=sz;v[3]*=sw;return *this;}
    MC_v4d MC_v4d::mask(const double& sx,const double& sy,const double& sz,const double& sw) const
    {return MC_v4d(v[0]*sx,v[1]*sy,v[2]*sz,v[3]*sw);}
    MC_v4d& MC_v4d::scale(const MC_v4d& scaling){v[0]*=scaling[0];v[1]*=scaling[1];v[2]*=scaling[2];v[3]*=scaling[3];return *this;}
    MC_v4d MC_v4d::mask(const MC_v4d& scaling) const{return MC_v4d(v[0]*scaling[0],v[1]*scaling[1],v[2]*scaling[2],v[3]*scaling[3]);}
    MC_v4d& MC_v4d::scale(const double& scaling){return (*this)*=scaling;}
    MC_v4d MC_v4d::scale(const double& scaling) const{return (*this)*scaling;}


    double MC_v4d::dot(const MC_v4d& vec) const
    {return v[0]*vec[0]+v[1]*vec[1]+v[2]*vec[2]+v[3]*vec[3];}
    double MC_v4d::norm() const
    {return sqrt(dot(*this));}
    MC_v4d MC_v4d::normalized() const
    {
        double epsilon=0.000001;
        double n=norm();
        if(n<epsilon)
        {std::cout<<"Warning in MC_v4d::normalized(), norm is "<<n<<std::endl; return MC_v4d(0,0,1,0);}
        return (*this)/n;
    }




    MC_v4d& MC_v4d::operator*=(const MC_matrix& M)
    {M.internal_product(this); return *this;}

    MC_v4d::MC_v4d(const MC_matrix& M)
    {
        if( ( M.size_1()==4 && M.size_2()==1) ||
            ( M.size_2()==4 && M.size_1()==1) )
        {v[0]=M(0);v[1]=M(1);v[2]=M(2);v[3]=M(3);}
    }
    MC_v4d& MC_v4d::set_v3d(const MC_v3d& vec)
    {v[0]=vec[0];v[1]=vec[1];v[2]=vec[2];return *this;}

    const double* MC_v4d::pointer() const
    {return &v[0];}

}