vertex_interface.h

Go to the documentation of this file.

/*********************************************************************
 *
 *  Software License Agreement
 *
 *  Copyright (c) 2020,
 *  TU Dortmund - Institute of Control Theory and Systems Engineering.
 *  All rights reserved.
 *
 *  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/>.
 *
 *  Authors: Christoph Rösmann
 *********************************************************************/

#ifndef SRC_OPTIMIZATION_INCLUDE_CORBO_OPTIMIZATION_HYPER_GRAPH_VERTEX_INTERFACE_H_
#define SRC_OPTIMIZATION_INCLUDE_CORBO_OPTIMIZATION_HYPER_GRAPH_VERTEX_INTERFACE_H_

#include <corbo-core/types.h>

#include <memory>
#include <set>

namespace corbo {

class EdgeInterface;  // Forward definition, include in child headers
class BaseEdge;       // Forward definition, include in child headers
class BaseMixedEdge;  // Forward definition, include in child headers

class VertexInterface
{
    friend class VertexSetInterface;

 public:
    using Ptr  = std::shared_ptr<VertexInterface>;
    using UPtr = std::unique_ptr<VertexInterface>;

    virtual ~VertexInterface() {}

    virtual int getDimension() const = 0;
    virtual int getDimensionUnfixed() const = 0;
    virtual bool isFixed() const { return getDimensionUnfixed() == 0; }

    void registerObjectiveEdge(BaseEdge* edge);
    void registerLsqObjectiveEdge(BaseEdge* edge);
    void registerEqualityEdge(BaseEdge* edge);
    void registerInequalityEdge(BaseEdge* edge);
    void registerMixedEdge(BaseMixedEdge* edge);
    void clearConnectedEdges()
    {
        _edges_objective.clear();
        _edges_lsq_objective.clear();
        _edges_equalities.clear();
        _edges_inequalities.clear();
        _edges_mixed.clear();
    }

    virtual void plus(int idx, double inc) = 0;
    virtual void plus(const double* inc) = 0;
    virtual void plusUnfixed(const double* inc) = 0;

    virtual const double* getData() const = 0;
    virtual double* getDataRaw() = 0;
    Eigen::Map<const Eigen::VectorXd> getDataMap() const { return Eigen::Map<const Eigen::VectorXd>(getData(), getDimension()); }
    Eigen::Map<Eigen::VectorXd> getDataRawMap() { return Eigen::Map<Eigen::VectorXd>(getDataRaw(), getDimension()); }

    virtual void setData(int idx, double data) = 0;

    virtual bool hasFixedComponents() const = 0;

    virtual bool isFixedComponent(int idx) const = 0;

    virtual void setLowerBounds(const Eigen::Ref<const Eigen::VectorXd>& lb) = 0;
    virtual void setUpperBounds(const Eigen::Ref<const Eigen::VectorXd>& ub) = 0;
    virtual void setLowerBound(int idx, double lb) = 0;
    virtual void setUpperBound(int idx, double ub) = 0;
    virtual bool hasFiniteBounds() const = 0;
    virtual bool hasFiniteLowerBounds() const = 0;
    virtual bool hasFiniteUpperBounds() const = 0;
    virtual bool hasFiniteLowerBound(int idx) const = 0;
    virtual bool hasFiniteUpperBound(int idx) const = 0;
    virtual int getNumberFiniteLowerBounds(bool unfixed_only) const = 0;
    virtual int getNumberFiniteUpperBounds(bool unfixed_only) const = 0;
    virtual int getNumberFiniteBounds(bool unfixed_only) const = 0;

    virtual const double* getLowerBounds() const = 0;
    Eigen::Map<const Eigen::VectorXd> getLowerBoundsMap() const { return Eigen::Map<const Eigen::VectorXd>(getLowerBounds(), getDimension()); }
    virtual const double* getUpperBounds() const = 0;
    Eigen::Map<const Eigen::VectorXd> getUpperBoundsMap() const { return Eigen::Map<const Eigen::VectorXd>(getUpperBounds(), getDimension()); }

    const std::set<BaseEdge*>& getConnectedObjectiveEdgesRef() const { return _edges_objective; }
    const std::set<BaseEdge*>& getConnectedLsqObjectiveEdgesRef() const { return _edges_lsq_objective; }
    const std::set<BaseEdge*>& getConnectedEqualityEdgesRef() const { return _edges_equalities; }
    const std::set<BaseEdge*>& getConnectedInequalityEdgesRef() const { return _edges_inequalities; }
    const std::set<BaseMixedEdge*>& getConnectedMixedEdgesRef() const { return _edges_mixed; }

    // Backup values
    virtual void push()       = 0;  
    virtual void pop()        = 0;  
    virtual void top()        = 0;  
    virtual void discardTop() = 0;  
    virtual void clear()      = 0;  
    virtual void clearBackups() { clear(); }
    // virtual void copyBackup(int k, double* values) = 0;   //!< Make sure that values complies with dimension()
    virtual int getNumBackups() const = 0;  

    int getVertexIdx() const { return _vertex_idx; }
    // int getNumObjectiveEdgesWithCustomJacobian() const;
    // int getNumEqualityEdgesWithCustomJacobian() const;
    // int getNumInequalityEdgesWithCustomJacobian() const;

 private:
    std::set<BaseEdge*> _edges_objective;      
    std::set<BaseEdge*> _edges_lsq_objective;  
    std::set<BaseEdge*> _edges_equalities;     
    std::set<BaseEdge*> _edges_inequalities;   
    std::set<BaseMixedEdge*> _edges_mixed;     

    int _vertex_idx = 0;  
    // int _num_edges_with_custom_jacob = 0;  //!< we can skip jacobian computation for this vertex if all edges provide their own jacobian
};

}  // namespace corbo

#endif  // SRC_OPTIMIZATION_INCLUDE_CORBO_OPTIMIZATION_HYPER_GRAPH_VERTEX_INTERFACE_H_