ratings.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <optional>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
#include "anpcpp/matrix.hpp"
 
namespace anpcpp {
 
struct RatingCategory {
  std::string id;
  std::string label;
  double value = 0.0;
};
 
struct IdentityInterpreter {};
 
struct DivideByMaxInterpreter {};
 
struct DivideByConstantInterpreter {
  double constant = 1.0;
};
 
struct MinMaxNormalizeInterpreter {};
 
struct PiecewiseLinearInterpreter {
  std::vector<std::pair<double, double>> knots;
};
 
using ScoreInterpreter =
    std::variant<IdentityInterpreter,
                 DivideByMaxInterpreter,
                 DivideByConstantInterpreter,
                 MinMaxNormalizeInterpreter,
                 PiecewiseLinearInterpreter>;
 
[[nodiscard]] std::vector<std::optional<double>> apply_score_interpreter(
    const ScoreInterpreter& interpreter,
    const std::vector<std::optional<double>>& raw);
 
class RatingsPrioritizer {
public:
  enum class Mode { Categorical, Numeric };
 
  RatingsPrioritizer() = default;
 
  explicit RatingsPrioritizer(std::vector<std::string> alternatives);
 
  [[nodiscard]] std::size_t size() const noexcept {
    return alternatives_.size();
  }
  [[nodiscard]] bool empty() const noexcept { return alternatives_.empty(); }
  [[nodiscard]] const std::vector<std::string>& alternatives() const noexcept {
    return alternatives_;
  }
 
  [[nodiscard]] bool has_alternative(const std::string& name) const;
  [[nodiscard]] std::size_t index_of(const std::string& name) const;
 
  void add_alternative(const std::string& name, bool ignore_existing = false);
 
  void remove_alternative(const std::string& name,
                          bool ignore_missing = false);
 
  [[nodiscard]] Mode mode() const noexcept { return mode_; }
  void set_mode(Mode mode) { mode_ = mode; }
 
  [[nodiscard]] const std::vector<RatingCategory>& categories() const noexcept {
    return categories_;
  }
  void set_categories(std::vector<RatingCategory> categories);
 
  [[nodiscard]] const ScoreInterpreter& interpreter() const noexcept {
    return interpreter_;
  }
  void set_interpreter(ScoreInterpreter interpreter) {
    interpreter_ = std::move(interpreter);
  }
 
  void set_rating(const std::string& alt, const std::string& category_id);
  void clear_rating(const std::string& alt);
  [[nodiscard]] std::optional<std::string> rating(
      const std::string& alt) const;
 
  void set_value(const std::string& alt, double raw);
  void clear_value(const std::string& alt);
  [[nodiscard]] std::optional<double> value(const std::string& alt) const;
 
  [[nodiscard]] Vector scores() const;
 
  [[nodiscard]] Vector priorities() const;
 
private:
  [[nodiscard]] std::optional<double> intensity_at(std::size_t i) const;
  [[nodiscard]] const RatingCategory* find_category(
      const std::string& id) const;
 
  std::vector<std::string> alternatives_;
  Mode mode_ = Mode::Numeric;
  std::vector<RatingCategory> categories_;
  std::vector<std::optional<std::string>> categorical_;
  std::vector<std::optional<double>> numeric_;
  ScoreInterpreter interpreter_ = IdentityInterpreter{};
};
 
}  // namespace anpcpp