e_point.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2011 Pierre SMARS (smars@yuntech.edu.tw)
         This program 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 2 of the License, or
         (at your option) any later version.
 
         This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "e_point.h"
#include <math.h>
 
//---------------------------------------------------------------------------
e_point& e_point::operator+=(const e_point& p)
{
        x_ += p.x();
        y_ += p.y();
        z_ += p.z();
        return *this;
}
//---------------------------------------------------------------------------
e_point& e_point::operator-=(const e_point& p)
{
        x_ -= p.x();
        y_ -= p.y();
        z_ -= p.z();
        return *this;
}
//---------------------------------------------------------------------------
double e_point::operator*=(const e_point& p)
{
        return x_*p.x()+y_*p.y()+z_*p.z();
}
//-operator*=----------------------------------------------------------------
e_point & e_point::operator*=(const double v)
{
        x_ *= v;
        y_ *= v;
        z_ *= v;
        return (*this);
}
//-operator/=----------------------------------------------------------------
e_point & e_point::operator/=(const double v)
{
        x_ /= v;
        y_ /= v;
        z_ /= v;
        return (*this);
}
//-sumsq---------------------------------------------------------------------
double e_point::sumsq() const
{
        return x_*x_+y_*y_+z_*z_;
}
//-norm----------------------------------------------------------------------
double e_point::norm() const
{
        return sqrt(sumsq());
}
//-normalise-----------------------------------------------------------------
e_point& e_point::normalise()
{
        double n = norm();
        if (n != 0) operator/=(n);
        return *this;
}
//***************************************************************************
//-operator+-----------------------------------------------------------------
e_point operator+(e_point& a, e_point& b)
{
        e_point r = a;
        return r += b;
}
//-operator------------------------------------------------------------------
e_point operator-(e_point& a, e_point& b)
{
        e_point r = a;
        return r -= b;
}
//-operator*-----------------------------------------------------------------
double operator*(e_point& a, e_point& b)
{
        e_point r = a;
        return r *= b;
}
//-operator*-----------------------------------------------------------------
e_point operator*(double v, e_point& a)
{
        e_point r = a;
        return r *= v;
}
//-operator*-----------------------------------------------------------------
e_point operator*(e_point& a, double v)
{
        e_point r = a;
        return r *= v;
}
//-cross---------------------------------------------------------------------
e_point cross(e_point& a, e_point& b)
{
        e_point r;
        r.x(a.y()*b.z()-a.z()*b.y());
        r.y(a.z()*b.x()-a.x()*b.z());
        r.z(a.x()*b.y()-a.y()*b.x());
        return r;
}
//***************************************************************************
//---------------------------------------------------------------------------
std::istream& operator>> (std::istream& i, e_point& p)
{
        i >> p.x_;
        i >> p.y_;
        i >> p.z_;
        return i;
}
//---------------------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const e_point& p)
{
        o << p.x() << " ";
        o << p.y() << " ";
        o << p.z() << " " << std::endl;
        return o;
}
//---------------------------------------------------------------------------
std::istream& operator>> (std::istream& i, e_point* p)
{
        i >> p->x_;
        i >> p->y_;
        i >> p->z_;
        return i;
}
//---------------------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const e_point* p)
{
        o << p->x() << " ";
        o << p->y() << " ";
        o << p->z() << " " << std::endl;
        return o;
}
//---------------------------------------------------------------------------
void e_point::print(std::ostream& o)
{
        o << "d  " << this->norm() << std::endl;
        o << "dx " << this->x() << std::endl;
        o << "dy " << this->y() << std::endl;
        o << "dz " << this->z() << std::endl;
        e_point a(*this);
        a.normalise();
        o << "cx " << a.x() << " " << 180/3.141592653589*acos(a.x()) << std::endl;
        o << "cy " << a.y() << " " << 180/3.141592653589*acos(a.y()) << std::endl;
        o << "cz " << a.z() << " " << 180/3.141592653589*acos(a.z()) << std::endl;
}