elecPoint.hpp

Go to the documentation of this file.

#pragma once

/*   This file is part of rl-lib
 *
 *   Copyright (C) 2010,  Herve FREZZA-BUET
 *
 *   Author : Herve Frezza-Buet
 *
 *   Contributor :
 *
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public
 *   License (GPL) as published by the Free Software Foundation; either
 *   version 3 of the License, or any later version.
 *   
 *   This library 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 library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 *   Contact : Herve.Frezza-Buet@supelec.fr
 *
 */

#include <vector>
#include <cstdlib>
#include <cmath>
#include <iostream>

namespace elec {
  class Point {
  public:
    double x,y;
    
    Point() : x(0), y(0) {}
    Point(const Point& cp) : x(cp.x), y(cp.y) {}
    Point(double xx, double yy) : x(xx), y(yy) {}
    Point& operator=(const Point& cp) {
      x = cp.x;
      y = cp.y;
      return *this;
    }

    Point& operator=(double val) {
      x = val;
      y = val;
      return *this;
    }
  
    Point operator+(const Point& p) const {
      return {x+p.x, y+p.y};
    }
  
    Point operator-() const {
      return {-x,-y};
    }

    Point operator+() const {
      return {x,y};
    }

    Point operator-(const Point& p) const {
      return {x-p.x, y-p.y};
    }
  
    double operator*(const Point& p) const {
      return x*p.x + y*p.y;
    }

    Point operator&(const Point& p) const {
      return {x*p.x, y*p.y};
    }

    Point operator*() const {
      const Point& me = *this;
      return me/std::sqrt(me*me);
    }

    Point operator*(double a) const {
      return {x*a, y*a};
    }

    Point operator/(double a) const {
      return {x/a, y/a};
    }

    Point& operator+=(const Point& p) {
      x += p.x;
      y += p.y;
      return *this;
    }

    Point& operator-=(const Point& p) {
      x -= p.x;
      y -= p.y;
      return *this;
    }
  
    Point& operator*=(double a) {
      x *= a;
      y *= a;
      return *this;
    }
  
    Point& operator/=(double a) {
      x /= a;
      y /= a;
      return *this;
    }
  };

  inline std::ostream& operator<<(std::ostream& os, 
                                  const Point& p) {
    os << '(' << p.x << ", " << p.y << ')';
    return os;
  }
  
  inline Point uniform(const Point& A, const Point& B) {
    Point d = {std::rand()/(RAND_MAX+1.0),
               std::rand()/(RAND_MAX+1.0)};
    return A + (d & (B-A));
  }
  
  inline double d2(const Point& A, const Point& B) {
    Point tmp = B-A;
    return tmp*tmp;
  }

  inline double d(const Point& A, const Point& B) {
    return std::sqrt(d2(A,B));
  }

  template<typename OutputIt>
  void mesh(const Point& A, const Point& B,
            unsigned int nb_x,
            unsigned int nb_y,
            OutputIt it) {
    Point scale;
    Point D = B-A;
    for(unsigned int h = 0; h < nb_y; ++h) {
      scale.y = h/(double)(nb_y-1);
      for(unsigned int w = 0; w < nb_x; ++w) {
        scale.x = w/(double)(nb_x-1);
        *(it++) = A + (scale & D);
      }
    }
  }
}