network.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "anpcpp/limit_matrix.hpp"
#include "anpcpp/matrix.hpp"
#include "anpcpp/multiuser.hpp"
#include "anpcpp/pairwise.hpp"
#include "anpcpp/ratings.hpp"
#include "anpcpp/rowsens.hpp"
#include "anpcpp/synthesis.hpp"
 
namespace anpcpp {
 
class AnpNetwork;
class AnpCluster;
 
enum class NodePrioritizerKind { Pairwise, Ratings };
 
struct NodePrioritizerSlot {
  NodePrioritizerKind kind = NodePrioritizerKind::Pairwise;
  PairwiseJudgments pairwise;
  RatingsPrioritizer ratings;
  std::map<std::string, PairwiseJudgments> user_pairwise;
  std::map<std::string, RatingsPrioritizer> user_ratings;
 
  [[nodiscard]] const std::vector<std::string>& alternatives() const;
  [[nodiscard]] bool empty() const;
  [[nodiscard]] bool has_alternative(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);
  void rename_alternative(const std::string& old_name,
                          const std::string& new_name);
  [[nodiscard]] Vector priorities() const;
  void set_kind(NodePrioritizerKind new_kind);
 
  PairwiseJudgments& ensure_user_pairwise(const std::string& user_id);
  RatingsPrioritizer& ensure_user_ratings(const std::string& user_id);
  void sync_ratings_scale_to_users();
};
 
class AnpNode {
public:
  AnpNode(AnpNetwork* network, AnpCluster* cluster, std::string name);
 
  [[nodiscard]] const std::string& name() const noexcept { return name_; }
  [[nodiscard]] const std::string& description() const noexcept {
    return description_;
  }
  void set_description(std::string description) {
    description_ = std::move(description);
  }
 
  [[nodiscard]] AnpCluster* cluster() const noexcept { return cluster_; }
  [[nodiscard]] AnpNetwork* network() const noexcept { return network_; }
 
  [[nodiscard]] bool invert() const noexcept { return invert_; }
  void set_invert(bool value) { invert_ = value; }
 
  void connect_to(AnpNode* dest);
  void disconnect_from(AnpNode* dest);
  [[nodiscard]] bool is_connected_to(const AnpNode* dest) const;
  [[nodiscard]] bool is_connected_to_cluster(const std::string& cluster_name) const;
 
  [[nodiscard]] PairwiseJudgments* node_pairwise(const std::string& dest_cluster);
  [[nodiscard]] const PairwiseJudgments* node_pairwise(
      const std::string& dest_cluster) const;
 
  [[nodiscard]] RatingsPrioritizer* node_ratings(const std::string& dest_cluster);
  [[nodiscard]] const RatingsPrioritizer* node_ratings(
      const std::string& dest_cluster) const;
 
  [[nodiscard]] NodePrioritizerKind node_prioritizer_kind(
      const std::string& dest_cluster) const;
 
  void set_node_prioritizer_kind(const std::string& dest_cluster,
                                 NodePrioritizerKind kind);
 
  [[nodiscard]] NodePrioritizerSlot* node_prioritizer(
      const std::string& dest_cluster);
  [[nodiscard]] const NodePrioritizerSlot* node_prioritizer(
      const std::string& dest_cluster) const;
 
  [[nodiscard]] Vector unscaled_column() const;
 
  [[nodiscard]] AnpNetwork* subnetwork() const noexcept {
    return subnetwork_.get();
  }
  [[nodiscard]] bool has_subnetwork() const noexcept {
    return subnetwork_ != nullptr;
  }
  AnpNetwork& ensure_subnetwork();
 
private:
  friend class AnpNetwork;
  friend class AnpCluster;
 
  AnpNetwork* network_ = nullptr;
  AnpCluster* cluster_ = nullptr;
  std::string name_;
  std::string description_;
  bool invert_ = false;
  std::map<std::string, NodePrioritizerSlot> node_prioritizers_;
  std::unique_ptr<AnpNetwork> subnetwork_;
};
 
class AnpCluster {
public:
  AnpCluster(AnpNetwork* network, std::string name);
 
  [[nodiscard]] const std::string& name() const noexcept { return name_; }
  [[nodiscard]] const std::string& description() const noexcept {
    return description_;
  }
  void set_description(std::string description) {
    description_ = std::move(description);
  }
 
  [[nodiscard]] AnpNetwork* network() const noexcept { return network_; }
  [[nodiscard]] std::size_t nnodes() const noexcept { return nodes_.size(); }
 
  AnpNode& add_node(const std::string& name);
 
  void move_node(const std::string& name, std::size_t new_index);
 
  [[nodiscard]] AnpNode* find_node(const std::string& name);
  [[nodiscard]] const AnpNode* find_node(const std::string& name) const;
  [[nodiscard]] AnpNode& node(const std::string& name);
  [[nodiscard]] const AnpNode& node(const std::string& name) const;
 
  [[nodiscard]] std::vector<std::string> node_names() const;
  [[nodiscard]] std::vector<AnpNode*> nodes();
  [[nodiscard]] std::vector<const AnpNode*> nodes() const;
 
  void cluster_connect(AnpCluster* dest);
  [[nodiscard]] PairwiseJudgments& cluster_pairwise() { return prioritizer_; }
  [[nodiscard]] const PairwiseJudgments& cluster_pairwise() const {
    return prioritizer_;
  }
  [[nodiscard]] std::map<std::string, PairwiseJudgments>& user_cluster_pairwise() {
    return user_prioritizers_;
  }
  [[nodiscard]] const std::map<std::string, PairwiseJudgments>&
  user_cluster_pairwise() const {
    return user_prioritizers_;
  }
  PairwiseJudgments& ensure_user_cluster_pairwise(const std::string& user_id);
 
private:
  friend class AnpNetwork;
  friend class AnpNode;
 
  AnpNetwork* network_ = nullptr;
  std::string name_;
  std::string description_;
  std::vector<std::unique_ptr<AnpNode>> nodes_;
  PairwiseJudgments prioritizer_;
  std::map<std::string, PairwiseJudgments> user_prioritizers_;
};
 
class AnpNetwork {
public:
  static constexpr const char* kDefaultAlternativesCluster = "Alternatives";
 
  explicit AnpNetwork(bool create_alts_cluster = true);
 
  AnpNetwork(const AnpNetwork&) = delete;
  AnpNetwork& operator=(const AnpNetwork&) = delete;
  AnpNetwork(AnpNetwork&&) noexcept = default;
  AnpNetwork& operator=(AnpNetwork&&) noexcept = default;
 
  AnpCluster& add_cluster(const std::string& name);
  [[nodiscard]] AnpCluster* find_cluster(const std::string& name);
  [[nodiscard]] const AnpCluster* find_cluster(const std::string& name) const;
  [[nodiscard]] AnpCluster& cluster(const std::string& name);
  [[nodiscard]] const AnpCluster& cluster(const std::string& name) const;
 
  [[nodiscard]] AnpCluster* alternatives_cluster() const noexcept {
    return alts_cluster_;
  }
  void set_alternatives_cluster(const std::string& name);
 
  AnpNode& add_node(const std::string& cluster_name, const std::string& node_name);
  void move_node(const std::string& name, std::size_t new_index);
  [[nodiscard]] AnpNode* find_node(const std::string& name);
  [[nodiscard]] const AnpNode* find_node(const std::string& name) const;
  [[nodiscard]] AnpNode& node(const std::string& name);
  [[nodiscard]] const AnpNode& node(const std::string& name) const;
 
  void node_connect(const std::string& src, const std::string& dest);
  void node_disconnect(const std::string& src, const std::string& dest);
  void set_node_comparison(const std::string& wrt_node,
                           const std::string& a,
                           const std::string& b,
                           double value);
  void set_cluster_comparison(const std::string& wrt_cluster,
                              const std::string& a,
                              const std::string& b,
                              double value);
 
  void set_node_prioritizer_kind(const std::string& wrt_node,
                                 const std::string& dest_cluster,
                                 NodePrioritizerKind kind);
 
  void set_node_rating(const std::string& wrt_node,
                       const std::string& alt,
                       const std::string& category_id);
 
  void set_node_rating_value(const std::string& wrt_node,
                             const std::string& alt,
                             double raw);
 
  void remove_node(const std::string& name);
  void remove_cluster(const std::string& name);
  void rename_node(const std::string& old_name, const std::string& new_name);
  void rename_cluster(const std::string& old_name, const std::string& new_name);
  void clear_subnetwork(const std::string& node_name);
 
  [[nodiscard]] const std::string& name() const noexcept { return name_; }
  void set_name(std::string name) { name_ = std::move(name); }
 
  [[nodiscard]] const std::string& description() const noexcept {
    return description_;
  }
  void set_description(std::string description) {
    description_ = std::move(description);
  }
 
  [[nodiscard]] const SynthesisOptions& synthesis_options() const noexcept {
    return synthesis_;
  }
  void set_synthesis_options(SynthesisOptions options) {
    synthesis_ = std::move(options);
  }
 
  [[nodiscard]] const LimitMatrixOptions& limit_matrix_options() const noexcept {
    return limit_options_;
  }
  void set_limit_matrix_options(LimitMatrixOptions options) {
    limit_options_ = std::move(options);
  }
 
  void set_cluster_position(const std::string& name, double x, double y);
  void set_node_position(const std::string& name, double x, double y);
  [[nodiscard]] bool cluster_position(const std::string& name,
                                      double& x,
                                      double& y) const;
  [[nodiscard]] bool node_position(const std::string& name,
                                   double& x,
                                   double& y) const;
 
  [[nodiscard]] std::size_t nnodes() const;
  [[nodiscard]] std::size_t nclusters() const noexcept {
    return clusters_.size();
  }
  [[nodiscard]] std::vector<std::string> cluster_names() const;
  [[nodiscard]] std::vector<std::string> node_names() const;
  [[nodiscard]] std::vector<AnpCluster*> clusters();
  [[nodiscard]] std::vector<const AnpCluster*> clusters() const;
  [[nodiscard]] std::vector<AnpNode*> nodes();
  [[nodiscard]] std::vector<const AnpNode*> nodes() const;
 
  [[nodiscard]] Matrix unscaled_supermatrix() const;
  [[nodiscard]] Matrix cluster_weight_matrix() const;
  [[nodiscard]] Matrix scaled_supermatrix() const;
  [[nodiscard]] Matrix limit_matrix(
      const LimitMatrixOptions& options = {}) const;
  [[nodiscard]] Vector global_priority(
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] bool has_subnet() const;
  AnpNetwork& subnet(const std::string& node_name);
  [[nodiscard]] std::vector<std::string> alt_names() const;
  [[nodiscard]] Vector priority(const LimitMatrixOptions& options = {}) const;
  [[nodiscard]] std::map<std::string, double> priority_map(
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] std::map<std::string, double> priority_map_at_p(
      const std::string& wrt_node,
      double p,
      const P0Mode& p0mode = P0Mode::Direct(0.5),
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] Vector priority_at_p(
      const std::string& wrt_node,
      double p,
      const P0Mode& p0mode = P0Mode::Direct(0.5),
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] std::vector<InfluenceRawEntry> influence_raw(
      const std::string& wrt_node,
      double delta_up = 0.1,
      double delta_down = 0.1,
      double p0 = 0.5,
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] std::vector<InfluenceRankEntry> influence_rank(
      double error = 1e-5,
      int round_to_decimal = 5,
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] std::vector<InfluenceMarginalEntry> influence_marginal_smart(
      double delta = 1e-6,
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] std::vector<InfluenceTotalEntry> influence_total(
      double delta = 0.25,
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] Vector perspective(
      const std::string& wrt_node,
      const P0Mode& p0mode = P0Mode::Direct(0.5),
      const LimitMatrixOptions& options = {}) const;
 
  [[nodiscard]] Matrix perspective_matrix(
      const P0Mode& p0mode = P0Mode::Direct(0.5),
      const LimitMatrixOptions& options = {}) const;
 
  // --- Multi-user judgments -------------------------------------------------
 
  [[nodiscard]] const std::vector<JudgmentParticipant>& participants() const {
    return participants_;
  }
  [[nodiscard]] std::vector<JudgmentParticipant>& participants() {
    return participants_;
  }
  [[nodiscard]] const std::vector<JudgmentGroup>& judgment_groups() const {
    return groups_;
  }
  [[nodiscard]] std::vector<JudgmentGroup>& judgment_groups() { return groups_; }
  [[nodiscard]] const JudgmentSession& judgment_session() const {
    return session_;
  }
  void set_judgment_session(JudgmentSession session) {
    session_ = std::move(session);
  }
 
  JudgmentParticipant& add_participant(std::string id,
                                       std::string name,
                                       std::string email = {});
  void remove_participant(const std::string& id);
  [[nodiscard]] JudgmentParticipant* find_participant(const std::string& id);
  [[nodiscard]] const JudgmentParticipant* find_participant(
      const std::string& id) const;
 
  JudgmentGroup& add_judgment_group(std::string id,
                                    std::string name,
                                    std::vector<std::string> member_ids = {});
  void remove_judgment_group(const std::string& id);
  [[nodiscard]] JudgmentGroup* find_judgment_group(const std::string& id);
  [[nodiscard]] const JudgmentGroup* find_judgment_group(
      const std::string& id) const;
 
  [[nodiscard]] std::vector<std::string> session_member_ids() const;
 
  void rebuild_effective_judgments();
 
  void ensure_multiuser_initialized();
 
  void set_node_comparison_for(const std::string& user_id,
                               const std::string& wrt_node,
                               const std::string& a,
                               const std::string& b,
                               double value);
 
  void set_cluster_comparison_for(const std::string& user_id,
                                  const std::string& wrt_cluster,
                                  const std::string& a,
                                  const std::string& b,
                                  double value);
 
  void set_node_rating_for(const std::string& user_id,
                           const std::string& wrt_node,
                           const std::string& alt,
                           const std::string& category_id);
 
  void set_node_rating_value_for(const std::string& user_id,
                                 const std::string& wrt_node,
                                 const std::string& alt,
                                 double raw);
 
private:
  friend class AnpNode;
  friend class AnpCluster;
 
  void register_node(AnpNode* node);
  void unregister_node(const std::string& name);
  [[nodiscard]] std::size_t node_index(const std::string& name) const;
  [[nodiscard]] std::vector<std::size_t> cluster_row_indices(
      const std::string& node_name) const;
 
  [[nodiscard]] Vector subnet_synthesize_from_global(
      const Vector& gp,
      const LimitMatrixOptions& options) const;
 
  [[nodiscard]] Vector subnet_synthesize(
      const LimitMatrixOptions& options) const;
 
  void rebuild_effective_judgments_local();
  void migrate_effective_into_default_user();
 
  std::vector<std::unique_ptr<AnpCluster>> clusters_;
  AnpCluster* alts_cluster_ = nullptr;
  std::unordered_map<std::string, AnpNode*> node_index_;
  std::string name_;
  std::string description_;
  SynthesisOptions synthesis_;
  LimitMatrixOptions limit_options_;
  std::map<std::string, std::pair<double, double>> cluster_positions_;
  std::map<std::string, std::pair<double, double>> node_positions_;
  std::vector<JudgmentParticipant> participants_;
  std::vector<JudgmentGroup> groups_;
  JudgmentSession session_;
};
 
}  // namespace anpcpp