Constraint.h

// Constraint.h -- The interface of the abstract super class of all
// CSP constraints.

/*
 * Copyright (C) 1997, 1998 Tudor Hulubei <tudor@hulubei.net>.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 *
 * This library 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA,
 * 02111-1307, USA.
 */

/*
 * NOTE: This is an interal header file.
 * You should not attempt to use it directly.
 */

// $Id: Constraint_8h-source.html,v 1.1 2005/05/25 12:37:18 tudor Exp $

#ifndef _CSP_KERNEL_Constraint_H
#define _CSP_KERNEL_Constraint_H


CSP_NAMESPACE_BEGIN(csp);


class CSP_API Constraint
{
  public:
    typedef FastVector<Variable*>::const_iterator variable_iterator;

    Constraint();

    virtual ~Constraint();

    variable_iterator add(Variable& variable)
    {
        return m_variables.insert(&variable);
    }

    void remove(Variable& variable, bool recursive = false);

    void setId(id_t id) { m_id = id; }

    id_t id() const { return m_id; }

    virtual wstring name() const;

    virtual wstring color() const { return L"black"; }

    virtual wstring textColor() const { return L"black"; }

    bool isActive() const { return m_active; }

    void activate() { assert(!isActive()); m_active = true; }

    void deactivate() { assert(isActive()); m_active = false; }

    bool isComplete() const
    {
        return m_instantiatedVariables == m_variables.size();
    }

    bool involves(const Variable& variable) const
    {
        return find(m_variables.begin(), m_variables.end(), &variable) !=
            m_variables.end();
    }

    Variable& pair(const Variable& variable) const
    {
        assert(variables() == 2);
        assert(m_variables[0]);
        assert(m_variables[1]);
        assert(m_variables[0] != m_variables[1]);
        assert(&variable == m_variables[0] || &variable == m_variables[1]);
        return (&variable == m_variables[0]) ?
            *m_variables[1] : *m_variables[0];
    }

    size_t variables() const { return m_variables.size(); }

    size_t order() const { return variables(); }

    const variable_iterator beginVariables() const
    {
        return m_variables.begin();
    }

    const variable_iterator endVariables() const
    {
        return m_variables.end();
    }

    const variable_iterator secondVariable() const
    {
        assert(order() >= 2);
        variable_iterator first = m_variables.begin();
        return ++first;
    }

    Variable& findVariable(bool instantiated = false) const;

    bool isSatisfied() const
    {
        if (!g_debugging) m_checks++;
        if (check()) return true;
        if (!g_debugging) m_failures++;
        return false;
    }

    /*
     * This method must be implemented by all constraint classes.  It
     * should check whether or not the constraint is satisfied by the
     * current assignments of its variables.  The implementation
     * should work if the variables involved have had their domain
     * reduced to a single value, regardless of wether they have been
     * instantiated or not.
     *
     * @return `true' if the constraint is satisfied, `false' otherwise.
     */
    virtual bool check() const = 0;

    virtual bool propagate(Variable& /*modifiedVariable*/) { return true; }

    bool tryOut(
        Variable& variable0,
        Value& value0,
        Variable& variable1,
        Value& value1) const;

    virtual ulonglong validTuples() const;

    ulonglong maxTuples() const;

    long double tightness() const
    {
        return 1 - static_cast<long double>(validTuples()) / maxTuples();
    }

    bool isLoose() const;

    virtual ulonglong invalidTuples() const
    {
        return maxTuples() - validTuples();
    }

    ulonglong checks() const { return m_checks; }

    ulonglong failures() const { return m_failures; }

    virtual void init() { m_checks = 0; m_failures = 0; m_weight = 0; }

    virtual void done() {}

    size_t instantiatedVariables() const { return m_instantiatedVariables; }

    size_t uninstantiatedVariables() const
    {
        return variables() - m_instantiatedVariables;
    }

    void inc() { m_instantiatedVariables++; }

    void dec() { m_instantiatedVariables--; }

    void incrementWeight() { m_weight++; }

    ulonglong weight() const { return m_weight; }

    virtual wostream& print(wostream& wos) const;

    friend CSP_API wostream& operator<<(
        wostream& wos, const Constraint& constraint)
    {
        return constraint.print(wos);
    }

  private:
    Constraint(const Constraint&);

    Constraint& operator=(const Constraint&);

    // The constraint's id.
    int m_id;

    // `true' if the constraint is active, `false' otherwise.
    bool m_active;

    // The variables involved in the constraint.
    FastVector<Variable*> m_variables;

    // The number of instantiated variables in `m_variables'.
    size_t m_instantiatedVariables;

    mutable ulonglong m_checks;

    mutable ulonglong m_failures;

    ulonglong m_weight;
};


CSP_NAMESPACE_END(csp);


#endif // _CSP_KERNEL_Constraint_H

// Local Variables:
// mode: C++
// End:

---