From 1baa8d68c7c466e5f39b658a0640f96c705c3600 Mon Sep 17 00:00:00 2001 From: Paul Davis Date: Wed, 10 Jun 2020 14:39:52 -0600 Subject: [PATCH] Canvas: reindent Kiwi code, and provide operator<<(ostream&) for several objects --- libs/canvas/kiwi/constraint.h | 183 ++++++++++++++++++++-------------- libs/canvas/kiwi/expression.h | 82 +++++++++------ libs/canvas/kiwi/term.h | 7 ++ libs/canvas/kiwi/variable.h | 2 +- 4 files changed, 165 insertions(+), 109 deletions(-) diff --git a/libs/canvas/kiwi/constraint.h b/libs/canvas/kiwi/constraint.h index 9d8322b94d..9b4617b120 100644 --- a/libs/canvas/kiwi/constraint.h +++ b/libs/canvas/kiwi/constraint.h @@ -1,11 +1,12 @@ /*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ + | Copyright (c) 2013-2017, Nucleic Development Team. + | + | Distributed under the terms of the Modified BSD License. + | + | The full license is in the file LICENSE, distributed with this software. + |----------------------------------------------------------------------------*/ #pragma once +#include #include #include #include "expression.h" @@ -19,101 +20,129 @@ namespace kiwi enum RelationalOperator { - OP_LE, - OP_GE, - OP_EQ + OP_LE, + OP_GE, + OP_EQ }; +static std::ostream& operator<< (std::ostream& o, RelationalOperator op) +{ + switch (op) { + case OP_LE: + o << "<="; + break; + case OP_GE: + o << ">="; + break; + case OP_EQ: + o << "=="; + break; + } + return o; +} + class Constraint { -public: - Constraint() : m_data(0) {} + public: + Constraint() : m_data(0) {} - Constraint(const Expression &expr, - RelationalOperator op, - double strength = strength::required) : m_data(new ConstraintData(expr, op, strength)) {} + Constraint(const Expression &expr, + RelationalOperator op, + double strength = strength::required) : m_data(new ConstraintData(expr, op, strength)) {} - Constraint(const Constraint &other, double strength) : m_data(new ConstraintData(other, strength)) {} + Constraint(const Constraint &other, double strength) : m_data(new ConstraintData(other, strength)) {} - ~Constraint() {} + ~Constraint() {} - const Expression &expression() const - { - return m_data->m_expression; - } + const Expression &expression() const + { + return m_data->m_expression; + } - RelationalOperator op() const - { - return m_data->m_op; - } + RelationalOperator op() const + { + return m_data->m_op; + } - double strength() const - { - return m_data->m_strength; - } + double strength() const + { + return m_data->m_strength; + } - bool operator!() const - { - return !m_data; - } + bool operator!() const + { + return !m_data; + } -private: - static Expression reduce(const Expression &expr) - { - std::map vars; - typedef std::vector::const_iterator iter_t; - iter_t end = expr.terms().end(); - for (iter_t it = expr.terms().begin(); it != end; ++it) - vars[it->variable()] += it->coefficient(); - std::vector terms(vars.begin(), vars.end()); - return Expression(terms, expr.constant()); - } + bool involves (Variable const & v) const { + if (expression().involves (v)) { + return true; + } + return false; + } - class ConstraintData : public SharedData - { + private: + static Expression reduce(const Expression &expr) + { + std::map vars; + typedef std::vector::const_iterator iter_t; + iter_t end = expr.terms().end(); + for (iter_t it = expr.terms().begin(); it != end; ++it) + vars[it->variable()] += it->coefficient(); + std::vector terms(vars.begin(), vars.end()); + return Expression(terms, expr.constant()); + } - public: - ConstraintData(const Expression &expr, - RelationalOperator op, - double strength) : SharedData(), - m_expression(reduce(expr)), - m_strength(strength::clip(strength)), - m_op(op) {} + class ConstraintData : public SharedData + { - ConstraintData(const Constraint &other, double strength) : SharedData(), - m_expression(other.expression()), - m_strength(strength::clip(strength)), - m_op(other.op()) {} + public: + ConstraintData(const Expression &expr, + RelationalOperator op, + double strength) : SharedData(), + m_expression(reduce(expr)), + m_strength(strength::clip(strength)), + m_op(op) {} - ~ConstraintData() {} + ConstraintData(const Constraint &other, double strength) : SharedData(), + m_expression(other.expression()), + m_strength(strength::clip(strength)), + m_op(other.op()) {} - Expression m_expression; - double m_strength; - RelationalOperator m_op; + ~ConstraintData() {} - private: - ConstraintData(const ConstraintData &other); + Expression m_expression; + double m_strength; + RelationalOperator m_op; - ConstraintData &operator=(const ConstraintData &other); - }; + private: + ConstraintData(const ConstraintData &other); - SharedDataPtr m_data; + ConstraintData &operator=(const ConstraintData &other); + }; - friend bool operator<(const Constraint &lhs, const Constraint &rhs) - { - return lhs.m_data < rhs.m_data; - } + SharedDataPtr m_data; - friend bool operator==(const Constraint &lhs, const Constraint &rhs) - { - return lhs.m_data == rhs.m_data; - } + friend bool operator<(const Constraint &lhs, const Constraint &rhs) + { + return lhs.m_data < rhs.m_data; + } - friend bool operator!=(const Constraint &lhs, const Constraint &rhs) - { - return lhs.m_data != rhs.m_data; - } + friend bool operator==(const Constraint &lhs, const Constraint &rhs) + { + return lhs.m_data == rhs.m_data; + } + + friend bool operator!=(const Constraint &lhs, const Constraint &rhs) + { + return lhs.m_data != rhs.m_data; + } }; +static std::ostream& operator<< (std::ostream& o, kiwi::Constraint const & c) +{ + return o << c.expression() << " OP " << c.op(); +} + } // namespace kiwi diff --git a/libs/canvas/kiwi/expression.h b/libs/canvas/kiwi/expression.h index e2b5ae6683..eac318c09b 100644 --- a/libs/canvas/kiwi/expression.h +++ b/libs/canvas/kiwi/expression.h @@ -1,11 +1,12 @@ /*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ + | Copyright (c) 2013-2017, Nucleic Development Team. + | + | Distributed under the terms of the Modified BSD License. + | + | The full license is in the file LICENSE, distributed with this software. + |----------------------------------------------------------------------------*/ #pragma once +#include #include #include "term.h" @@ -15,38 +16,57 @@ namespace kiwi class Expression { -public: - Expression(double constant = 0.0) : m_constant(constant) {} + public: + Expression(double constant = 0.0) : m_constant(constant) {} - Expression(const Term &term, double constant = 0.0) : m_terms(1, term), m_constant(constant) {} + Expression(const Term &term, double constant = 0.0) : m_terms(1, term), m_constant(constant) {} - Expression(const std::vector &terms, double constant = 0.0) : m_terms(terms), m_constant(constant) {} + Expression(const std::vector &terms, double constant = 0.0) : m_terms(terms), m_constant(constant) {} - ~Expression() {} + ~Expression() {} - const std::vector &terms() const - { - return m_terms; - } + const std::vector &terms() const + { + return m_terms; + } - double constant() const - { - return m_constant; - } + double constant() const + { + return m_constant; + } - double value() const - { - typedef std::vector::const_iterator iter_t; - double result = m_constant; - iter_t end = m_terms.end(); - for (iter_t it = m_terms.begin(); it != end; ++it) - result += it->value(); - return result; - } + double value() const + { + typedef std::vector::const_iterator iter_t; + double result = m_constant; + iter_t end = m_terms.end(); + for (iter_t it = m_terms.begin(); it != end; ++it) + result += it->value(); + return result; + } -private: - std::vector m_terms; - double m_constant; + bool involves (Variable const & v) const { + for (std::vector::const_iterator it = m_terms.begin(); it != m_terms.end(); ++it) { + if (it->variable().equals (v)) { + return true; + } + } + return false; + } + + private: + std::vector m_terms; + double m_constant; }; +static std::ostream& operator<<(std::ostream& o, kiwi::Expression const &e) +{ + o << e.constant() << " + "; + for (std::vector::const_iterator it = e.terms().begin(); it != e.terms().end(); ++it) { + o << (*it) << ' '; + } + return o; +} + } // namespace kiwi + diff --git a/libs/canvas/kiwi/term.h b/libs/canvas/kiwi/term.h index aecfdf06dc..ac08569eba 100644 --- a/libs/canvas/kiwi/term.h +++ b/libs/canvas/kiwi/term.h @@ -6,6 +6,7 @@ | The full license is in the file LICENSE, distributed with this software. |----------------------------------------------------------------------------*/ #pragma once +#include #include #include "variable.h" @@ -48,4 +49,10 @@ private: double m_coefficient; }; +static std::ostream& operator<< (std::ostream& o, kiwi::Term const & t) +{ + return o << t.variable().name() << " * " << t.coefficient(); +} + } // namespace kiwi + diff --git a/libs/canvas/kiwi/variable.h b/libs/canvas/kiwi/variable.h index a4db777069..f91a0a0b57 100644 --- a/libs/canvas/kiwi/variable.h +++ b/libs/canvas/kiwi/variable.h @@ -68,7 +68,7 @@ public: } // operator== is used for symbolics - bool equals(const Variable &other) + bool equals(const Variable &other) const { return m_data == other.m_data; }