drwnVarAssignment.h

Go to the documentation of this file.

/******************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2017, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnVarAssignment.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
** DESCRIPTION:
**  Data structures for encoding assignments to variables.
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <cassert>
#include <vector>
#include <map>

#include "drwnGraphUtils.h"
#include "drwnVarUniverse.h"

using namespace std;

// drwnFullAssignment ------------------------------------------------------

typedef std::vector<int> drwnFullAssignment;

// drwnLocalAssignment -----------------------------------------------------

typedef std::vector<int> drwnLocalAssignment;

// drwnPartialAssignment ---------------------------------------------------

class drwnPartialAssignment : public std::map<int, int> {
 public:
    drwnPartialAssignment() { /* do nothing */ }
    explicit drwnPartialAssignment(const drwnFullAssignment& a) {
        for (int i = 0; i < (int)a.size(); i++) {
            if (a[i] >= 0) {
                this->insert(make_pair(i, a[i]));
            }
        }
    }

    drwnPartialAssignment(const drwnFullAssignment& a, const drwnClique& c) {
        for (drwnClique::const_iterator it = c.begin(); it != c.end(); ++it) {
            if (a[*it] >= 0) {
                this->insert(make_pair(*it, a[*it]));
            }
        }
    }

    drwnPartialAssignment(const vector<int>& vars, const drwnLocalAssignment& vals) {
        for (size_t i = 0; i < vars.size(); i++) {
            this->insert(make_pair(vars[i], vals[i]));
        }
    }

    drwnClique getClique() const {
        drwnClique c;
        for (const_iterator it = begin(); it != end(); ++it) {
            c.insert(it->first);
        }
        return c;
    }

    drwnLocalAssignment toLocalAssignment(const vector<int>& vars) const {
        drwnLocalAssignment a(vars.size());
        for (size_t i = 0; i < vars.size(); i++) {
            const_iterator it = this->find(vars[i]);
            a[i] = (it == end()) ? -1 : it->second;
        }
        return a;
    }

    drwnFullAssignment toFullAssignment() const {
        return drwnFullAssignment(*this);
    }

    operator drwnFullAssignment() const {
        drwnFullAssignment a(this->rbegin()->first + 1, -1);
        for (const_iterator it = begin(); it != end(); ++it) {
            a[it->first] = it->second;
        }
        return a;
    }
};

// utility functions -------------------------------------------------------

void successor(drwnFullAssignment& assignment, const drwnVarUniverse& universe);
void predecessor(drwnFullAssignment& assignment, const drwnVarUniverse& universe);
void successor(drwnPartialAssignment& assignment, const drwnVarUniverse& universe);
void predecessor(drwnPartialAssignment& assignment, const drwnVarUniverse& universe);