Speed.h

/***************************************************************************
 *   Copyright (C) 2019-2021 by Stefan Kebekus                             *
 *   stefan.kebekus@gmail.com                                              *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#pragma once
 
#include <QDataStream>
#include <QObject>
#include <QQmlEngine>
#include <QtMath>
 
#include "units/Distance.h"
#include "units/Timespan.h"
 
 
namespace Units {

    class Speed {
        Q_GADGET
        QML_VALUE_TYPE(speed)
 
    public:        
        Q_INVOKABLE static constexpr Units::Speed fromFPM(double speedInFPM)
        {
            Speed result;
            result._speedInMPS = speedInFPM/FPM_per_MPS;
            return result;
        }

        Q_INVOKABLE static constexpr Units::Speed fromMPS(double speedInMPS)
        {
            Speed result;
            result._speedInMPS = speedInMPS;
            return result;
        }
 

        Q_INVOKABLE static constexpr Units::Speed fromMPH(double speedInMPH)
        {
            Speed result;
            result._speedInMPS = speedInMPH*MPS_per_MPH;
            return result;
        }

        Q_INVOKABLE static constexpr Units::Speed fromKN(double speedInKT)
        {
            Speed result;
            result._speedInMPS = speedInKT / KN_per_MPS;
            return result;
        }

        Q_INVOKABLE static constexpr Units::Speed fromKMH(double speedInKMH)
        {
            Speed result;
            result._speedInMPS = speedInKMH / KMH_per_MPS;
            return result;
        }

        [[nodiscard]] Q_INVOKABLE bool isFinite() const
        {
            return std::isfinite(_speedInMPS);
        }

        [[nodiscard]] Q_INVOKABLE bool isNegative() const
        {
            return _speedInMPS < 0.0;
        }

        Q_INVOKABLE double operator/(Units::Speed rhs) const
        {
            if (qFuzzyIsNull(rhs._speedInMPS)) {
                return qQNaN();
}
            return _speedInMPS / rhs._speedInMPS;
        }

        Q_INVOKABLE Units::Speed operator+(Units::Speed rhs) const
        {
            return Units::Speed::fromMPS(_speedInMPS + rhs._speedInMPS);
        }

        Q_INVOKABLE Units::Speed operator-(Units::Speed rhs) const
        {
            return Units::Speed::fromMPS(_speedInMPS - rhs._speedInMPS);
        }

        [[nodiscard]] Q_INVOKABLE std::partial_ordering operator<=>(const Units::Speed& rhs) const = default;

        [[nodiscard]] Q_INVOKABLE double toFPM() const
        {
            return _speedInMPS * FPM_per_MPS;
        }

        [[nodiscard]] Q_INVOKABLE double toMPS() const
        {
            return _speedInMPS;
        }

        [[nodiscard]] Q_INVOKABLE double toMPH() const
        {
            return _speedInMPS/MPS_per_MPH;
        }

        [[nodiscard]] Q_INVOKABLE double toKN() const
        {
            return _speedInMPS * KN_per_MPS;
        }

        [[nodiscard]] Q_INVOKABLE double toKMH() const
        {
            return _speedInMPS * KMH_per_MPS;
        }

        static constexpr double FPM_per_MPS = 196.85039370079;

        static constexpr double MPS_per_MPH = 0.44704;

        static constexpr double KMH_per_MPS = 3.6;

        static constexpr double KN_per_MPS = 1.943844;
 
 

        static constexpr double KMH_per_KT = KMH_per_MPS / KN_per_MPS;
 
    private:
        // Speed in meters per second
        double _speedInMPS{ NAN };
    };
 
} // namespace Units
 
 
//
// Operations
//

inline Units::Speed operator*(double lhs, Units::Speed rhs)
{
    return Units::Speed::fromMPS(lhs*rhs.toMPS());
}

inline Units::Distance operator*(Units::Timespan lhs, Units::Speed rhs)
{
    return Units::Distance::fromM(lhs.toS() * rhs.toMPS());
}

inline Units::Distance operator*(Units::Speed lhs, Units::Timespan rhs)
{
    return Units::Distance::fromM(rhs.toS() * lhs.toMPS());
}

QDataStream & operator<<(QDataStream &out, Units::Speed speed);

auto operator>>(QDataStream &in, Units::Speed &speed) -> QDataStream &;
 
 
// Declare meta types
Q_DECLARE_METATYPE(Units::Speed)