testExpressionEvaluator.cc

Go to the documentation of this file.

#include <cppunit/extensions/HelperMacros.h>

#include <boost/assign/std/vector.hpp>
#include <boost/assign/list_of.hpp>

#include <tst/Verify.h>
#include <utl/MathExpressionGrammar.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/SymbolTable.h>
#include <utl/ExpressionParser.h> 

#include <map>
#include <string>
#include <iostream>

using std::map;
using std::vector;
using std::string;
using namespace utl;
using namespace tst;
using namespace boost::assign;


#define ASSERT_CLOSE(x, y) CPPUNIT_ASSERT(Verify<CloseTo>(x, y))
#define ASSERT_NOTCLOSE(x, y) CPPUNIT_ASSERT(Verify<Not<CloseTo> >(x, y))


struct TestSymbols {
  static const utl::SymbolTable& GetSymbolMap() { return fgUnitMap; }
  static void SetSymbols(const utl::SymbolTable& s) { fgUnitMap=s; }
  static utl::SymbolTable fgUnitMap; 
};
utl::SymbolTable TestSymbols::fgUnitMap = utl::SymbolTable();



class ExpressionEvaluatorTest : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(ExpressionEvaluatorTest);
  CPPUNIT_TEST(testEvaluating);
  CPPUNIT_TEST(testMath);
  CPPUNIT_TEST_SUITE_END();

public:
  void
  setUp()
  {
    ErrorLogger::GetInstance().SetVerbosity(Verbosity::eAnnoying);
  }

  void
  tearDown() { }

  void
  testEvaluating()
  {
    utl::SymbolTable t =
      map_list_of
      ("a", 0.0)
      ("b", 1.0)
      ("c", 2.0)
      ("d", 3.0)
      ("scient1", 1.234e-1)
      ("scient2", 1.234e-2)
      ("scient3", 1.234e-3)
      ("doub1", 42.001)
      ("doub2", 42.002)
      ("doub3", 42.003)
      ;

    const map<string, double> expressionValue =
      map_list_of
      ("a", t["a"])
      ("a * b * c", t["a"] * t["b"] * t["c"])
      ("b * c", t["b"] * t["c"])
      ("c^2", pow(t["c"], 2))
      ("c^0.5", sqrt(2))
      ("c*d^2", t["c"] * pow(t["d"], 2))
      ("b/c*d", t["b"] / t["c"] * t["d"])
      ("scient1 * scient2 * scient3", t["scient1"] * t["scient2"] * t["scient3"])
      ("doub1 / doub2 * scient3", t["doub1"] / t["doub2"] * t["scient3"])
      ;
    
    TestSymbols::SetSymbols(t);
    utl::ExpressionParser<utl::MathExpressionGrammar, TestSymbols> eval;
    
    for (map<string, double>::const_iterator it = expressionValue.begin(), end = expressionValue.end();
         it != end; ++it) {
      ASSERT_CLOSE(eval.Evaluate(it->first), it->second);
    }


    
    utl::SymbolTable t2 =
      map_list_of
      ("x", 26.3)
      ;
    
    const map<string, double> expressionValue2 =
      map_list_of
      ("c+x*doub1", t["c"]+t2["x"]*t["doub1"])
      ;
    
    utl::ExpressionParser<utl::MathExpressionGrammar, TestSymbols> evalx(t2);
    for (map<string, double>::const_iterator it = expressionValue2.begin(), end = expressionValue2.end();
         it != end; ++it) {
      ASSERT_CLOSE(evalx.Evaluate(it->first), it->second);
    }

  }


  void
  testMath()
  {
    utl::SymbolTable t =
      map_list_of
      ("a", 0.1)
      ("b", 1.0)
      ("c", 2.0)
      ("d", 3.0)
      ("scient1", 1.234e-1)
      ("scient2", 1.234e-2)
      ("scient3", 1.234e-3)
      ("doub1", 42.001)
      ("doub2", 42.002)
      ("doub3", 42.003)
      ;    
    
    utl::SymbolTable tOne = t;
    tOne["x"] = 0.5;

    const map<string, double> expressionValueOne =
      map_list_of
      ("x*a", tOne["a"]*tOne["x"])
      ("a+x", tOne["a"]+tOne["x"])
      ("(x*a)", tOne["a"]*tOne["x"])
      ("(a+x)", tOne["a"]+tOne["x"])
      ("(x)+a", tOne["a"]+tOne["x"])
      ("x+(a)", tOne["a"]+tOne["x"])
      ("(x)*a", tOne["a"]*tOne["x"])
      ("x*(a)", tOne["a"]*tOne["x"])
      ("a+b*x+a", tOne["a"]+tOne["b"]*tOne["x"]+tOne["a"])
      ("scient1+b*doub1+scient1*x^2-b*(-4.)", tOne["scient1"]+tOne["b"]*tOne["doub1"]+tOne["scient1"]*pow(tOne["x"],2)-tOne["b"]*(-4.))
      ("(doub3-scient2)^2/c+(d/a)", pow(tOne["doub3"]-tOne["scient2"],2)/tOne["c"]+tOne["d"]/tOne["a"])
      ("-(doub3-scient2)^2/c+(d/a)", -pow(tOne["doub3"]-tOne["scient2"],2)/tOne["c"]+tOne["d"]/tOne["a"])
      ("-(doub3-scient2)^2+c+(d/a)", -pow(tOne["doub3"]-tOne["scient2"],2)+tOne["c"]+tOne["d"]/tOne["a"])
      ("-(doub3-scient2)^2-c+(d/a)", -pow(tOne["doub3"]-tOne["scient2"],2)-tOne["c"]+tOne["d"]/tOne["a"])
      ("c-(doub3-scient2)^2-c+(d/a)", tOne["c"]-pow(tOne["doub3"]-tOne["scient2"],2)-tOne["c"]+tOne["d"]/tOne["a"])
      //("a+b*x+a+0.4", tOne["a"]+tOne["b"]*tOne["x"]+tOne["a"]+0.4)
      ("b+c*x^2", tOne["b"]+tOne["c"]*pow(tOne["x"],2))
      ("b+c*log10(x)", tOne["b"]+tOne["c"]*log10(tOne["x"]))
      ("b+c*exp(x)", tOne["b"]+tOne["c"]*exp(tOne["x"]))
      ("b+c*exp(-x)", tOne["b"]+tOne["c"]*exp(-tOne["x"]))
      ("b+c*log10(x+a*exp(x)+b*x^(2-a))", tOne["b"]+tOne["c"]*log10(tOne["x"]+tOne["a"]*exp(tOne["x"])+tOne["b"]*pow(tOne["x"],2-tOne["a"])))
      ("b+log(x+5)", tOne["b"]+log(tOne["x"]+5))
      ("b+sin(x+5)", tOne["b"]+sin(tOne["x"]+5))
      ("b+cos(x+5)", tOne["b"]+cos(tOne["x"]+5))
      ("b+tan(x+5)", tOne["b"]+tan(tOne["x"]+5))
      ;

    utl::FunctionParser evalOne(tOne);
    
    for (map<string, double>::const_iterator it = expressionValueOne.begin(), end = expressionValueOne.end();
         it != end; ++it) {
      ASSERT_CLOSE(evalOne.Evaluate(it->first), it->second);
    }
    
    
    
    utl::SymbolTable tTwo = t;
    tTwo["Xmax"] = 500*g/cm2;
    
    const map<string, double> expressionValueTwo =
      map_list_of
      ("(Xmax-400*g/cm2)+20*g/cm2", (tTwo["Xmax"]-400*g/cm2)+20*g/cm2)
      ("Xmax/(100*g/cm2)-0.5", tTwo["Xmax"]/(100*g/cm2)-0.5)
      ("-Xmax/(100*g/cm2)+10.5", -tTwo["Xmax"]/(100*g/cm2)+10.5)
      ("exp(-Xmax/(100*g/cm2)+10.5)", exp(-tTwo["Xmax"]/(100*g/cm2)+10.5));
    
    utl::FunctionParser evalTwo(tTwo);

    for (map<string, double>::const_iterator it = expressionValueTwo.begin(), end = expressionValueTwo.end();
         it != end; ++it) {
      ASSERT_CLOSE(evalTwo.Evaluate(it->first), it->second);
    }
  }
};


CPPUNIT_TEST_SUITE_REGISTRATION(ExpressionEvaluatorTest);