point.hpp

Go to the documentation of this file.

#ifndef _POINT_H
#define _POINT_H

#include <cstddef>
#include <iostream>
#include <cstdlib>
#include <cassert>
#include <cstdarg>
#include <array>
#include <cmath>
#include <initializer_list>


template<std::size_t N>
class Point
{
    private:
        std::array<double, N> coordinates; 
        bool boundry = false; 
    public:
        Point();

        Point(const Point& other);

        Point(double val, ...);

        Point(std::initializer_list<double> l);


        Point(Point&& other);

        const Point& operator=(Point&& other);

        Point& operator=(const Point& other);

        void setCoord(unsigned int index, double val);

        void setCoords(double val, ...);

        double getCoord(unsigned int index) const;

        bool outOfBoundries();

        bool operator==(Point const& other);

        bool operator<(const Point& other) const;

        bool operator>=(const Point& other) const;

        bool operator<=(const Point& other) const;

        bool operator>(const Point&  other) const;
        
        double distance(const Point<N>& other) const;

        void toBoundry();

        bool isBoundry();

        template<std::size_t P>
        friend std::ostream& operator<<(std::ostream& os, const Point<P>& point);

};

template<std::size_t N>
Point<N>::Point(){
    //std::cout << "Point::Constructeur vide" << std::endl;
    for(unsigned i=0; i<N; i++){
        coordinates[i] = 0.0;
    }
}

template<std::size_t N>
Point<N>::Point(const Point& other){
    std::cout << "Point::Constructeur par copie" << std::endl;
    for(unsigned i = 0; i<N; i++){
        coordinates[i] = other.coordinates[i];
    }
    this->boundry=other.boundry;
}

template<std::size_t N>
Point<N>::Point(Point&& other){
    //std::cout << "Point::Constructeur par deplacement" << std::endl;
    coordinates = std::move(other.coordinates);
    this->boundry=other.boundry;
    other.coordinates.empty();
}

template<std::size_t N>
Point<N>::Point(double val, ...){
    //std::cout << "Point::Constructeur par valeur (...)" << std::endl;
    this->setCoord(0, val);
    va_list ap;

    va_start(ap,NULL);
    for (unsigned i = 1; i<N; i++){
        this->setCoord(i, va_arg(ap,double));
    }

    va_end(ap);
}

template<std::size_t N>
Point<N>::Point(std::initializer_list<double> l){
    //std::cout << "Point::Constructeur par valeur (initializer_list)" << std::endl;
    for(unsigned i=0; i<N; i++){
        coordinates[i] = 0.0;
    }
    size_t pos = 0;
    for(double v : l){
        if(pos >= N)
            break;
        coordinates[pos] = v;
        pos++;
    }
}

template<std::size_t N>
Point<N>& Point<N>::operator=(const Point& other){
    //std::cout << "Point::Operator=" << std::endl;
    for(unsigned i = 0; i<N; i++){
        coordinates[i] = other.coordinates[i];
    }
    this->boundry=other.boundry;
    return *this;
}

template<std::size_t N>
const Point<N>& Point<N>::operator=(Point&& other){
    //std::cout << "Point::Operateur d'affectation par deplacement" << std::endl;
    if (this != &other){
        coordinates = std::move(other.coordinates);
        other.coordinates.empty();
        delete other.coordinates;
    }
    this->boundry=other.boundry;
    return *this;
}

template<std::size_t P>
std::ostream& operator<<(std::ostream& os, const Point<P>& point){
    os << "(";
    for(unsigned i=0; i<P; i++){
        os << point.getCoord(i);
        if (i != P-1)
            os << ", ";
    }
    os << ")";
    return os;
}

template<std::size_t N>
void Point<N>::setCoord(unsigned int index, double val){
    if (index >= N) {
        std::cerr << "Depassement !" << std::endl;
        abort();
    }
    coordinates[index] = val;
}

template<std::size_t N>
void Point<N>::setCoords(double val, ...){
    this->setCoord(0, val);
    va_list ap;

    va_start(ap,NULL);
    for (unsigned i = 1; i<N; i++){
        this->setCoord(i, va_arg(ap,double));
    }
    va_end(ap);
}

template<std::size_t N>
double Point<N>::getCoord(unsigned int index) const{
    return coordinates[index];
}

template<std::size_t N>
bool Point<N>::outOfBoundries(){
    double MIN_VALUE = -250.0;
    double MAX_VALUE = 250.0;

    for (unsigned int i =0; i<N; i++){
        if (this->getCoord(i) < MIN_VALUE || this->getCoord(i) > MAX_VALUE){
            return true;
        }
    }

    return false;
}

template<std::size_t N>
bool Point<N>::operator==(Point<N> const& other){
    for (unsigned i=0; i<N; i++){
        if (other.getCoord(i) != this->getCoord(i))
            return false;
    }
    return true;
}

template<std::size_t N>
bool Point<N>::operator<(const Point<N>& other) const{
    for (unsigned i=0; i<N; i++){
        if (other.getCoord(i) > this->getCoord(i))
            return false;
    }
    return true;
}

template<std::size_t N>
bool Point<N>::operator>(const Point<N>& other) const{
    return !(*this<other || *this==other);
}

template<std::size_t N>
bool Point<N>::operator<=(const Point<N>& other) const{
    return !(*this>other);
}

template<std::size_t N>
bool Point<N>::operator>=(const Point<N>& other) const{
    return !(*this<other);
}

template<std::size_t N>
double Point<N>::distance(const Point<N>& other) const{
    Point<N> diffOfPoints;
    double dist = 0.0;
    for (unsigned int i=0; i<N; i++){
        dist += (this->getCoord(i)-other.getCoord(i))*(this->getCoord(i)-other.getCoord(i));
    } 
    return std::sqrt(dist);
}

template<std::size_t N>
void Point<N>::toBoundry(){
    boundry= true;
}

template<std::size_t N>
bool Point<N>::isBoundry(){
    return boundry;
}

#endif