metaSMT git

metaSMT/backend/Aiger.hpp

Go to the documentation of this file.
00001 
00002 #pragma once
00003 
00004 #include "../tags/Logic.hpp" 
00005 
00006 extern "C" {
00007 #include <aiger.h>
00008 }
00009 
00010 namespace metaSMT 
00011 {
00012   class Aiger  
00013   {
00014     public:
00015       typedef unsigned result_type;
00016       
00017       aiger *aig; 
00018 
00019     public:
00020       Aiger () : aig (aiger_init()) {} 
00021       ~Aiger () 
00022       {
00023         aiger_reset ( aig ); 
00024       }
00025 
00026       result_type operator() (logic::tag::var_tag const& var, boost::any args)
00027       {
00028         return new_var(); 
00029       }
00030 
00031       result_type operator() (logic::tag::true_tag const& , boost::any args)
00032       {
00033         return aiger_true;
00034       }
00035        
00036       result_type operator() (logic::tag::false_tag const& , boost::any args)
00037       {
00038         return aiger_false; 
00039       }
00040 
00041       result_type operator() (logic::tag::not_tag const&, result_type operand)
00042       {
00043         return aiger_not ( operand );
00044       }
00045 
00046       result_type operator() (logic::tag::and_tag const&, result_type lhs, result_type rhs )
00047       {
00048         result_type t = new_var();
00049         aiger_add_and ( aig, t, lhs, rhs );
00050         return t; 
00051       }
00052 
00053       result_type operator() (logic::tag::nand_tag const&, result_type lhs, result_type rhs )
00054       {
00055         result_type t = new_var();
00056         aiger_add_and ( aig, t, lhs, rhs );
00057         return aiger_not ( t );
00058       }
00059 
00060       result_type operator() (logic::tag::equal_tag const&, result_type lhs, result_type rhs )
00061       {
00062         return aiger_add_xnor ( aig, lhs, rhs ); 
00063       }
00064 
00065       result_type operator() (logic::tag::nequal_tag const&, result_type lhs, result_type rhs )
00066       {
00067         return aiger_not ( aiger_add_xnor ( aig, lhs, rhs ) ); 
00068       }
00069 
00070       result_type operator() (logic::tag::xnor_tag const&, result_type lhs, result_type rhs )
00071       {
00072         return aiger_add_xnor ( aig, lhs, rhs ); 
00073       }
00074 
00075       result_type operator() (logic::tag::implies_tag const&, result_type lhs, result_type rhs )
00076       {
00077         return aiger_add_or ( aig, aiger_not (lhs), rhs ); 
00078       }
00079 
00080       result_type operator() (logic::tag::or_tag const&, result_type lhs, result_type rhs )
00081       {
00082         return aiger_add_or ( aig, lhs, rhs ); 
00083       }
00084       
00085       result_type operator() (logic::tag::nor_tag const&, result_type lhs, result_type rhs )
00086       {
00087         return aiger_not ( aiger_add_or ( aig, lhs, rhs ) );
00088       }
00089 
00090       result_type operator() (logic::tag::xor_tag const&, result_type lhs, result_type rhs )
00091       {
00092         return aiger_add_xor ( aig, lhs, rhs ); 
00093       }
00094 
00095       result_type operator() (logic::tag::ite_tag const&, result_type I, result_type T, result_type E)
00096       {
00097         return aiger_add_ite ( aig, I, T, E );
00098       }
00099 
00100 
00101       template<typename T>
00102         result_type operator() (T const& , result_type lhs, result_type rhs )
00103         {
00104           assert ( false ); 
00105           return aiger_false; 
00106         }
00107 
00108       template<typename T, typename Arg>
00109         result_type operator() (T const& var, Arg lhs )
00110         {
00111           assert ( false ); 
00112           return aiger_false; 
00113         }
00114 
00115       template<typename T>
00116         result_type operator() (T const& var, result_type op1, result_type op2, result_type op3  )
00117         {
00118           assert ( false ); 
00119           return aiger_false; 
00120         }
00121 
00122       unsigned new_var ()
00123       {
00124         ++aig->maxvar;
00125         return aiger_var2lit( aig->maxvar );
00126       }
00127        
00128       unsigned aiger_add_or ( aiger *aig, unsigned lhs, unsigned rhs )
00129       {
00130         result_type t = new_var ();
00131         aiger_add_and ( aig, t, aiger_not (lhs), aiger_not (rhs) ); 
00132         return aiger_not ( t );  
00133       }
00134 
00135       unsigned aiger_add_xor ( aiger *aig, unsigned lhs, unsigned rhs )
00136       {
00137         return aiger_not ( aiger_add_xnor ( aig, lhs, rhs ) );
00138       }
00139 
00140       unsigned aiger_add_xnor ( aiger *aig, unsigned lhs, unsigned rhs )
00141       {
00142         result_type t = new_var(); 
00143 
00144         result_type t1 = new_var ();
00145         result_type t2 = new_var ();
00146 
00147         aiger_add_and ( aig, t1, aiger_not ( lhs ), aiger_not ( rhs ) ); 
00148         aiger_add_and ( aig, t2, lhs, rhs ); 
00149 
00150         return aiger_add_or ( aig, t1, t2 ); 
00151       }
00152 
00153       unsigned aiger_add_ite ( aiger *aig, unsigned I, unsigned T, unsigned E )
00154       {
00155         result_type t = new_var (); 
00156         aiger_add_and ( aig 
00157             , t
00158             , aiger_add_or ( aig, aiger_not (I), T )
00159             , aiger_add_or ( aig, I, E ) );
00160         return t;
00161       }
00162   }; 
00163 
00164 
00165 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines