add two large expressions based on symengine#1612 to the visitor init…

… benchmarks

benchmarks/visitor_init.cpp

@@ -7,18 +7,22 @@
 #include <symengine/mul.h>
 #include <symengine/pow.h>
 #include <symengine/symbol.h>
+#include <symengine/functions.h>
 
 using SymEngine::add;
 using SymEngine::Basic;
 using SymEngine::cos;
+using SymEngine::DenseMatrix;
 using SymEngine::integer;
 using SymEngine::LambdaRealDoubleVisitor;
 using SymEngine::LLVMDoubleVisitor;
 using SymEngine::LLVMFloatVisitor;
+using SymEngine::log;
 using SymEngine::mul;
 using SymEngine::pow;
 using SymEngine::RCP;
 using SymEngine::sin;
+using SymEngine::sqrt;
 using SymEngine::symbol;
 using SymEngine::vec_basic;
 
@@ -58,28 +62,80 @@ struct Expr2 {
     }
 };
 
-void init(LLVMFloatVisitor &v, const vec_basic& args, const vec_basic& expr, bool cse, [[maybe_unused]] unsigned opt_level)
+// large cse-friendly expression based on
+// https://github.com/symengine/symengine/pull/1612
+struct Expr3 {
+    vec_basic vec{6, symbol("a")};
+    vec_basic expr()
+    {
+        RCP<const Basic> e = integer(23);
+        const std::size_t n{vec.size()};
+        for (std::size_t i = 0; i < n; ++i) {
+            e = pow(e,
+                    add(cos(sqrt(log(sin(pow(vec[n - i - 1], vec[i]))))), e));
+        }
+        e = expand(e);
+        DenseMatrix M(1, 1, {e});
+        DenseMatrix S(n, 1, vec);
+        DenseMatrix J(1, n);
+        jacobian(M, S, J);
+        vec_basic expression;
+        for (std::size_t i = 0; i < n; ++i) {
+            expression.push_back(J.get(0, i));
+        }
+        return expression;
+    }
+};
+
+// large cse-friendly expression based on
+// https://github.com/symengine/symengine/pull/1612
+struct Expr4 {
+    vec_basic vec{6, symbol("a")};
+    vec_basic expr()
+    {
+        RCP<const Basic> e = integer(23);
+        const std::size_t n{vec.size()};
+        for (std::size_t i = 0; i < n; ++i) {
+            e = pow(e, cos(sqrt(log(sin(pow(vec[n - i - 1], vec[i]))))));
+        }
+        e = expand(e);
+        DenseMatrix M(1, 1, {e});
+        DenseMatrix S(n, 1, vec);
+        DenseMatrix J(1, n);
+        jacobian(M, S, J);
+        vec_basic expression;
+        for (std::size_t i = 0; i < n; ++i) {
+            expression.push_back(J.get(0, i));
+        }
+        return expression;
+    }
+};
+
+void init(LLVMFloatVisitor &v, const vec_basic &args, const vec_basic &expr,
+          bool cse, [[maybe_unused]] unsigned opt_level)
 {
     v.init(args, expr, cse, opt_level);
 }
 
-void init(LLVMDoubleVisitor &v, const vec_basic& args, const vec_basic& expr, bool cse, [[maybe_unused]] unsigned opt_level)
+void init(LLVMDoubleVisitor &v, const vec_basic &args, const vec_basic &expr,
+          bool cse, [[maybe_unused]] unsigned opt_level)
 {
     v.init(args, expr, cse, opt_level);
 }
 
-void init(LambdaRealDoubleVisitor &v, const vec_basic& args, const vec_basic& expr, bool cse, [[maybe_unused]] unsigned opt_level)
+void init(LambdaRealDoubleVisitor &v, const vec_basic &args,
+          const vec_basic &expr, bool cse, [[maybe_unused]] unsigned opt_level)
 {
     v.init(args, expr, cse);
 }
 
 template <typename Visitor, typename Expr, typename Real>
 static void Init(benchmark::State &state)
 {
-    Visitor v;
     bool cse{static_cast<bool>(state.range(0))};
     unsigned opt_level{static_cast<unsigned>(state.range(1))};
     Expr e;
+    Visitor v;
     vec_basic args{e.vec};
     vec_basic expr{e.expr()};
     for (auto _ : state) {
@@ -89,23 +145,38 @@ static void Init(benchmark::State &state)
 }
 
 // BENCHMARK_TEMPLATE(BenchmarkName, VisitorClass,
-// ExpressionClass, RealType)->ArgsProduct({{cse values}, {opt_level values}});
+// ExpressionClass, RealType)->ArgsProduct({{cse values}, {opt_level
+// values}});
 
 static std::vector<int64_t> opt_code_values{0, 1, 2, 3};
 static std::vector<int64_t> cse_values{0, 1};
 
 BENCHMARK_TEMPLATE(Init, LambdaRealDoubleVisitor, Expr1, double)
-->ArgsProduct({cse_values, {0}});
+    ->ArgsProduct({cse_values, {0}});
 BENCHMARK_TEMPLATE(Init, LLVMDoubleVisitor, Expr1, double)
-->ArgsProduct({cse_values, opt_code_values});
+    ->ArgsProduct({cse_values, opt_code_values});
 BENCHMARK_TEMPLATE(Init, LLVMFloatVisitor, Expr1, float)
-->ArgsProduct({cse_values, opt_code_values});
+    ->ArgsProduct({cse_values, opt_code_values});
 
 BENCHMARK_TEMPLATE(Init, LambdaRealDoubleVisitor, Expr2, double)
-->ArgsProduct({cse_values, {0}});
+    ->ArgsProduct({cse_values, {0}});
 BENCHMARK_TEMPLATE(Init, LLVMDoubleVisitor, Expr2, double)
-->ArgsProduct({cse_values, opt_code_values});
+    ->ArgsProduct({cse_values, opt_code_values});
 BENCHMARK_TEMPLATE(Init, LLVMFloatVisitor, Expr2, float)
+    ->ArgsProduct({cse_values, opt_code_values});
+
+BENCHMARK_TEMPLATE(Init, LambdaRealDoubleVisitor, Expr3, double)
+    ->ArgsProduct({cse_values, {0}});
+BENCHMARK_TEMPLATE(Init, LLVMDoubleVisitor, Expr3, double)
+    ->ArgsProduct({cse_values, opt_code_values});
+BENCHMARK_TEMPLATE(Init, LLVMFloatVisitor, Expr3, float)
+    ->ArgsProduct({cse_values, opt_code_values});
+
+BENCHMARK_TEMPLATE(Init, LambdaRealDoubleVisitor, Expr4, double)
+->ArgsProduct({cse_values, {0}});
+BENCHMARK_TEMPLATE(Init, LLVMDoubleVisitor, Expr4, double)
+->ArgsProduct({cse_values, opt_code_values});
+BENCHMARK_TEMPLATE(Init, LLVMFloatVisitor, Expr4, float)
 ->ArgsProduct({cse_values, opt_code_values});
 
 BENCHMARK_MAIN();