exprtk_truthtable_gen.cpp

/*
 **************************************************************
 *         C++ Mathematical Expression Toolkit Library        *
 *                                                            *
 * ExprTk Truth Table Generator                               *
 * Author: Arash Partow (1999-2024)                           *
 * URL: https://www.partow.net/programming/exprtk/index.html  *
 *                                                            *
 * Copyright notice:                                          *
 * Free use of the Mathematical Expression Toolkit Library is *
 * permitted under the guidelines and in accordance with the  *
 * most current version of the MIT License.                   *
 * https://www.opensource.org/licenses/MIT                    *
 * SPDX-License-Identifier: MIT                               *
 *                                                            *
 **************************************************************
*/


#include <cmath>
#include <cstdio>
#include <string>

#include "exprtk.hpp"


template <typename T>
void truth_table_generator(const std::string& boolean_expression)
{
   typedef exprtk::symbol_table<T>    symbol_table_t;
   typedef exprtk::expression<T>      expression_t;
   typedef exprtk::parser<T>          parser_t;
   typedef exprtk::parser_error::type err_t;
   typedef typename parser_t::settings_store settings_t;

   symbol_table_t symbol_table;

   expression_t expression;
   expression.register_symbol_table(symbol_table);

   static const std::size_t compile_options =
      settings_t::e_replacer            +
      settings_t::e_joiner              +
      settings_t::e_numeric_check       +
      settings_t::e_bracket_check       +
      settings_t::e_sequence_check      +
      settings_t::e_strength_reduction  +
      settings_t::e_disable_usr_on_rsrvd;

   parser_t parser(settings_t(compile_options)
                     .disable_all_base_functions    ()
                     .disable_all_control_structures());

   parser.enable_unknown_symbol_resolver();

   parser.dec().collect_variables() = true;
   parser.dec().collect_functions() = true;

   if (!parser.compile(boolean_expression,expression))
   {
      printf("Error: %s\tExpression: %s\n",
             parser.error().c_str(),
             boolean_expression.c_str());

      for (std::size_t i = 0; i < parser.error_count(); ++i)
      {
         err_t error = parser.get_error(i);

         printf("Error: %02d Position: %02d "
                "Type: [%s] "
                "Message: %s "
                "Expression: %s\n",
                static_cast<int>(i),
                static_cast<int>(error.token.position),
                exprtk::parser_error::to_str(error.mode).c_str(),
                error.diagnostic.c_str(),
                boolean_expression.c_str());

         exprtk::parser_error::update_error(error,boolean_expression);

         printf("Error[%02d] at line: %d column: %d\n",
                static_cast<int>(i),
                static_cast<int>(error.line_no),
                static_cast<int>(error.column_no));
      }

      return;
   }

   typedef typename parser_t::dependent_entity_collector::symbol_t dec_symbol_t;

   std::deque<dec_symbol_t> symbol_list;

   parser.dec().symbols(symbol_list);

   if (symbol_list.empty())
   {
      printf("Error: No variables found to build truth table.\n");
      return;
   }

   for (std::size_t i = 0; i < symbol_list.size(); ++i)
   {
      if (exprtk::details::imatch(symbol_list[i].first,"not"))
      {
         symbol_list.erase(symbol_list.begin() + i);

         if (i >= symbol_list.size())
            break;
      }

      if (parser_t::e_st_function == symbol_list[i].second)
      {
         printf("Error: call to function '%s' not allowed.\n",symbol_list[i].first.c_str());
         return;
      }
   }

   if (symbol_list.size() > 32)
   {
      printf("Error: no more than 32 unique variables allowed.\n");
      return;
   }

   unsigned int upper_bound = 1 << symbol_list.size();

   const int index_width = static_cast<int>(std::ceil(std::log10(upper_bound)));

   // Print truth table header
   printf(" #%s ",std::string(index_width - 1,' ').c_str());

   for (std::size_t i = 0; i < symbol_list.size(); ++i)
   {
      printf("| %s ",symbol_list[i].first.c_str());
   }

   printf("| %s \n",boolean_expression.c_str());

   for (std::size_t i = 0; i < upper_bound; ++i)
   {
      for (std::size_t j = 0; j < symbol_list.size(); ++j)
      {
         symbol_table.get_variable(symbol_list[j].first)->ref() = T((i & (1 << (symbol_list.size() - j - 1))) ? 0 : 1);
      }

      const std::size_t result = static_cast<std::size_t>(expression.value());

      printf(" %*d ", index_width, static_cast<int>(i));

      for (std::size_t j = 0; j < symbol_list.size(); ++j)
      {
         printf("| %d ",static_cast<int>(symbol_table.get_variable(symbol_list[j].first)->value()));
      }

      printf("| %d \n", static_cast<int>(result));
   }
}

int main(int argc, char* argv[])
{
   if (2 != argc)
   {
      printf("usage: exprtk_truthtable_gen <expression>\n");
      return 1;
   }

   truth_table_generator<double>(argv[1]);

   return 0;
}

/*
   Examples:
   ./exprtk_truthtable_gen 'A and B or C or not(D)'
   ./exprtk_truthtable_gen '(A and not(B)) nor not(C xor D)'
   ./exprtk_truthtable_gen '(A nand not(B or C)) xor not(D xor E)'
*/