ConstraintExpression.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 "ConstraintVariable.hpp"
 
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <vector>
 
namespace CeresEngine::Constraint {
 
    class ConstraintExpression {
    public:
        class Term;
 
    private:
        Vector<Term> mTerms;
        double mConstant;
 
    public:
        ConstraintExpression(const double constant = 0.0) : mConstant(constant) {}
        ConstraintExpression(const Term& term, const double constant = 0.0) : mTerms(1, term), mConstant(constant) {}
        ConstraintExpression(Vector<Term> terms, const double constant = 0.0) : mTerms(std::move(terms)), mConstant(constant) {}
 
        ConstraintExpression(const ConstraintExpression&) = default;
        ConstraintExpression& operator=(const ConstraintExpression&) = default;
 
        ConstraintExpression& operator=(ConstraintExpression&&) noexcept = default;
        ConstraintExpression(ConstraintExpression&&) noexcept = default;
 
        ~ConstraintExpression() = default;
 
    public:
        [[nodiscard]] const Vector<Term>& getTerms() const { return mTerms; }
 
        [[nodiscard]] double getConstant() const { return mConstant; }
 
        [[nodiscard]] double getValue() const {
            double result = mConstant;
 
            for(const Term& term : mTerms) {
                result += term.getValue();
            }
 
            return result;
        }
 
    public:
        class Term {
        private:
            ConstraintVariable mVariable;
            double mCoefficient;
 
        public:
            Term(ConstraintVariable variable, const double coefficient = 1.0) : mVariable(std::move(variable)), mCoefficient(coefficient) {}
 
            // to facilitate efficient map -> vector copies
            Term(const std::pair<const ConstraintVariable, double>& pair) : mVariable(pair.first), mCoefficient(pair.second) {}
 
            Term(const Term&) = default;
            Term& operator=(const Term&) = default;
 
            Term(Term&&) noexcept = default;
            Term& operator=(Term&&) noexcept = default;
 
            ~Term() = default;
 
        public:
            [[nodiscard]] const ConstraintVariable& getVariable() const { return mVariable; }
 
            [[nodiscard]] double getCoefficient() const { return mCoefficient; }
 
            [[nodiscard]] double getValue() const { return mCoefficient * mVariable.getValue(); }
        };
    };
 
} // namespace CeresEngine::Constraint