model.h

/*
    Copyright (C) 2016-2019  Michelle Blom

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/


#ifndef _MODEL_H
#define _MODEL_H

#include<vector>
#include<set>
#include<exception>
#include<boost/lexical_cast.hpp>
#include<boost/filesystem.hpp>
#include<boost/tokenizer.hpp>
#include<boost/algorithm/string.hpp>
#include<map>

#ifndef _WIN32
#include<sys/time.h>
#endif

typedef std::vector<int> Ints;
typedef std::vector<double> Doubles;
typedef std::set<int> SInts;
typedef std::set<SInts> SInts2d;
typedef std::set<SInts2d> SInts3d;
typedef std::vector<Ints> Ints2d;
typedef std::vector<std::string> Strings;

struct mytimespec
{
	double seconds;
};

void GetTime(struct mytimespec* t);


struct Config
{
	int ncandidates;
	double totalvotes;

	bool tightbounds;
	bool compbounds;
	bool optlog;
    bool debug;
    bool allowties;
    bool test_all_losers;

    std::map<std::string,int> name2index;
    std::map<int, std::string> index2name;
	Strings elect_only;

	Config() : ncandidates(0), totalvotes(0), tightbounds(false),
               compbounds(false), optlog(false), debug(false), allowties(false), test_all_losers(false) {}
};

class STVException
{
	private:
		const std::string message;

	public:
		STVException(const STVException &me) : message(me.what()){}
		STVException(const std::string &str) : message(str) {}
		const std::string& what() const { return message; }
};


struct Candidate
{
	std::string name;
	int index;
	double sum_votes;

	Ints ballots;

	std::string party;

	// For simulation
	int sim_votes;
	Ints sim_ballots;

	int standing;
    int operator==(const Candidate& right)const{
        return (index == right.index);
    }

	Candidate() : name("n/a"), index(0), sum_votes(0), party("IND"),
                  sim_votes(0), standing(1) {}
};

typedef std::vector<Candidate> Candidates;

struct Ballot
{
	int tag;
	double votes; // Number of votes present with this signature
	Ints prefs;

    int operator==(const Ballot& right)const{
        return (prefs == right.prefs);
    }
};

typedef std::vector<Ballot> Ballots;

template <typename T>
T ToType(const std::string &s);

typedef std::map<std::vector<int>,int> I2Map;

struct Node{
	// Score (or LP evaluation)
	double dist;

	// Elimination sequence (partial or total)
	Ints order_c;

	// Set of candidates *not* in elimination sequence
	SInts remcand;

	// The following three attributes used when solving LP
	// for this node.
	Ballots rev_ballots;
	I2Map ballotmap;
	Ints bid2newid;

	Node(int ncand, int nballots) {
		bid2newid.resize(nballots, -1);
		dist = -1;
	}

	void Reset(){
		dist = -1;

		rev_ballots.clear();
		ballotmap.clear();
		remcand.clear();

		for(int i = 0; i < bid2newid.size(); ++i){
			bid2newid[i] = -1;
		}
	}

	void ClearEqClassData(){
		rev_ballots.clear();
		ballotmap.clear();
	}
};


struct NMNode{  // NM abbreviates NonMono
    // Score (or LP evaluation)
    double dist;

    // Elimination sequence (partial or total), starts with first round, growing toward the last round
    // This is different from Node
    Ints elim_seq;

    // Set of candidates *not* in elimination sequence
    SInts remcand;

    // this variable has varying use: (1) index of the original IRV winner in promoting NM tests
    // (2) demotion candidate whom we want to win
    int reference_target;

    explicit NMNode(int _reference_target) {
        dist = -1;
        reference_target = _reference_target;
    }

    void Reset(){
        dist = -1;
        remcand.clear();
    }
};



bool ReadBallots(const char *path, Ballots &ballots,
	Candidates &candidates, Config &config);

#endif