multiuser.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <map>
#include <string>
#include <vector>
 
#include "anpcpp/pairwise.hpp"
#include "anpcpp/ratings.hpp"
 
namespace anpcpp {
 
struct JudgmentParticipant {
  std::string id;
  std::string name;
  std::string email;
};
 
struct JudgmentGroup {
  std::string id;
  std::string name;
  std::vector<std::string> member_ids;
};
 
enum class JudgmentScopeKind {
  Average,
  Participant,
  Group,
};
 
struct JudgmentSession {
  JudgmentScopeKind kind = JudgmentScopeKind::Average;
  std::string id;
};
 
inline constexpr const char* kDefaultParticipantId = "default";
 
void aggregate_pairwise_geometric(
    const std::vector<const PairwiseJudgments*>& inputs,
    PairwiseJudgments& out);
 
void aggregate_ratings_arithmetic(
    const std::vector<const RatingsPrioritizer*>& inputs,
    const RatingsPrioritizer& scale_template,
    RatingsPrioritizer& out);
 
void copy_pairwise_into(const PairwiseJudgments& src, PairwiseJudgments& out);
 
void copy_ratings_votes_into(const RatingsPrioritizer& src,
                             RatingsPrioritizer& out);
 
struct PairwiseCellDisagreement {
  double min = 0.0;
  double max = 0.0;
  double ratio = 0.0;
  int contributor_count = 0;
};
 
struct RatingsAltDisagreement {
  std::string alt;
  double min = 0.0;
  double max = 0.0;
  double range = 0.0;
  int contributor_count = 0;
};
 
struct JudgmentFillCounts {
  std::size_t filled = 0;
  std::size_t needed = 0;
};
 
[[nodiscard]] std::vector<std::vector<PairwiseCellDisagreement>>
pairwise_disagreement(const std::vector<const PairwiseJudgments*>& inputs);
 
[[nodiscard]] std::vector<RatingsAltDisagreement> ratings_disagreement(
    const std::vector<const RatingsPrioritizer*>& inputs,
    const std::vector<std::string>& alt_order = {});
 
[[nodiscard]] JudgmentFillCounts pairwise_fill_counts(
    const PairwiseJudgments& pw);
 
[[nodiscard]] JudgmentFillCounts ratings_fill_counts(
    const RatingsPrioritizer& rt);
 
struct VoteSpreadSummary {
  std::vector<double> values;
  double min = 0.0;
  double max = 0.0;
  double mean = 0.0;
  double band_low = 0.0;
  double band_high = 0.0;
  double alignment_pct = 0.0;
  int contributor_count = 0;
};
 
inline constexpr double kPairwiseAlignmentSpanRatio = 81.0;
 
[[nodiscard]] double pairwise_alignment_pct(double min_v, double max_v);
 
[[nodiscard]] double ratings_alignment_pct(double range, double full_scale);
 
[[nodiscard]] VoteSpreadSummary summarize_pairwise_votes(
    const std::vector<double>& values);
 
[[nodiscard]] VoteSpreadSummary summarize_ratings_votes(
    const std::vector<double>& values, double full_scale = 1.0);
 
}  // namespace anpcpp