move more param stuff to lazy_params.h

9 files changed, 41 insertions, 36 deletions

diff --git a/eval/src/apps/eval_expr/eval_expr.cpp b/eval/src/apps/eval_expr/eval_expr.cpp
index 71c808174b8..91c669efe94 100644
--- a/eval/src/apps/eval_expr/eval_expr.cpp
+++ b/eval/src/apps/eval_expr/eval_expr.cpp
@@ -21,7 +21,7 @@ int main(int argc, char **argv) {
     }
     InterpretedFunction interpreted(SimpleTensorEngine::ref(), function, NodeTypes());
     InterpretedFunction::Context ctx(interpreted);
-    InterpretedFunction::SimpleParams params({});
+    SimpleParams params({});
     const Value &result = interpreted.eval(ctx, params);
     if (result.is_double()) {
         fprintf(stdout, "%.32g\n", result.as_double());
diff --git a/eval/src/tests/eval/gbdt/gbdt_test.cpp b/eval/src/tests/eval/gbdt/gbdt_test.cpp
index 20969a1e3b4..af5935fbf1e 100644
--- a/eval/src/tests/eval/gbdt/gbdt_test.cpp
+++ b/eval/src/tests/eval/gbdt/gbdt_test.cpp
@@ -18,7 +18,7 @@ using namespace vespalib::eval::gbdt;
 double eval_double(const Function &function, const std::vector<double> &params) {
     InterpretedFunction ifun(SimpleTensorEngine::ref(), function, NodeTypes());
     InterpretedFunction::Context ctx(ifun);
-    InterpretedFunction::SimpleParams fun_params(params);
+    SimpleParams fun_params(params);
     return ifun.eval(ctx, fun_params).as_double();
 }
 
diff --git a/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp b/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
index 5b7fb9af910..91eb741f334 100644
--- a/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
+++ b/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
@@ -51,7 +51,7 @@ struct MyEvalTest : test::EvalSpec::EvalTest {
         bool has_issues = InterpretedFunction::detect_issues(function);
         if (is_supported && !has_issues) {
             vespalib::string desc = as_string(param_names, param_values, expression);
-            InterpretedFunction::SimpleParams params(param_values);
+            SimpleParams params(param_values);
             verify_result(SimpleTensorEngine::ref(), function, false,  "[untyped simple] "+desc, params, expected_result);
             verify_result(DefaultTensorEngine::ref(), function, false, "[untyped prod]   "+desc, params, expected_result);
             verify_result(DefaultTensorEngine::ref(), function, true,  "[typed prod]     "+desc, params, expected_result);
@@ -62,7 +62,7 @@ struct MyEvalTest : test::EvalSpec::EvalTest {
                        const Function &function,
                        bool typed,
                        const vespalib::string &description,
-                       const InterpretedFunction::SimpleParams &params,
+                       const SimpleParams &params,
                        double expected_result)
     {
         NodeTypes node_types = typed
@@ -103,7 +103,7 @@ TEST("require that invalid function evaluates to a error") {
     EXPECT_TRUE(function.has_error());
     InterpretedFunction ifun(SimpleTensorEngine::ref(), function, NodeTypes());
     InterpretedFunction::Context ctx(ifun);
-    InterpretedFunction::SimpleParams my_params({1,2,3,4});
+    SimpleParams my_params({1,2,3,4});
     const Value &result = ifun.eval(ctx, my_params);
     EXPECT_TRUE(result.is_error());
     EXPECT_EQUAL(error_value, result.as_double());
@@ -115,7 +115,7 @@ size_t count_ifs(const vespalib::string &expr, std::initializer_list<double> par
     Function fun = Function::parse(expr);
     InterpretedFunction ifun(SimpleTensorEngine::ref(), fun, NodeTypes());
     InterpretedFunction::Context ctx(ifun);
-    InterpretedFunction::SimpleParams params(params_in);
+    SimpleParams params(params_in);
     ifun.eval(ctx, params);
     return ctx.if_cnt();
 }
@@ -143,8 +143,8 @@ TEST("require that basic addition works") {
     Function function = Function::parse("a+10");
     InterpretedFunction interpreted(SimpleTensorEngine::ref(), function, NodeTypes());
     InterpretedFunction::Context ctx(interpreted);
-    InterpretedFunction::SimpleParams params_20({20});
-    InterpretedFunction::SimpleParams params_40({40});
+    SimpleParams params_20({20});
+    SimpleParams params_40({40});
     EXPECT_EQUAL(interpreted.eval(ctx, params_20).as_double(), 30.0);
     EXPECT_EQUAL(interpreted.eval(ctx, params_40).as_double(), 50.0);
 }
diff --git a/eval/src/tests/tensor/tensor_performance/tensor_performance_test.cpp b/eval/src/tests/tensor/tensor_performance/tensor_performance_test.cpp
index 1472fd3497c..689a908f3f8 100644
--- a/eval/src/tests/tensor/tensor_performance/tensor_performance_test.cpp
+++ b/eval/src/tests/tensor/tensor_performance/tensor_performance_test.cpp
@@ -68,7 +68,7 @@ double calculate_expression(const vespalib::string &expression, const Params &pa
 }
 
 DoubleValue dummy_result(0.0);
-const Value &dummy_ranking(InterpretedFunction::Context &, InterpretedFunction::LazyParams &) { return dummy_result; }
+const Value &dummy_ranking(InterpretedFunction::Context &, LazyParams &) { return dummy_result; }
 
 double benchmark_expression_us(const vespalib::string &expression, const Params &params) {
     const Function function = Function::parse(expression);
diff --git a/eval/src/vespa/eval/eval/basic_nodes.cpp b/eval/src/vespa/eval/eval/basic_nodes.cpp
index a96d634e07a..85e00e76803 100644
--- a/eval/src/vespa/eval/eval/basic_nodes.cpp
+++ b/eval/src/vespa/eval/eval/basic_nodes.cpp
@@ -20,7 +20,7 @@ struct Frame {
     const Node &next_child() { return node.get_child(child_idx++); }
 };
 
-struct NoParams : InterpretedFunction::LazyParams {
+struct NoParams : LazyParams {
     const Value &resolve(size_t, Stash &stash) const override {
         return stash.create<ErrorValue>();
     }
diff --git a/eval/src/vespa/eval/eval/interpreted_function.cpp b/eval/src/vespa/eval/eval/interpreted_function.cpp
index 89d850c2dd3..0fb5860eaf0 100644
--- a/eval/src/vespa/eval/eval/interpreted_function.cpp
+++ b/eval/src/vespa/eval/eval/interpreted_function.cpp
@@ -450,19 +450,6 @@ const Function *get_lambda(const nodes::Node &node) {
 } // namespace vespalib::<unnamed>
 
 
-InterpretedFunction::SimpleParams::SimpleParams(const std::vector<double> &params_in)
-    : params(params_in)
-{}
-
-InterpretedFunction::SimpleParams::~SimpleParams() { }
-
-const Value &
-InterpretedFunction::SimpleParams::resolve(size_t idx, Stash &stash) const
-{
-    assert(idx < params.size());
-    return stash.create<DoubleValue>(params[idx]);
-}
-
 InterpretedFunction::State::State(const TensorEngine &engine_in)
     : engine(engine_in),
       params(nullptr),
diff --git a/eval/src/vespa/eval/eval/interpreted_function.h b/eval/src/vespa/eval/eval/interpreted_function.h
index ea8fcbc3a42..2a52a5a8258 100644
--- a/eval/src/vespa/eval/eval/interpreted_function.h
+++ b/eval/src/vespa/eval/eval/interpreted_function.h
@@ -27,18 +27,6 @@ class TensorEngine;
 class InterpretedFunction
 {
 public:
-    using LazyParams = ::vespalib::eval::LazyParams;
-
-    /**
-     * Simple wrapper for number-only parameters that are known up
-     * front. Intended for convenience (testing), not performance.
-     **/
-    struct SimpleParams : LazyParams {
-        std::vector<double> params;
-        explicit SimpleParams(const std::vector<double> &params_in);
-        ~SimpleParams();
-        const Value &resolve(size_t idx, Stash &stash) const override;
-    };
     struct State {
         const TensorEngine      &engine;
         const LazyParams        *params;
diff --git a/eval/src/vespa/eval/eval/lazy_params.cpp b/eval/src/vespa/eval/eval/lazy_params.cpp
index 1aea00eb592..aec8cf78059 100644
--- a/eval/src/vespa/eval/eval/lazy_params.cpp
+++ b/eval/src/vespa/eval/eval/lazy_params.cpp
@@ -9,6 +9,8 @@ LazyParams::~LazyParams()
 {
 }
 
+//-----------------------------------------------------------------------------
+
 SimpleObjectParams::~SimpleObjectParams()
 {
 }
@@ -20,4 +22,19 @@ SimpleObjectParams::resolve(size_t idx, Stash &) const
     return params[idx];
 }
 
+//-----------------------------------------------------------------------------
+
+SimpleParams::~SimpleParams()
+{
+}
+
+const Value &
+SimpleParams::resolve(size_t idx, Stash &stash) const
+{
+    assert(idx < params.size());
+    return stash.create<DoubleValue>(params[idx]);
+}
+
+//-----------------------------------------------------------------------------
+
 } // namespace vespalib::eval
diff --git a/eval/src/vespa/eval/eval/lazy_params.h b/eval/src/vespa/eval/eval/lazy_params.h
index d2c7b066162..b6b7753eff9 100644
--- a/eval/src/vespa/eval/eval/lazy_params.h
+++ b/eval/src/vespa/eval/eval/lazy_params.h
@@ -28,10 +28,23 @@ struct LazyParams {
  **/
 struct SimpleObjectParams : LazyParams {
     std::vector<Value::CREF> params;
-    explicit SimpleObjectParams(const std::vector<Value::CREF> &params_in) : params(params_in) {}
+    explicit SimpleObjectParams(const std::vector<Value::CREF> &params_in)
+        : params(params_in) {}
     ~SimpleObjectParams();
     const Value &resolve(size_t idx, Stash &stash) const override;
 };
 
+/**
+ * Simple wrapper for number-only parameters that are known up
+ * front. Intended for convenience (testing), not performance.
+ **/
+struct SimpleParams : LazyParams {
+    std::vector<double> params;
+    explicit SimpleParams(const std::vector<double> &params_in)
+        : params(params_in) {}
+    ~SimpleParams();
+    const Value &resolve(size_t idx, Stash &stash) const override;
+};
+
 } // namespace vespalib::eval
 } // namespace vespalib