toki/StartRNR
1
0
Fork 0
Code Issues Pull requests Activity

fix: resolve inconsistent name of dataset option

Browse source
This commit is contained in:
Kiana Sheibani 2024-08-18 02:50:40 -04:00
parent 4b44b82531
commit e644f96648
Signed by: toki
GPG key ID: 6CB106C25E86A9F7
3 changed files with 29 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

45
src/database.rs
View file

@ -14,7 +14,7 @@ pub struct DatasetMetadata {
pub state: Option<String>, pub state: Option<String>,
pub decay_const: f64, pub decay_const: f64,
pub var_const: f64, pub var_rate: f64,
} }
/// Return the path to the datasets file. /// Return the path to the datasets file.
@ -48,8 +48,8 @@ CREATE TABLE IF NOT EXISTS datasets (
game_slug TEXT NOT NULL, game_slug TEXT NOT NULL,
country TEXT, country TEXT,
state TEXT, state TEXT,
decay_rate REAL NOT NULL, decay_const REAL NOT NULL,
var_const REAL NOT NULL var_rate REAL NOT NULL
) STRICT; ) STRICT;
CREATE TABLE IF NOT EXISTS players ( CREATE TABLE IF NOT EXISTS players (
@ -108,8 +108,8 @@ pub fn list_datasets(connection: &Connection) -> sqlite::Result<Vec<(String, Dat
game_slug: r_.read::<&str, _>("game_slug").to_owned(), game_slug: r_.read::<&str, _>("game_slug").to_owned(),
country: r_.read::<Option<&str>, _>("country").map(String::from), country: r_.read::<Option<&str>, _>("country").map(String::from),
state: r_.read::<Option<&str>, _>("state").map(String::from), state: r_.read::<Option<&str>, _>("state").map(String::from),
decay_const: r_.read::<f64, _>("decay_rate"), decay_const: r_.read::<f64, _>("decay_const"),
var_const: r_.read::<f64, _>("adj_decay_rate"), var_rate: r_.read::<f64, _>("var_rate"),
}, },
)) ))
}) })
@ -200,7 +200,7 @@ CREATE INDEX "{0}_network_B" ON "{0}_network" (player_B);"#,
.bind((8, metadata.country.as_deref()))? .bind((8, metadata.country.as_deref()))?
.bind((9, metadata.state.as_deref()))? .bind((9, metadata.state.as_deref()))?
.bind((10, metadata.decay_const))? .bind((10, metadata.decay_const))?
.bind((11, metadata.var_const))? .bind((11, metadata.var_rate))?
.try_for_each(|x| x.map(|_| ()))?; .try_for_each(|x| x.map(|_| ()))?;
connection.execute(query2) connection.execute(query2)
@ -230,8 +230,8 @@ pub fn get_metadata(
game_slug: r_.read::<&str, _>("game_slug").to_owned(), game_slug: r_.read::<&str, _>("game_slug").to_owned(),
country: r_.read::<Option<&str>, _>("country").map(String::from), country: r_.read::<Option<&str>, _>("country").map(String::from),
state: r_.read::<Option<&str>, _>("state").map(String::from), state: r_.read::<Option<&str>, _>("state").map(String::from),
decay_const: r_.read::<f64, _>("decay_rate"), decay_const: r_.read::<f64, _>("decay_const"),
var_const: r_.read::<f64, _>("var_const"), var_rate: r_.read::<f64, _>("var_rate"),
}) })
}) })
.and_then(Result::ok)) .and_then(Result::ok))
@ -484,7 +484,7 @@ pub fn adjust_for_time(
connection: &Connection, connection: &Connection,
dataset: &str, dataset: &str,
player: PlayerId, player: PlayerId,
var_const: f64, var_rate: f64,
time: Timestamp, time: Timestamp,
) -> sqlite::Result<()> { ) -> sqlite::Result<()> {
let query = format!( let query = format!(
@ -497,7 +497,7 @@ WHERE player_A = :i OR player_B = :i"#,
let mut statement = connection.prepare(query)?; let mut statement = connection.prepare(query)?;
statement.bind((":i", player.0 as i64))?; statement.bind((":i", player.0 as i64))?;
statement.bind((":c", var_const))?; statement.bind((":c", var_rate))?;
statement.bind((":t", time.0 as i64))?; statement.bind((":t", time.0 as i64))?;
statement.into_iter().try_for_each(|x| x.map(|_| ())) statement.into_iter().try_for_each(|x| x.map(|_| ()))
} }
@ -511,7 +511,7 @@ pub fn glicko_adjust(
advantage: f64, advantage: f64,
variance: f64, variance: f64,
winner: usize, winner: usize,
decay_rate: f64, decay_const: f64,
) -> sqlite::Result<()> { ) -> sqlite::Result<()> {
let score = if winner != 0 { 1.0 } else { 0.0 }; let score = if winner != 0 { 1.0 } else { 0.0 };
@ -544,7 +544,7 @@ WHERE player_A = min(:a, :b) AND player_B = max(:a, :b)"#,
statement.bind((":pl", player1.0 as i64))?; statement.bind((":pl", player1.0 as i64))?;
statement.bind((":plo", player2.0 as i64))?; statement.bind((":plo", player2.0 as i64))?;
statement.bind((":adj", -0.5 * adjust))?; statement.bind((":adj", -0.5 * adjust))?;
statement.bind((":d", decay_rate))?; statement.bind((":d", decay_const))?;
statement.bind((":lv", like_var))?; statement.bind((":lv", like_var))?;
statement.into_iter().try_for_each(|x| x.map(|_| ()))?; statement.into_iter().try_for_each(|x| x.map(|_| ()))?;
@ -552,7 +552,7 @@ WHERE player_A = min(:a, :b) AND player_B = max(:a, :b)"#,
statement.bind((":pl", player2.0 as i64))?; statement.bind((":pl", player2.0 as i64))?;
statement.bind((":plo", player1.0 as i64))?; statement.bind((":plo", player1.0 as i64))?;
statement.bind((":adj", 0.5 * adjust))?; statement.bind((":adj", 0.5 * adjust))?;
statement.bind((":d", decay_rate))?; statement.bind((":d", decay_const))?;
statement.bind((":lv", like_var))?; statement.bind((":lv", like_var))?;
statement.into_iter().try_for_each(|x| x.map(|_| ()))?; statement.into_iter().try_for_each(|x| x.map(|_| ()))?;
@ -624,20 +624,20 @@ pub fn hypothetical_advantage(
dataset: &str, dataset: &str,
player1: PlayerId, player1: PlayerId,
player2: PlayerId, player2: PlayerId,
decay_rate: f64, decay_const: f64,
) -> sqlite::Result<(f64, f64)> { ) -> sqlite::Result<(f64, f64)> {
use std::collections::{HashSet, VecDeque}; use std::collections::{HashSet, VecDeque};
// Check trivial cases // Check trivial cases
if player1 == player2 { if player1 == player2 {
return Ok((0.0, 0.0)); return Ok((0.0, 0.0));
} else if decay_rate < 0.05 || either_isolated(connection, dataset, player1, player2)? { } else if decay_const < 0.05 || either_isolated(connection, dataset, player1, player2)? {
return Ok((0.0, 5.0)); return Ok((0.0, 5.0));
} }
let mut visited: HashSet<PlayerId> = HashSet::new(); let mut visited: HashSet<PlayerId> = HashSet::new();
let mut queue: VecDeque<(PlayerId, Vec<(f64, f64, f64)>)> = let mut queue: VecDeque<(PlayerId, Vec<(f64, f64, f64)>)> =
VecDeque::from([(player1, Vec::from([(0.0, 0.0, 1.0 / decay_rate)]))]); VecDeque::from([(player1, Vec::from([(0.0, 0.0, 1.0 / decay_const)]))]);
let mut final_paths = Vec::new(); let mut final_paths = Vec::new();
@ -662,7 +662,7 @@ pub fn hypothetical_advantage(
if rf.len() < 100 { if rf.len() < 100 {
let iter = paths let iter = paths
.iter() .iter()
.map(|(av, vr, dec)| (av + adv, vr + var, dec * decay_rate)); .map(|(av, vr, dec)| (av + adv, vr + var, dec * decay_const));
rf.extend(iter); rf.extend(iter);
rf.truncate(100); rf.truncate(100);
@ -697,10 +697,10 @@ pub fn initialize_edge(
dataset: &str, dataset: &str,
player1: PlayerId, player1: PlayerId,
player2: PlayerId, player2: PlayerId,
decay_rate: f64, decay_const: f64,
time: Timestamp, time: Timestamp,
) -> sqlite::Result<(f64, f64)> { ) -> sqlite::Result<(f64, f64)> {
let (adv, var) = hypothetical_advantage(connection, dataset, player1, player2, decay_rate)?; let (adv, var) = hypothetical_advantage(connection, dataset, player1, player2, decay_const)?;
insert_network_data(connection, dataset, player1, player2, adv, var, time)?; insert_network_data(connection, dataset, player1, player2, adv, var, time)?;
Ok((adv, var)) Ok((adv, var))
} }
@ -724,9 +724,8 @@ CREATE TABLE IF NOT EXISTS datasets (
country TEXT, country TEXT,
state TEXT, state TEXT,
set_limit INTEGER NOT NULL, set_limit INTEGER NOT NULL,
decay_rate REAL NOT NULL, decay_const REAL NOT NULL,
adj_decay_rate REAL NOT NULL, var_rate REAL NOT NULL
var_const
) STRICT; ) STRICT;
CREATE TABLE IF NOT EXISTS players ( CREATE TABLE IF NOT EXISTS players (
@ -766,7 +765,7 @@ CREATE TABLE IF NOT EXISTS sets (
country: None, country: None,
state: None, state: None,
decay_const: 0.5, decay_const: 0.5,
var_const: 0.00000001, var_rate: 0.00000001,
} }
} }

10
src/main.rs
View file

@ -404,7 +404,7 @@ End date (year, m/y, or m/d/y): "
// Defaults // Defaults
let mut decay_const = 0.9; let mut decay_const = 0.9;
let mut var_const = (10.0 - 0.04) / SECS_IN_YEAR as f64 / 3.0; let mut var_rate = (10.0 - 0.04) / SECS_IN_YEAR as f64 / 3.0;
print!("\nConfigure advanced options? (y/n) "); print!("\nConfigure advanced options? (y/n) ");
if let Some('y') = read_string().chars().next() { if let Some('y') = read_string().chars().next() {
@ -445,9 +445,9 @@ default will be chosen.
Variance rate: " Variance rate: "
); );
let var_const_input = read_string(); let var_rate_input = read_string();
if !var_const_input.is_empty() { if !var_rate_input.is_empty() {
var_const = var_const_input var_rate = var_rate_input
.parse::<f64>() .parse::<f64>()
.unwrap_or_else(|_| error("Input is not a number", 1)); .unwrap_or_else(|_| error("Input is not a number", 1));
} }
@ -468,7 +468,7 @@ Variance rate: "
country, country,
state, state,
decay_const, decay_const,
var_const, var_rate,
}, },
) )
.expect("Error communicating with SQLite"); .expect("Error communicating with SQLite");

4
src/sync.rs
View file

@ -134,8 +134,8 @@ fn update_from_set(
// Time-adjust all variances associated with each player // Time-adjust all variances associated with each player
let time = results.time.unwrap_or(event_time); let time = results.time.unwrap_or(event_time);
adjust_for_time(connection, dataset, player1, metadata.var_const, time)?; adjust_for_time(connection, dataset, player1, metadata.var_rate, time)?;
adjust_for_time(connection, dataset, player2, metadata.var_const, time)?; adjust_for_time(connection, dataset, player2, metadata.var_rate, time)?;
let (advantage, variance) = match get_network_data(connection, dataset, player1, player2) { let (advantage, variance) = match get_network_data(connection, dataset, player1, player2) {
Err(e) => Err(e)?, Err(e) => Err(e)?,