e_point.h

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/>.
*/
#ifndef _E_POINT_H_
#define _E_POINT_H_
 
// .NAME e_point
// .PORTABILITY : ansi C++
// .SECTION Author
// Pierre Smars
 
#include <iostream>
#include "a_point.h"
 
class e_point : public a_point
{
        public:
                inline e_point() : x_(0), y_(0), z_(0) {};
                inline e_point(double x, double y, double z) : x_(x), y_(y), z_(z) {}
                inline e_point(const double x[3]) : x_(x[0]), y_(x[1]), z_(x[2]) {}
                inline e_point(const e_point& p) {x_ = p.x_; y_ = p.y_; z_ = p.z_;}
 
                //: get coordinates
                inline double   x() const { return x_; };
                inline double   y() const { return y_; };
                inline double   z() const { return z_; };
 
                //: set coordinates
                inline void     x(double v) { x_ = v; };
                inline void     y(double v) { y_ = v; };
                inline void     z(double v) { z_ = v; };
 
                e_point& operator+=(const e_point&);
                e_point& operator-=(const e_point&);
                double   operator*=(const e_point&);
                e_point& operator*=(const double v);
                e_point& operator/=(const double v);
 
                e_point& operator/=(const e_point&);
                double sumsq() const;
                double norm() const;
                e_point& normalise();
                void print(std::ostream& o);
 
                //: input/output
                friend   std::istream&    operator>> (std::istream& i, e_point& p);
                friend   std::ostream&    operator<< (std::ostream& o, const e_point& p);
                friend   std::istream&    operator>> (std::istream& i, e_point* p);
                friend   std::ostream&    operator<< (std::ostream& o, const e_point* p);
 
        protected:
                double   x_;
                double   y_;
                double   z_;
                double  err_;
};
 
e_point operator+(e_point& a, e_point& b);
e_point operator-(e_point& a, e_point& b);
double operator*(e_point& a, e_point& b);
e_point operator*(double v, e_point& a);
e_point operator*(e_point& a, double v);
e_point cross(e_point& a, e_point& b);
 
#endif