C++ (Cpp) Gaussian::init_mu_sigma Examples

Example #1

File: trueskill.cpp Project: JesseBuesking/trueskill

void TrueSkill::adjust_players(std::vector<Player*> players) {
    Constants constants;

    std::sort(players.begin(), players.end(), player_sorter());

    std::vector<Variable*> ss, ps, ts, ds;
    unsigned int i = 0, size = players.size();
    double gammasqr = constants.GAMMA * constants.GAMMA,
           betasqr = constants.BETA * constants.BETA;

    for (i = 0; i < size; ++i) {
        ss.push_back(new Variable());
        ps.push_back(new Variable());
        ts.push_back(new Variable());
    }

    for (i = 0; i < size - 1; ++i) {
        ds.push_back(new Variable());
    }

    std::vector<PriorFactor*> skill;
    for (i = 0; i < size; ++i) {
        Player* pl = players[i];
        Variable* s = ss[i];
        Gaussian* gaussian = new Gaussian();
        gaussian->init_mu_sigma(pl->mu, sqrt((pl->sigma * pl->sigma) + gammasqr));
        skill.push_back(new PriorFactor(s, gaussian));
    }

    std::vector<LikelihoodFactor*> skill_to_perf;
    for (i = 0; i < size; ++i) {
        Variable* s = ss[i];
        Variable* p = ps[i];
        skill_to_perf.push_back(new LikelihoodFactor(s, p, betasqr));
    }

    std::vector<SumFactor*> perf_to_team;
    for (i = 0; i < size; ++i) {
        std::vector<Variable*>* p = new std::vector<Variable*>();
        std::vector<double>* c = new std::vector<double>;
        p->push_back(ps[i]);
        c->push_back(1.0);
        perf_to_team.push_back(new SumFactor(ts[i], p, c));
    }

    std::vector<SumFactor*> team_diff;
    for (i = 0; i < size - 1; ++i) {
        std::vector<Variable*>* p = new std::vector<Variable*>();
        p->push_back(ts[i]);
        p->push_back(ts[i + 1]);
        std::vector<double>* c = new std::vector<double>;
        c->push_back(1.0);
        c->push_back(-1.0);
        team_diff.push_back(new SumFactor(ds[i], p, c));
    }

    std::vector<TruncateFactor*> trunc;
    for (i = 0; i < size - 1; ++i) {
        TruncateFactor* tf;
        if (players[i]->rank == players[i + 1]->rank) {
            tf = new TruncateFactorDraw(ds[i], constants.EPSILON);
        } else {
            tf = new TruncateFactorWin(ds[i], constants.EPSILON);
        }
        trunc.push_back(tf);
    }

    for(std::vector<PriorFactor*>::iterator it = skill.begin(); it != skill.end(); ++it) {
        (*it)->start();
    }

    for(std::vector<LikelihoodFactor*>::iterator it = skill_to_perf.begin(); it != skill_to_perf.end(); ++it) {
        (*it)->update_value();
    }

    for(std::vector<SumFactor*>::iterator it = perf_to_team.begin(); it != perf_to_team.end(); ++it) {
        (*it)->update_sum();
    }

    for (i = 0; i < 5; ++i) {
        for(std::vector<SumFactor*>::iterator it = team_diff.begin(); it != team_diff.end(); ++it) {
            (*it)->update_sum();
        }

        for(std::vector<TruncateFactor*>::iterator it = trunc.begin(); it != trunc.end(); ++it) {
            (*it)->update();
        }

        for(std::vector<SumFactor*>::iterator it = team_diff.begin(); it != team_diff.end(); ++it) {
            (*it)->update_term(0);
            (*it)->update_term(1);
        }
    }

    for(std::vector<SumFactor*>::iterator it = perf_to_team.begin(); it != perf_to_team.end(); ++it) {
        (*it)->update_term(0);
    }

    for(std::vector<LikelihoodFactor*>::iterator it = skill_to_perf.begin(); it != skill_to_perf.end(); ++it) {
        (*it)->update_mean();
    }

    for (i = 0; i < size; ++i) {
        players[i]->mu = ss[i]->value->get_mu();
        players[i]->sigma = ss[i]->value->get_sigma();
    }

    while(!skill.empty()) {
        delete skill.back();
        skill.pop_back();
    }

    while(!skill_to_perf.empty()) {
        delete skill_to_perf.back();
        skill_to_perf.pop_back();
    }

    while(!perf_to_team.empty()) {
        delete perf_to_team.back();
        perf_to_team.pop_back();
    }

    while(!team_diff.empty()) {
        delete team_diff.back();
        team_diff.pop_back();
    }

    while(!trunc.empty()) {
        delete trunc.back();
        trunc.pop_back();
    }

    while(!ss.empty()) {
        delete ss.back();
        ss.pop_back();
    }

    while(!ts.empty()) {
        delete ts.back();
        ts.pop_back();
    }

    while(!ds.empty()) {
        delete ds.back();
        ds.pop_back();
    }

    while(!ps.empty()) {
        delete ps.back();
        ps.pop_back();
    }
}