Ordinale Conditions separat speichern

cpp/subprojects/common/include/mlrl/common/data/vector_sparse_array.hpp

@@ -10,7 +10,8 @@
 
 /**
  * An one-dimensional sparse vector that stores a fixed number of elements, consisting of an index and a value, in a
- * C-contiguous array.
+ * C-contiguous array. Such a vector is similar to a `SparseArraysVector`, but uses a single array for storing the
+ * indices and values.
  *
  * @tparam T The type of the data that is stored in the vector
  */

cpp/subprojects/common/include/mlrl/common/data/vector_sparse_arrays.hpp

@@ -0,0 +1,109 @@
+/*
+ * @author Michael Rapp ([email protected])
+ */
+#pragma once
+
+#include "mlrl/common/data/vector_dense.hpp"
+
+/**
+ * An one-dimensional sparse vector that stores a fixed number of elements, consisting of an index and a value, in
+ * C-contiguous arrays. Such a vector is similar to a `SparseArrayVector`, but uses separate arrays for storing the
+ * indices and values.
+ *
+ * @tparam T The type of the data that is stored in the vector
+ */
+template<typename T>
+class MLRLCOMMON_API SparseArraysVector : public IOneDimensionalView {
+    private:
+
+        DenseVector<uint32> indices_;
+
+        DenseVector<T> values_;
+
+    public:
+
+        /**
+         * @param numElements The number of elements in the vector
+         */
+        SparseArraysVector(uint32 numElements);
+
+        virtual ~SparseArraysVector() override {};
+
+        /**
+         * An iterator that provides access to the indices in the vector and allows to modify them.
+         */
+        typedef DenseVector<uint32>::iterator index_iterator;
+
+        /**
+         * An iterator that provides read-only access to the indices in the vector.
+         */
+        typedef DenseVector<uint32>::const_iterator index_const_iterator;
+
+        /**
+         * An iterator that provides access to the values in the vector and allows to modify them.
+         */
+        typedef typename DenseVector<T>::iterator value_iterator;
+
+        /**
+         * An iterator that provides read-only access to the values in the vector.
+         */
+        typedef typename DenseVector<T>::const_iterator value_const_iterator;
+
+        /**
+         * Returns an `index_iterator` to the beginning of the indices in the vector.
+         *
+         * @return An `index_iterator` to the beginning
+         */
+        index_iterator indices_begin();
+
+        /**
+         * Returns an `index_iterator` to the end of the indices in the vector.
+         *
+         * @return An `index_iterator` to the end
+         */
+        index_iterator indices_end();
+
+        /**
+         * Returns an `index_const_iterator` to the beginning of the indices in the vector.
+         *
+         * @return An `index_const_iterator` to the beginning
+         */
+        index_const_iterator indices_cbegin() const;
+
+        /**
+         * Returns an `index_const_iterator` to the end of the indices in the vector.
+         *
+         * @return An `index_const_iterator` to the end
+         */
+        index_const_iterator indices_cend() const;
+
+        /**
+         * Returns a `value_iterator` to the beginning of the values in the vector.
+         *
+         * @return A `value_iterator` to the beginning
+         */
+        value_iterator values_begin();
+
+        /**
+         * Returns a `value_iterator` to the end of the values in the vector.
+         *
+         * @return A `value_iterator` to the end
+         */
+        value_iterator values_end();
+
+        /**
+         * Returns a `value_const_iterator` to the beginning of the values in the vector.
+         *
+         * @return A `value_const_iterator` to the beginning
+         */
+        value_const_iterator values_cbegin() const;
+
+        /**
+         * Returns a `value_const_iterator` to the end of the values in the vector.
+         *
+         * @return A `value_const_iterator` to the end
+         */
+        value_const_iterator values_cend() const;
+
+        uint32 getNumElements() const override;
+};

cpp/subprojects/common/include/mlrl/common/input/feature_type.hpp

@@ -11,6 +11,13 @@ class IFeatureType {
 
         virtual ~IFeatureType() {};
 
+        /**
+         * Returns whether the feature is ordinal or not.
+         *
+         * @return True, if the feature is ordinal, false otherwise
+         */
+        virtual bool isOrdinal() const = 0;
+
         /**
          * Returns whether the feature is nominal or not.
          *

cpp/subprojects/common/include/mlrl/common/input/feature_type_nominal.hpp

@@ -11,5 +11,7 @@
 class NominalFeatureType final : public IFeatureType {
     public:
 
+        bool isOrdinal() const override;
+
         bool isNominal() const override;
 };

cpp/subprojects/common/include/mlrl/common/input/feature_type_numerical.hpp

@@ -11,5 +11,7 @@
 class NumericalFeatureType final : public IFeatureType {
     public:
 
+        bool isOrdinal() const override;
+
         bool isNominal() const override;
 };

cpp/subprojects/common/include/mlrl/common/input/feature_type_ordinal.hpp

@@ -11,5 +11,7 @@
 class OrdinalFeatureType final : public IFeatureType {
     public:
 
+        bool isOrdinal() const override;
+
         bool isNominal() const override;
 };

cpp/subprojects/common/include/mlrl/common/model/body.hpp

@@ -14,26 +14,15 @@ class EmptyBody;
 class ConjunctiveBody;
 
 /**
- * Defines an interface for all classes that represent the body of a rule.
+ * Defines an interface for all classes that allow to check whether an example is covered or not.
  */
-class MLRLCOMMON_API IBody {
+class MLRLCOMMON_API IConditional {
     public:
 
-        virtual ~IBody() {};
-
-        /**
-         * A visitor function for handling objects of the type `EmptyBody`.
-         */
-        typedef std::function<void(const EmptyBody&)> EmptyBodyVisitor;
-
-        /**
-         * A visitor function for handling objects of the type `ConjunctiveBody`.
-         */
-        typedef std::function<void(const ConjunctiveBody&)> ConjunctiveBodyVisitor;
+        virtual ~IConditional() {};
 
         /**
-         * Returns whether an individual example, which is stored in a C-contiguous matrix, is covered by the body or
-         * not.
+         * Returns whether an individual example, which is stored in a C-contiguous matrix, is covered or not.
          *
          * @param begin A `VectorConstView::const_iterator` to the beginning of the example's feature values
          * @param end   A `VectorConstView::const_iterator` to the end of the example's feature values
@@ -43,7 +32,7 @@ class MLRLCOMMON_API IBody {
                             VectorConstView<const float32>::const_iterator end) const = 0;
 
         /**
-         * Returns whether an individual example, which is stored in a CSR sparse matrix, is covered by the body or not.
+         * Returns whether an individual example, which is stored in a CSR sparse matrix, is covered or not.
          *
          * @param indicesBegin  An iterator to the beginning of the example's feature values
          * @param indicesEnd    An iterator to the end of the example's feature values
@@ -64,6 +53,25 @@ class MLRLCOMMON_API IBody {
                             CsrConstView<const float32>::value_const_iterator valuesBegin,
                             CsrConstView<const float32>::value_const_iterator valuesEnd, float32* tmpArray1,
                             uint32* tmpArray2, uint32 n) const = 0;
+};
+
+/**
+ * Defines an interface for all classes that represent the body of a rule.
+ */
+class MLRLCOMMON_API IBody : public IConditional {
+    public:
+
+        virtual ~IBody() override {};
+
+        /**
+         * A visitor function for handling objects of the type `EmptyBody`.
+         */
+        typedef std::function<void(const EmptyBody&)> EmptyBodyVisitor;
+
+        /**
+         * A visitor function for handling objects of the type `ConjunctiveBody`.
+         */
+        typedef std::function<void(const ConjunctiveBody&)> ConjunctiveBodyVisitor;
 
         /**
          * Invokes one of the given visitor functions, depending on which one is able to handle this particular type of