rowsens.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
#include "anpcpp/limit_matrix.hpp"
#include "anpcpp/matrix.hpp"
 
namespace anpcpp {
 
enum class P0ModeKind {
  Direct,
  Smart,
  OriginalWeight
};
 
struct P0Mode {
  P0ModeKind kind = P0ModeKind::Direct;
  double direct = 0.5;
  std::size_t smart_alt = 0;
 
  static P0Mode Direct(double p0) {
    P0Mode m;
    m.kind = P0ModeKind::Direct;
    m.direct = p0;
    return m;
  }
  static P0Mode Smart(std::size_t alt_index) {
    P0Mode m;
    m.kind = P0ModeKind::Smart;
    m.smart_alt = alt_index;
    return m;
  }
  static P0Mode Original() {
    P0Mode m;
    m.kind = P0ModeKind::OriginalWeight;
    return m;
  }
};
 
struct InfluenceRawEntry {
  std::string name;
  double original = 0.0;
  double up_score = 0.0;
  double up_diff = 0.0;
  double down_score = 0.0;
  double down_diff = 0.0;
};
 
struct InfluenceRankEntry {
  std::string name;
  double original = 0.0;
  double rank_influence = 0.0;
};
 
struct InfluenceMarginalEntry {
  std::string name;
  double marginal = 0.0;
  double smart_p0 = 0.5;
};
 
struct InfluenceTotalEntry {
  std::string name;
  double total_influence = 0.0;
  double max_alt_change = 0.0;
};
 
[[nodiscard]] Matrix row_adjust(const Matrix& mat,
                                std::size_t row,
                                double p,
                                const P0Mode& p0mode = P0Mode::Direct(0.5),
                                const std::vector<std::size_t>& cluster_nodes = {});
 
[[nodiscard]] double smart_p0(
    const Matrix& mat,
    std::size_t row,
    std::size_t cont_alt,
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {});
 
[[nodiscard]] Vector priority_after_row_adjust(
    const Matrix& mat,
    std::size_t row,
    double p,
    const P0Mode& p0mode = P0Mode::Direct(0.5),
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {},
    bool normalize_to_orig = true);
 
[[nodiscard]] Vector influence_marginal(
    const Matrix& mat,
    std::size_t row,
    double p0,
    int left_or_right = 0,
    double delta = 1e-6,
    const std::vector<std::size_t>& influence_nodes = {},
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {});
 
[[nodiscard]] std::vector<InfluenceMarginalEntry> influence_marginal_smart(
    const Matrix& mat,
    std::size_t row,
    const std::vector<std::size_t>& influence_nodes,
    const std::vector<std::string>& names,
    const std::vector<std::size_t>& cluster_nodes = {},
    double delta = 1e-6,
    const LimitMatrixOptions& options = {});
 
[[nodiscard]] std::vector<InfluenceRawEntry> influence_raw(
    const Matrix& mat,
    std::size_t row,
    const std::vector<std::size_t>& influence_nodes,
    const std::vector<std::string>& names,
    double delta_up = 0.1,
    double delta_down = 0.1,
    double p0 = 0.5,
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {});
 
[[nodiscard]] std::vector<InfluenceRankEntry> influence_rank(
    const Matrix& mat,
    std::size_t row,
    const std::vector<std::size_t>& influence_nodes,
    const std::vector<std::string>& names,
    const std::vector<std::size_t>& cluster_nodes = {},
    double error = 1e-5,
    int round_to_decimal = 5,
    const LimitMatrixOptions& options = {});
 
[[nodiscard]] InfluenceTotalEntry influence_total_row(
    const Matrix& mat,
    std::size_t row,
    const std::vector<std::size_t>& influence_nodes,
    double delta = 0.25,
    double p0 = 0.5,
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {});
 
[[nodiscard]] std::vector<InfluenceTotalEntry> influence_total(
    const Matrix& mat,
    const std::vector<std::size_t>& rows,
    const std::vector<std::string>& row_names,
    const std::vector<std::size_t>& influence_nodes,
    double delta = 0.25,
    double p0 = 0.5,
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {});
 
[[nodiscard]] Vector perspective(
    const Matrix& mat,
    std::size_t row,
    const P0Mode& p0mode = P0Mode::Direct(0.5),
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {},
    bool normalize_to_orig = true);
 
[[nodiscard]] Matrix perspective_matrix(
    const Matrix& mat,
    const std::vector<std::size_t>& rows = {},
    const P0Mode& p0mode = P0Mode::Direct(0.5),
    const std::vector<std::size_t>& cluster_nodes = {},
    const LimitMatrixOptions& options = {},
    bool normalize_to_orig = true);
 
inline constexpr double kPerspectivePCoarse = 1.0 - 1e-6;
inline constexpr double kPerspectivePFine = 1.0 - 1e-7;
inline constexpr double kPerspectivePRefine = 1.0 - 1e-9;
inline constexpr double kPerspectiveAgreeTol = 1e-6;
 
}  // namespace anpcpp