lin_expr.hpp

#pragma once
 
#include <array>
#include <vector>
 
#include "scippp/var.hpp"
 
// just for tests, see test_linexpr.cpp
namespace LinExpression { // NOLINT(readability-identifier-naming)
struct CheckInternalsUsingFriendStruct;
}
namespace scippp {
 
class LinExpr {
    friend class Model;
    friend struct LinExpression::CheckInternalsUsingFriendStruct; // just for tests, see test_linexpr.cpp
    double m_constant { 0.0 };
    std::vector<Var> m_vars {};
    std::vector<double> m_coeffs {};
 
public:
    LinExpr() = default;
    template <typename Arithmetic, std::enable_if_t<std::is_arithmetic_v<Arithmetic>, bool> = true>
    LinExpr(Arithmetic constant)
        : m_constant { static_cast<double>(constant) }
    {
    }
    LinExpr(const Var& var);
    LinExpr(std::initializer_list<Var> vars);
    LinExpr(std::initializer_list<Var> vars, std::initializer_list<double> coeffs);
    template <std::size_t N>
    LinExpr(const std::array<Var, N>& vars)
        : m_vars { vars.begin(), vars.end() }
        , m_coeffs(vars.size(), 1)
    {
    }
    template <std::size_t N>
    LinExpr(const std::array<Var, N>& vars, std::array<double, N>& coeffs)
        : m_vars { vars.begin(), vars.end() }
        , m_coeffs { coeffs.begin(), coeffs.end() }
    {
    }
    LinExpr(const std::vector<Var>& vars);
    LinExpr(const std::vector<Var>& vars, const std::vector<double>& coeffs);
 
    [[nodiscard]] double getConstant() const;
 
    LinExpr& operator+=(const LinExpr& expr);
    LinExpr& operator-=(const LinExpr& expr);
    LinExpr& operator*=(double factor);
};
 
LinExpr operator*(double factor, LinExpr rhs);
 
LinExpr operator+(LinExpr lhs, const LinExpr& rhs);
 
LinExpr operator-(LinExpr lhs, const LinExpr& rhs);
 
}