Geometricpp.hpp

Ir para a documentação deste ficheiro.

 
/*
 *  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 3 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 <https://www.gnu.org/licenses/>.
 */
 
#ifndef GEOMETRICPP_HPP
#define GEOMETRICPP_HPP
 
#include <iostream>
#include <cmath>
#include <stdexcept>
 
#include <type_traits>
#include <utility>
 
namespace Geometricpp
{
    typedef double_t GEOMETRIC_SIDE;
 
    typedef double_t DIAGONAL;
 
    const double_t PI = 3.14159265358979323846;
 
    template <typename length>
    typename std::enable_if<std::is_arithmetic<length>::value, length>::type
    pitagoras_diagonais(length largest_diagonal, length smallest_diagonal)
    {
        if (largest_diagonal < smallest_diagonal)
        {
            throw std::invalid_argument("largest_diagonal parameter cannot be smaller than smallest_diagonal parameter");
        }
 
        return sqrt((largest_diagonal / 2) * (largest_diagonal / 2) +
                    (smallest_diagonal / 2) * (smallest_diagonal / 2));
    }
 
    template <typename T>
    typename std::enable_if<std::is_arithmetic<T>::value, T>::type
    pitagoras(T a, T b)
    {
        return std::sqrt(a * a + b * b);
    }
 
    namespace Quadrilaterals
    {
        class Square
        {
        private:
            GEOMETRIC_SIDE side_length;
 
        public:
            Square(GEOMETRIC_SIDE side_length) : side_length(side_length) {};
 
            double_t size() const;
 
            double_t area() const;
            double_t perimeter() const;
            double_t diagonal() const;
        };
 
        class Rectangle
        {
        private:
            GEOMETRIC_SIDE height, width;
 
        public:
            explicit Rectangle(GEOMETRIC_SIDE h, GEOMETRIC_SIDE w) : height(h), width(w)
            {
                if (height == width)
                {
                    throw std::invalid_argument("Sides can't be equal, at least one needs to be different.");
                }
            }
 
            std::pair<Geometricpp::GEOMETRIC_SIDE, Geometricpp::GEOMETRIC_SIDE> size() const;
 
            double_t area() const;
            double_t perimeter() const;
            double_t diagonal() const;
        };
 
        class Rhombus
        {
        private:
            DIAGONAL diagonal_a, diagonal_b;
 
        public:
            explicit Rhombus(double_t side, double_t angle)
            {
                double_t angle_radians = angle * PI / 180.0;
 
                diagonal_a = side * sqrt(2 * (1 + cos(angle_radians)));
                diagonal_b = side * sqrt(2 * (1 - cos(angle_radians)));
            }
 
            void show_diagonals() const;
 
            double_t area() const;
            double_t perimeter() const;
            double_t height() const;
 
            double_t inradius() const;
            double_t circumradius() const;
        };
    };
 
    // TODO
    // namespace Triangles
    // {
    // };
}
 
#endif