flomnes

class SystemBuilder
{
private:
    class SystemBuilderConnections
    {
    public:
        SystemBuilderConnections(SystemBuilder& parent):
            parent(parent)
        {
        }

flomnes

#include <iostream>
#include <string>
#include <string_view>
#include <utility>

template<class T>
T&& log(T&& in, std::string_view msg)
{
    std::cout << msg << std::endl;
    return std::move(in);

flomnes

#include <chrono>
#include <cstdlib> //rand
#include <iostream>
#include <map>
#include <string>
#include <unordered_map>

#include <boost/container_hash/hash.hpp>

constexpr int INV_REQ = 2;

flomnes

#include <iostream>

class C
{
public:
    C()
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

flomnes

#include <algorithm>
#include <vector>

static bool operator<=(const std::vector<double>& v, const double c)
{
    return std::ranges::all_of(v, [&c](const double& e) { return e <= c; });
}

static bool operator>=(const std::vector<double>& v, const double c)
{

flomnes

#include <string>
#include <utility>

class Hashable
{
public:
    Hashable(const std::string& s1, const std::string& s2):
        s1(s1),
        s2(s2)
    {

flomnes

#include <optional>
#include <string>
#include <utility>

class Node
{
public:
    virtual ~Node() = default;
};

flomnes

class EmptyClass
{
    virtual ~EmptyClass() = default;
};

class DerivedFromEmpty: public EmptyClass
{
    bool operator==(const DerivedFromEmpty&) const = default;
};

flomnes

#include <stdexcept>

class IName
{
public:
    virtual const std::string& name() const = 0;
};

class EqualNode: public IName

flomnes

#include <cassert>

enum class C
{
    LINEAR,
    NON_LINEAR,
    CONSTANT
};

C operator+(C x, C y)