Move bool_op into prod2's template arguments

[SSoelvsten]

We may be able to get a slight but significant performance increase by having the boolean operators op given to Apply and Quantification to be compile-time known, since this might simplify some computations or even remove some if-statements. This might get us even closer in performance to other implementations.

• Rework the bool_op functions in adiar/bool_op.h to be a predicate<bool,bool>, i.e. one that only sees the value of the ptr_uint64.
• Rename is_X_irrelevant into is_X_idempotent.
• Replace internal/bool_op.h with a generic binary_op class that holds a reference to a function<Terminal(Terminal, Terminal)>. For now, only implement the specialization for Terminal = bool.
  • Improve its performance by pre-computing values that are used more than once in the binary_op constructor.
  • Add type of flipped binary_op<...>
  • Template the prod2 algorithm to work with some BinaryOp (possibly inheritable by the policy?).
• Add non-generic versions for each operator that exploits bit-operations and provides as much as possible at compile time.

   class and_op
   {
   public:
     static ptr_t apply(const ptr_t lhs, const ptr_t rhs)
     {
       return essential(sink1 & sink2);
     }
  
     operator() (const ptr_t lhs, const ptr_t rhs)
     {
        return apply(lhs, rhs);
     }
  
     static bool is_left_shortcutting(const ptr_t lhs)
     {
        return !value_of(lhs);
     }
  
     static constexpr bool is_left_negating(const ptr_t lhs)
     {
        return false;
     }
  
     // etc.
   }

  • Unit test these extra classes separately.
  • Use these non-generic versions within bdd_and, bdd_or, zdd_intsec, ... (and add new unit tests to cover these specializations)

This would essentially be a stateful policy pattern similar to the ones added in #128 .