Coord.h

/***************************************************************************
 * file:        Coord.h
 *
 * author:      Christian Frank
 *
 * copyright:   (C) 2004 Telecommunication Networks Group (TKN) at
 *              Technische Universitaet Berlin, Germany.
 *
 *              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.
 *              For further information see file COPYING
 *              in the top level directory
 ***************************************************************************
 * part of:     framework implementation developed by tkn
 **************************************************************************/


#ifndef _COORD_H
#define _COORD_H

#include <omnetpp.h>
#include "FWMath.h"

class Coord : public cPolymorphic
{
 public:
    double x,y;

    Coord(double _x=0, double _y=0) : x(_x), y(_y) {};


    Coord( const Coord& pos ) {
        x=pos.x;
        y=pos.y;
    }

    Coord( const Coord* pos ) {
        x=pos->x;
        y=pos->y;
    }

    std::string info() const {
        std::stringstream os;
        os << "(" << x << "," << y << ")";
        return os.str();
    }

    friend Coord operator+(const Coord& a, const Coord& b) {
        return Coord(a.x+b.x, a.y+b.y);
    }

    friend Coord operator-(const Coord& a, const Coord& b) {
        return Coord(a.x-b.x, a.y-b.y);
    }

    friend Coord operator*(const Coord& a, double f) {
        return Coord(a.x*f, a.y*f);
    }

    friend Coord operator/(const Coord& a, double f) {
        return Coord(a.x/f, a.y/f);
    }

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

    Coord operator=(const Coord& a) {
        x=a.x;
        y=a.y;
        return *this;
    }

    Coord operator-=(const Coord& a) {
        x-=a.x;
        y-=a.y;
        return *this;
    }

    friend bool operator==(const Coord& a, const Coord& b) {
        return FWMath::close(a.x,b.x) && FWMath::close(a.y,b.y);
    }

    friend bool operator!=(const Coord& a, const Coord& b) {
        return !(a==b);
    }

    double distance( const Coord& a ) const {
        Coord dist=*this-a;
        return sqrt( dist.x*dist.x + dist.y*dist.y);
    }

    double sqrdist( const Coord& a ) const {
        Coord dist=*this-a;
        return dist.x*dist.x + dist.y*dist.y;
    }

    double sqrTorusDist(const Coord& b, const Coord& playGround) const {
        double minTorDist;
        double torDist;
        torDist = FWMath::torDist(this->x,              b.x, this->y,                  b.y);
        minTorDist = torDist;
        torDist = FWMath::torDist(this->x+playGround.x, b.x, this->y,                  b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        torDist = FWMath::torDist(this->x-playGround.x, b.x, this->y,                  b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        torDist = FWMath::torDist(this->x,              b.x, this->y+playGround.y,     b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        torDist = FWMath::torDist(this->x,              b.x, this->y-playGround.y,     b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        torDist = FWMath::torDist(this->x+playGround.x, b.x, this->y+playGround.y,     b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        torDist = FWMath::torDist(this->x+playGround.x, b.x, this->y-playGround.y,     b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        torDist = FWMath::torDist(this->x-playGround.x, b.x, this->y+playGround.y,     b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        torDist = FWMath::torDist(this->x-playGround.x, b.x, this->y-playGround.y,     b.y);
        if(torDist < minTorDist) minTorDist = torDist;
        return minTorDist;
    }
};

#endif

---