a_plucker.cxx

Go to the documentation of this file.

/*
Copyright 2010-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     <math.h>           // math routines
#include "a_plucker.h"
 
//---------------------------------------------------------------------------
a_plucker::a_plucker()
: p1_(0.,0.,0.), p2_(0.,0.,0.)
{}
 
//---------------------------------------------------------------------------
a_plucker::a_plucker(double ax, double ay, double az, double bx, double by, double bz)
: p1_(ax,ay,az), p2_(bx,by,bz) 
{
}
//---------------------------------------------------------------------------
a_plucker::a_plucker(const a_plucker & f)
: p1_(f.p1_), p2_(f.p2_)
{}
//---------------------------------------------------------------------------
a_plucker& a_plucker::operator=(const a_plucker& f)
{
        p1_ = f.p1();
        p2_ = f.p2();
        return *this;
}
//---------------------------------------------------------------------------
a_plucker& a_plucker::operator-()
{
        p1_.operator-();
        p2_.operator-();
        return *this;
}
//---------------------------------------------------------------------------
a_plucker a_plucker::operator+(const a_plucker& b)
{
        a_plucker b2 = *this;
        return b2 += b;
}
//---------------------------------------------------------------------------
a_plucker a_plucker::operator-(const a_plucker& b)
{
        a_plucker b2 = *this;
        return b2 -= b;
}
//---------------------------------------------------------------------------
a_plucker& a_plucker::operator+=(const a_plucker& b)
{
        p1_ += b.p1_;
        p2_ += b.p2_;
        return *this;
}
//---------------------------------------------------------------------------
a_plucker& a_plucker::operator-=(const a_plucker& b)
{
        p1_ -= b.p1_;
        p2_ -= b.p2_;
        return *this;
}
//---------------------------------------------------------------------------
a_plucker& a_plucker::operator*=(const double b)
{
        p1_ *= b;
        p2_ *= b;
        return *this;
}
//---------------------------------------------------------------------------
a_plucker& a_plucker::operator/=(const double b)
{
        p1_ /= b;
        p2_ /= b;
        return *this;
}
//---------------------------------------------------------------------------
bool a_plucker::operator==(const a_plucker& a) const
{
        return (a.p1_ == this->p1_ && a.p2_ == this->p2_);
}
//---------------------------------------------------------------------------
bool a_plucker::operator!=(const a_plucker& a) const
{
  return !(*this==a);
}
//---------------------------------------------------------------------------
void a_plucker::read(std::istream &in)
{
        in >> p1_;
        in >> p2_;
}
//---------------------------------------------------------------------------
void a_plucker::write(std::ostream &o) const
{
        o << p1_ << " " << p2_;
}
//***************************************************************************
//---------------------------------------------------------------------------
std::istream& operator>> (std::istream& i, a_plucker& f)
{
        f.read(i);
        return i;
}
//---------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& o, const a_plucker& f)
{
        f.write(o);
        return o;
}
//---------------------------------------------------------------------------
std::istream& operator>> (std::istream& i, a_plucker* f)
{
        f->read(i);
        return i;
}
//---------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& o, const a_plucker* f)
{
        f->write(o);
        return o;
}
//***************************************************************************
//---------------------------------------------------------------------------
double operator*(const a_plucker & a, const a_plucker & b)
{
        return a.p1()*b.p2()+a.p2()*b.p1();
}