boolean_function_decorator.cpp

Go to the documentation of this file.

#include "hal_core/python_bindings/python_bindings.h"
 
namespace hal
{
    void boolean_function_decorator_init(py::module& m)
    {
        py::class_<BooleanFunctionDecorator> py_boolean_function_decorator(m, "BooleanFunctionDecorator", R"(
            A Boolean function decorator that provides functionality to operate on the associated Boolean function.
        )");
 
        py_boolean_function_decorator.def(py::init<const BooleanFunction&>(), py::arg("bf"), R"(
            Construct new BooleanFunctionDecorator object.
 
            :param hal_py.BooleanFunction bf: The Booelan function to operate on.
        )");
 
        py_boolean_function_decorator.def(
            "substitute_power_ground_nets",
            [](const BooleanFunctionDecorator& self, const Netlist* nl) -> std::optional<BooleanFunction> {
                auto res = self.substitute_power_ground_nets(nl);
                if (res.is_ok())
                {
                    return res.get();
                }
                else
                {
                    log_error("python_context", "error encountered while substituting power and ground nets:\n{}", res.get_error().get());
                    return std::nullopt;
                }
            },
            py::arg("nl"),
            R"(
            Substitute all Boolean function variables fed by power or ground gates by constant ``0`` and ``1``. 
 
            :param hal_py.Netlist nl: The netlist to operate on.
            :returns: The resulting Boolean function on success, ``None`` otherwise.
            :rtype: hal_py.BooleanFunction or None
        )");
 
        py_boolean_function_decorator.def(
            "substitute_power_ground_pins",
            [](const BooleanFunctionDecorator& self, const Gate* g) -> std::optional<BooleanFunction> {
                auto res = self.substitute_power_ground_pins(g);
                if (res.is_ok())
                {
                    return res.get();
                }
                else
                {
                    log_error("python_context", "error encountered while substituting power and ground pins:\n{}", res.get_error().get());
                    return std::nullopt;
                }
            },
            py::arg("g"),
            R"(
            Substitute all Boolean function variables that belong to a pin connected to a power or ground gate by constant ``0`` and ``1``.  
 
            :param hal_py.Gate g: The gate which is connected to the pins and belongs to the Boolean function under inspection.
            :returns: The resulting Boolean function on success, ``None`` otherwise.
            :rtype: hal_py.BooleanFunction or None
        )");
 
        py_boolean_function_decorator.def_static(
            "get_boolean_function_from",
            [](const std::vector<BooleanFunction>& functions, u32 extend_to_size = 0, bool sign_extend = false, bool ascending = true) -> std::optional<BooleanFunction> {
                auto res = BooleanFunctionDecorator::get_boolean_function_from(functions, extend_to_size, sign_extend, ascending);
                if (res.is_ok())
                {
                    return res.get();
                }
                else
                {
                    log_error("python_context", "error encountered while getting Boolean function from Boolean function vector:\n{}", res.get_error().get());
                    return std::nullopt;
                }
            },
            py::arg("functions"),
            py::arg("extend_to_size") = 0,
            py::arg("sign_extend")    = false,
            py::arg("ascending")      = true,
            R"(
            Get the Boolean function that is the concatenation of Boolean functions.
            The Boolean function can optionally be extended to any desired size greater the size of the given Boolean function list.
 
            :param list[hal_py.BooleanFunction] functions: The Boolean functions to concatenate. 
            :param int extend_to_size: The size to which to extend the Boolean function. Set to ``0`` to prevent extension. Defaults to ``0``.
            :param bool sign_extend: Set ``True`` to sign extend, ``False`` to zero extend. Defaults to ``False``.
            :param bool ascending: Set ``True`` to concatenate in ascending order (from ``0`` to ``n-1``), ``False`` for descending order (from ``n-1`` to ``0``). Defaults to ``True``. 
            :returns: The resulting Boolean function on success, ``None`` otherwise.
            :rtype: hal_py.BooleanFunction or None
        )");
 
        py_boolean_function_decorator.def_static(
            "get_boolean_function_from",
            [](const std::vector<Net*>& nets, u32 extend_to_size = 0, bool sign_extend = false, bool ascending = true) -> std::optional<BooleanFunction> {
                auto res = BooleanFunctionDecorator::get_boolean_function_from(nets, extend_to_size, sign_extend, ascending);
                if (res.is_ok())
                {
                    return res.get();
                }
                else
                {
                    log_error("python_context", "error encountered while getting Boolean function from net vector:\n{}", res.get_error().get());
                    return std::nullopt;
                }
            },
            py::arg("nets"),
            py::arg("extend_to_size") = 0,
            py::arg("sign_extend")    = false,
            py::arg("ascending")      = true,
            R"(
            Get the Boolean function that is the concatenation of variable names corresponding to nets of a netlist.
            The Boolean function can optionally be extended to any desired size greater the size of the given net vector.
 
            :param list[hal_py.Net] nets: The nets to concatenate. 
            :param int extend_to_size: The size to which to extend the Boolean function. Set to ``0`` to prevent extension. Defaults to ``0``.
            :param bool sign_extend: Set ``True`` to sign extend, ``False`` to zero extend. Defaults to ``False``.
            :param bool ascending: Set ``True`` to concatenate in ascending order (from ``0`` to ``n-1``), ``False`` for descending order (from ``n-1`` to ``0``). Defaults to ``True``. 
            :returns: The resulting Boolean function on success, ``None`` otherwise.
            :rtype: hal_py.BooleanFunction or None
        )");
 
        py_boolean_function_decorator.def_static(
            "get_boolean_function_from",
            [](const PinGroup<ModulePin>* pin_group, u32 extend_to_size = 0, bool sign_extend = false) -> std::optional<BooleanFunction> {
                auto res = BooleanFunctionDecorator::get_boolean_function_from(pin_group, extend_to_size, sign_extend);
                if (res.is_ok())
                {
                    return res.get();
                }
                else
                {
                    log_error("python_context", "error encountered while getting Boolean function from net vector:\n{}", res.get_error().get());
                    return std::nullopt;
                }
            },
            py::arg("pin_group"),
            py::arg("extend_to_size") = 0,
            py::arg("sign_extend")    = false,
            R"(
            Get the Boolean function that is the concatenation of variable names corresponding to the nets connected to the pins of the given pin group.
            The Boolean function can optionally be extended to any desired size greater the size of the given net vector.
 
            :param hal_py.ModulePinGroup pin_group: The module pin group.
            :param int extend_to_size: The size to which to extend the Boolean function. Set to ``0`` to prevent extension. Defaults to ``0``.
            :param bool sign_extend: Set ``True`` to sign extend, ``False`` to zero extend. Defaults to ``False``.
            :returns: The resulting Boolean function on success, ``None`` otherwise.
            :rtype: hal_py.BooleanFunction or None
        )");
    }
}    // namespace hal