ConstraintStrength.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/Container/Array.hpp"
 
#include "CeresEngine/Math/Math.hpp"
 
namespace CeresEngine::Constraint {
 
    class ConstraintSymbolicWeight final {
    private:
        Array<double, 3> mValues;
 
    public:
        constexpr ConstraintSymbolicWeight() : ConstraintSymbolicWeight(0, 0, 0) {}
        constexpr ConstraintSymbolicWeight(const double w1, const double w2, const double w3) : mValues{w1, w2, w3} {}
 
        [[nodiscard]] ConstraintSymbolicWeight& negate();
        [[nodiscard]] ConstraintSymbolicWeight& operator*=(double n);
        [[nodiscard]] ConstraintSymbolicWeight& operator/=(double n);
        [[nodiscard]] ConstraintSymbolicWeight& operator+=(const ConstraintSymbolicWeight& n);
        [[nodiscard]] ConstraintSymbolicWeight& operator-=(const ConstraintSymbolicWeight& n);
 
        [[nodiscard]] bool isNegative() const;
        [[nodiscard]] constexpr double asDouble() const { return mValues[2] + mValues[1] * 10000. + mValues[0] * 10000000.; }
        [[nodiscard]] constexpr size_t levels() const { return 3; }
 
    public:
        static const ConstraintSymbolicWeight zero;
 
    public:
        friend bool operator<(const ConstraintSymbolicWeight& lhs, const ConstraintSymbolicWeight& rhs);
        friend bool operator<=(const ConstraintSymbolicWeight& lhs, const ConstraintSymbolicWeight& rhs);
        friend bool operator==(const ConstraintSymbolicWeight& lhs, const ConstraintSymbolicWeight& rhs);
        friend bool operator!=(const ConstraintSymbolicWeight& lhs, const ConstraintSymbolicWeight& rhs);
        friend bool operator>(const ConstraintSymbolicWeight& lhs, const ConstraintSymbolicWeight& rhs);
        friend bool operator>=(const ConstraintSymbolicWeight& lhs, const ConstraintSymbolicWeight& rhs);
    };
 
    inline ConstraintSymbolicWeight operator*(ConstraintSymbolicWeight w, const double n) { return w *= n; }
    inline ConstraintSymbolicWeight operator/(ConstraintSymbolicWeight w, const double n) { return w /= n; }
    inline ConstraintSymbolicWeight operator+(ConstraintSymbolicWeight w, const ConstraintSymbolicWeight& n) { return w += n; }
    inline ConstraintSymbolicWeight operator-(ConstraintSymbolicWeight w, const ConstraintSymbolicWeight& n) { return w -= n; }
 
    // ---------------------------------------------------------------------------------------------
 
    class ConstraintStrength final {
    private:
        ConstraintSymbolicWeight mSymbolicWeight;
        double mWeight = 1.0;
 
    public:
        constexpr ConstraintStrength(const ConstraintSymbolicWeight& symbolicWeight, const double w) : mSymbolicWeight{symbolicWeight}, mWeight{w} {}
 
        constexpr ConstraintStrength(const double a, const double b, const double c, const double w = 1.0) : mSymbolicWeight{a, b, c}, mWeight(w) {}
 
        [[nodiscard]] bool isRequired() const { return mSymbolicWeight == required.mSymbolicWeight; }
 
        [[nodiscard]] const ConstraintSymbolicWeight& getSymbolicWeight() const { return mSymbolicWeight; }
 
        [[nodiscard]] double getWeight() const { return mWeight; }
 
        [[nodiscard]] double getAdjustedWeight() const { return std::min(mSymbolicWeight.asDouble() * mWeight, required.mSymbolicWeight.asDouble()); }
 
    public:
        static const ConstraintStrength required;
 
        static const ConstraintStrength strong;
 
        static const ConstraintStrength medium;
 
        static const ConstraintStrength weak;
 
        friend bool operator==(const ConstraintStrength& lhs, const ConstraintStrength& rhs);
        friend bool operator!=(const ConstraintStrength& lhs, const ConstraintStrength& rhs);
        friend bool operator<=(const ConstraintStrength& lhs, const ConstraintStrength& rhs);
        friend bool operator<(const ConstraintStrength& lhs, const ConstraintStrength& rhs);
        friend bool operator>=(const ConstraintStrength& lhs, const ConstraintStrength& rhs);
        friend bool operator>(const ConstraintStrength& lhs, const ConstraintStrength& rhs);
        friend ConstraintStrength operator*(ConstraintStrength lhs, double w);
    };
 
    inline const ConstraintStrength ConstraintStrength::required{
        std::numeric_limits<double>::max(),
        std::numeric_limits<double>::max(),
        std::numeric_limits<double>::max(),
    };
    inline const ConstraintStrength ConstraintStrength::strong{1, 0, 0};
    inline const ConstraintStrength ConstraintStrength::medium{0, 1, 0};
    inline const ConstraintStrength ConstraintStrength::weak{0, 0, 1};
 
    inline bool operator==(const ConstraintStrength& lhs, const ConstraintStrength& rhs) { return lhs.mSymbolicWeight == rhs.mSymbolicWeight; }
    inline bool operator!=(const ConstraintStrength& lhs, const ConstraintStrength& rhs) { return lhs.mSymbolicWeight != rhs.mSymbolicWeight; }
    inline bool operator<=(const ConstraintStrength& lhs, const ConstraintStrength& rhs) { return lhs.mSymbolicWeight <= rhs.mSymbolicWeight; }
    inline bool operator<(const ConstraintStrength& lhs, const ConstraintStrength& rhs) { return lhs.mSymbolicWeight < rhs.mSymbolicWeight; }
    inline bool operator>=(const ConstraintStrength& lhs, const ConstraintStrength& rhs) { return lhs.mSymbolicWeight >= rhs.mSymbolicWeight; }
    inline bool operator>(const ConstraintStrength& lhs, const ConstraintStrength& rhs) { return lhs.mSymbolicWeight > rhs.mSymbolicWeight; }
    inline ConstraintStrength operator*(ConstraintStrength lhs, const double w) {
        lhs.mWeight = w;
        return lhs;
    }
 
    std::ostream& operator<<(std::ostream& str, const ConstraintStrength& s);
 
} // namespace CeresEngine::Constraint