minor fixup

4 files changed, 23 insertions, 23 deletions

diff --git a/eval/src/tests/eval/aggr/aggr_test.cpp b/eval/src/tests/eval/aggr/aggr_test.cpp
index 4acb220154e..db000840f59 100644
--- a/eval/src/tests/eval/aggr/aggr_test.cpp
+++ b/eval/src/tests/eval/aggr/aggr_test.cpp
@@ -48,7 +48,7 @@ TEST("require that AVG aggregator works as expected") {
     aggr.next(30.0),   EXPECT_EQUAL(aggr.result(), 20.0);
     aggr.first(100.0), EXPECT_EQUAL(aggr.result(), 100.0);
     aggr.next(200.0),  EXPECT_EQUAL(aggr.result(), 150.0);
-    EXPECT_TRUE(aggr.enum_type() == Aggr::AVG);
+    EXPECT_TRUE(aggr.enum_value() == Aggr::AVG);
 }
 
 TEST("require that COUNT aggregator works as expected") {
@@ -60,7 +60,7 @@ TEST("require that COUNT aggregator works as expected") {
     aggr.next(30.0),   EXPECT_EQUAL(aggr.result(), 3.0);
     aggr.first(100.0), EXPECT_EQUAL(aggr.result(), 1.0);
     aggr.next(200.0),  EXPECT_EQUAL(aggr.result(), 2.0);
-    EXPECT_TRUE(aggr.enum_type() == Aggr::COUNT);
+    EXPECT_TRUE(aggr.enum_value() == Aggr::COUNT);
 }
 
 TEST("require that PROD aggregator works as expected") {
@@ -72,7 +72,7 @@ TEST("require that PROD aggregator works as expected") {
     aggr.next(30.0),   EXPECT_EQUAL(aggr.result(), 6000.0);
     aggr.first(100.0), EXPECT_EQUAL(aggr.result(), 100.0);
     aggr.next(200.0),  EXPECT_EQUAL(aggr.result(), 20000.0);
-    EXPECT_TRUE(aggr.enum_type() == Aggr::PROD);
+    EXPECT_TRUE(aggr.enum_value() == Aggr::PROD);
 }
 
 TEST("require that Prod combine works as expected") {
@@ -90,7 +90,7 @@ TEST("require that SUM aggregator works as expected") {
     aggr.next(30.0),   EXPECT_EQUAL(aggr.result(), 60.0);
     aggr.first(100.0), EXPECT_EQUAL(aggr.result(), 100.0);
     aggr.next(200.0),  EXPECT_EQUAL(aggr.result(), 300.0);
-    EXPECT_TRUE(aggr.enum_type() == Aggr::SUM);
+    EXPECT_TRUE(aggr.enum_value() == Aggr::SUM);
 }
 
 TEST("require that Sum combine works as expected") {
@@ -108,7 +108,7 @@ TEST("require that MAX aggregator works as expected") {
     aggr.next(30.0),   EXPECT_EQUAL(aggr.result(), 30.0);
     aggr.first(100.0), EXPECT_EQUAL(aggr.result(), 100.0);
     aggr.next(200.0),  EXPECT_EQUAL(aggr.result(), 200.0);
-    EXPECT_TRUE(aggr.enum_type() == Aggr::MAX);
+    EXPECT_TRUE(aggr.enum_value() == Aggr::MAX);
 }
 
 TEST("require that Max combine works as expected") {
@@ -128,7 +128,7 @@ TEST("require that MEDIAN aggregator works as expected") {
     aggr.next(16.0),   EXPECT_EQUAL(aggr.result(), 16.0);
     aggr.first(100.0), EXPECT_EQUAL(aggr.result(), 100.0);
     aggr.next(200.0),  EXPECT_EQUAL(aggr.result(), 150.0);
-    EXPECT_TRUE(aggr.enum_type() == Aggr::MEDIAN);
+    EXPECT_TRUE(aggr.enum_value() == Aggr::MEDIAN);
 }
 
 TEST("require that MEDIAN aggregator handles NaN values") {
@@ -152,7 +152,7 @@ TEST("require that MIN aggregator works as expected") {
     aggr.next(30.0),   EXPECT_EQUAL(aggr.result(), 10.0);
     aggr.first(100.0), EXPECT_EQUAL(aggr.result(), 100.0);
     aggr.next(200.0),  EXPECT_EQUAL(aggr.result(), 100.0);
-    EXPECT_TRUE(aggr.enum_type() == Aggr::MIN);
+    EXPECT_TRUE(aggr.enum_value() == Aggr::MIN);
 }
 
 TEST("require that Min combine works as expected") {
diff --git a/eval/src/vespa/eval/eval/aggr.cpp b/eval/src/vespa/eval/eval/aggr.cpp
index d8beacd1dd0..a73cc4314c6 100644
--- a/eval/src/vespa/eval/eval/aggr.cpp
+++ b/eval/src/vespa/eval/eval/aggr.cpp
@@ -17,7 +17,7 @@ struct Wrapper : Aggregator {
     virtual void first(double value) final override { aggr = T{value}; }
     virtual void next(double value) final override { aggr.sample(value); }
     virtual double result() const final override { return aggr.result(); }
-    virtual Aggr enum_type() const final override { return T::enum_type(); }
+    virtual Aggr enum_value() const final override { return T::enum_value(); }
 };
 
 } // namespace vespalib::eval::<unnamed>
diff --git a/eval/src/vespa/eval/eval/aggr.h b/eval/src/vespa/eval/eval/aggr.h
index ec3593c9efb..2173205dc82 100644
--- a/eval/src/vespa/eval/eval/aggr.h
+++ b/eval/src/vespa/eval/eval/aggr.h
@@ -53,7 +53,7 @@ struct Aggregator {
     virtual void first(double value) = 0;
     virtual void next(double value) = 0;
     virtual double result() const = 0;
-    virtual Aggr enum_type() const = 0;
+    virtual Aggr enum_value() const = 0;
     virtual ~Aggregator();
     static Aggregator &create(Aggr aggr, Stash &stash);
     static std::vector<Aggr> list();
@@ -93,7 +93,7 @@ public:
         _cnt += rhs._cnt;
     };
     constexpr T result() const { return (_sum / _cnt); }
-    static constexpr Aggr enum_type() { return Aggr::AVG; }
+    static constexpr Aggr enum_value() { return Aggr::AVG; }
 };
 
 template <typename T> class Count {
@@ -106,7 +106,7 @@ public:
     constexpr void sample(T) { ++_cnt; }
     constexpr void merge(const Count &rhs) { _cnt += rhs._cnt; }
     constexpr T result() const { return _cnt; }
-    static constexpr Aggr enum_type() { return Aggr::COUNT; }
+    static constexpr Aggr enum_value() { return Aggr::COUNT; }
 };
 
 template <typename T> class Prod {
@@ -119,8 +119,8 @@ public:
     constexpr void sample(T value) { _prod *= value; }
     constexpr void merge(const Prod &rhs) { _prod *= rhs._prod; }
     constexpr T result() const { return _prod; }
-    static constexpr Aggr enum_type() { return Aggr::PROD; }
-    static T combine(T a, T b) { return (a * b); }
+    static constexpr Aggr enum_value() { return Aggr::PROD; }
+    static constexpr T combine(T a, T b) { return (a * b); }
 };
 
 template <typename T> class Sum {
@@ -133,8 +133,8 @@ public:
     constexpr void sample(T value) { _sum += value; }
     constexpr void merge(const Sum &rhs) { _sum += rhs._sum; }
     constexpr T result() const { return _sum; }
-    static constexpr Aggr enum_type() { return Aggr::SUM; }
-    static T combine(T a, T b) { return (a += b); }
+    static constexpr Aggr enum_value() { return Aggr::SUM; }
+    static constexpr T combine(T a, T b) { return (a + b); }
 };
 
 template <typename T> class Max {
@@ -147,8 +147,8 @@ public:
     constexpr void sample(T value) { _max = std::max(_max, value); }
     constexpr void merge(const Max &rhs) { _max = std::max(_max, rhs._max); }
     constexpr T result() const { return _max; }
-    static constexpr Aggr enum_type() { return Aggr::MAX; }
-    static T combine(T a, T b) { return std::max(a,b); }
+    static constexpr Aggr enum_value() { return Aggr::MAX; }
+    static constexpr T combine(T a, T b) { return std::max(a,b); }
 };
 
 template <typename T> class Median {
@@ -186,7 +186,7 @@ public:
         }
         return result;
     }
-    static constexpr Aggr enum_type() { return Aggr::MEDIAN; }
+    static constexpr Aggr enum_value() { return Aggr::MEDIAN; }
 };
 
 template <typename T> class Min {
@@ -199,11 +199,11 @@ public:
     constexpr void sample(T value) { _min = std::min(_min, value); }
     constexpr void merge(const Min &rhs) { _min = std::min(_min, rhs._min); }
     constexpr T result() const { return _min; }
-    static constexpr Aggr enum_type() { return Aggr::MIN; }
-    static T combine(T a, T b) { return std::min(a,b); }
+    static constexpr Aggr enum_value() { return Aggr::MIN; }
+    static constexpr T combine(T a, T b) { return std::min(a,b); }
 };
 
-} // namespave vespalib::eval::aggr
+} // namespace vespalib::eval::aggr
 
 struct TypifyAggr {
     template <template<typename> typename TT> using Result = TypifyResultSimpleTemplate<TT>;
diff --git a/eval/src/vespa/eval/tensor/dense/dense_single_reduce_function.cpp b/eval/src/vespa/eval/tensor/dense/dense_single_reduce_function.cpp
index f5241407516..2d8afa638ce 100644
--- a/eval/src/vespa/eval/tensor/dense/dense_single_reduce_function.cpp
+++ b/eval/src/vespa/eval/tensor/dense/dense_single_reduce_function.cpp
@@ -87,7 +87,7 @@ auto reduce_cells_atleast_8(const CT *src, size_t n, size_t stride) {
 
 template <typename CT, typename AGGR, bool atleast_8, bool is_inner>
 void trace_reduce_impl(const Params &params, const CT *src, CT *dst) {
-    constexpr bool aggr_is_complex = is_complex(AGGR::enum_type());
+    constexpr bool aggr_is_complex = is_complex(AGGR::enum_value());
     const size_t block_size = (params.dim_size * params.inner_size);
     for (size_t outer = 0; outer < params.outer_size; ++outer) {
         for (size_t inner = 0; inner < params.inner_size; ++inner) {
@@ -125,7 +125,7 @@ void fold_reduce_impl(const Params &params, const CT *src, CT *dst) {
 template <typename CT, typename AGGR, bool atleast_8, bool is_inner>
 void my_single_reduce_op(InterpretedFunction::State &state, uint64_t param) {
     static_assert(std::is_same_v<CT,typename AGGR::value_type>);
-    constexpr bool aggr_is_simple = is_simple(AGGR::enum_type());
+    constexpr bool aggr_is_simple = is_simple(AGGR::enum_value());
     const auto &params = unwrap_param<Params>(param);
     const CT *src = state.peek(0).cells().typify<CT>().cbegin();
     auto dst_cells = state.stash.create_uninitialized_array<CT>(params.outer_size * params.inner_size);