path: root/impl/MaxStrategy.hpp

#ifndef MAX_EXPRESSION_HPP
#define MAX_EXPRESSION_HPP

#include <ostream>
#include "Expression.hpp"
#include "EquationSystem.hpp"
#include "IdSet.hpp"

template<typename Domain>
struct MaxStrategy {
  virtual ~MaxStrategy() { }
  virtual unsigned int get(const MaxExpression<Domain>& e) const = 0;
  virtual unsigned int get(const MaxExpression<Domain>& e) {
    return const_cast<const MaxStrategy*>(this)->get(e);
  }
};

unsigned int stack_depth = 1;

std::string indent() {
  std::string result = "";
  for (unsigned int i = 0; i < stack_depth; ++i) {
    result += '\t';
  }
  return result;
}

#include "VariableAssignment.hpp"

template<typename Domain>
struct DynamicVariableAssignment;

template<typename Domain>
struct DynamicMaxStrategy : public MaxStrategy<Domain> {
  DynamicMaxStrategy(
    const EquationSystem<Domain>& system
  ) : _frozen(false),
      _system(system),
      _rho(NULL),
      _values(system.maxExpressionCount(), 0),
      _stable(system.maxExpressionCount()),
      _influence(system.maxExpressionCount(),
                 IdSet<MaxExpression<Domain> >(system.maxExpressionCount())),
      _var_influence(system.variableCount(),
                     IdSet<MaxExpression<Domain> >(system.maxExpressionCount())),
      _frozen(false)
  {}

  void freeze() {
    _frozen = true;
  }

  void thaw() {
    _frozen = false;
  }

  bool is_frozen() {
    return _frozen;
  }

  void setRho(DynamicVariableAssignment<Domain>& rho) {
    _rho = &rho;
  }

  unsigned int get(const MaxExpression<Domain>& e) const {
    if (!_frozen)
      solve(e);
    return _values[e];
  }

  void invalidate(const Variable<Domain>& v) const {
    log::strategy << indent() << "Invalidating " << v << " - " << *_system[v] << std::endl;
    if (_system[v] && _stable.contains(*_system[v])) {
      _stable.remove(*_system[v]);
      _stable.filter(_var_influence[v]);
      
      IdSet<MaxExpression<Domain> > infl = _var_influence[v];
      _var_influence[v].clear();
      for (typename IdSet<MaxExpression<Domain> >::iterator
             it = infl.begin(),
             end = infl.end();
           it != end;
           ++it) {
        solve(_system.maxExpression(*it));
      }
    }
  }

private:
  void solve(const MaxExpression<Domain>& x) {
    if (!_stable.contains(x)) {
      _stable.insert(x);
      log::strategy << indent() << "Stabilise " << x << std::endl;

      stack_depth++;
      unsigned int val = x.bestStrategy(DependencyAssignment(*this, *_rho, x),
                                        DependencyStrategy(*this, x));
      stack_depth--;

      if (val != _values[x]) {

        log::strategy << x << " => " << *x.arguments()[val] << std::endl;

        IdSet<MaxExpression<Domain> > oldInfluence = _influence[x];
        _influence[x].clear();
        _values[x] = val;

        _rho->invalidate(*_system.varFromExpr(x));

        _stable.filter(oldInfluence);

        for (typename IdSet<MaxExpression<Domain> >::iterator
               it = oldInfluence.begin(),
               end = oldInfluence.end();
             it != end;
             ++it) {
          solve(_system.maxExpression(*it));
        }
      } else {
        log::strategy << indent() << x << " did not change: "
		      << x << " => " << *x.arguments()[val] << std::endl;
      }
    } else {
      log::strategy << indent() << x << " is stable: "
		    << x << " => " << *x.arguments()[_values[x]] << std::endl;
    }
  }

  const DynamicMaxStrategy& freeze() const {
    _frozen = true;
    return *this;
  }

  const DynamicMaxStrategy& thaw() const {
    _frozen = false;
    return *this;
  }

  struct DependencyAssignment : public VariableAssignment<Domain>{
    DependencyAssignment(DynamicMaxStrategy& strat,
                         VariableAssignment<Domain>& rho,
                         const MaxExpression<Domain>& expr)
      : _strat(strat),
        _rho(rho),
        _expr(expr) {
    }
    const Domain& operator[](const Variable<Domain>& var) const {
      _strat._var_influence[var].insert(_expr);
      return _rho[var];
    }
  private:
    DynamicMaxStrategy& _strat;
    VariableAssignment<Domain>& _rho;
    const MaxExpression<Domain>& _expr;
  };

  struct InvalidatingAssignment : public VariableAssignment<Domain>{
    InvalidatingAssignment(DynamicVariableAssignment<Domain>& rho)
      : _rho(rho) {
    }
    ~InvalidatingAssignment() {
      for (typename std::set<const Variable<Domain>*>::iterator
             it = seen.begin(),
             ei = seen.end();
           it != ei;
           ++it) {
        if (!_old_stable.contains(**it))
          _rho.invalidate(**it);
      }
    }
    const Domain& operator[](const Variable<Domain>& var) const {
      seen.insert(&var);
      return _rho[var];
    }
  private:
    DynamicVariableAssignment<Domain>& _rho;
    IdSet<Variable<Domain> > _old_stable;
    mutable std::set<const Variable<Domain>*> seen;
  };

  struct DependencyStrategy : public MaxStrategy<Domain> {
    DependencyStrategy(DynamicMaxStrategy& strat, const MaxExpression<Domain>& expr)
      : _strat(strat),
        _expr(expr) {
    }
    unsigned int get(const MaxExpression<Domain>& e) const {
      _strat.solve(e);
      if (&_expr != &e) {
        _strat._influence[e].insert(_expr);
      }
      return _strat._values[e];
    }
  private:
    DynamicMaxStrategy& _strat;
    const MaxExpression<Domain>& _expr;
  };

private:
  mutable bool _frozen;
  const EquationSystem<Domain>& _system;
  DynamicVariableAssignment<Domain>* _rho;
  IdMap<MaxExpression<Domain>,unsigned int> _values;
  IdSet<MaxExpression<Domain> > _stable;
  IdMap<MaxExpression<Domain>,IdSet<MaxExpression<Domain> > > _influence;
  IdMap<Variable<Domain>,IdSet<MaxExpression<Domain> > > _var_influence;
  bool _frozen;
};


template<typename T>
IdMap<Variable<T>,T> solve_for(const EquationSystem<T>& system) {
  IdMap<Variable<T>,T> result(system.variableCount(), infinity<T>());

  DynamicMaxStrategy<T> strategy(system);
  DynamicVariableAssignment<T> rho(system, strategy, -infinity<T>());
  strategy.setRho(rho);

  bool changed;
  do {
    changed = false;

    // improve strategy
    rho.freeze();
    strategy.thaw();
    for (unsigned int i = 0; i < system.variableCount(); ++i) {
      strategy.get(*system[system.variable(i)]);
    }

    // iterate fixpoint
    strategy.freeze();
    rho.thaw();
    for (unsigned int i = 0; i < system.variableCount(); ++i) {
      Variable<T>& var = system.variable(i);
      T val = rho[var];
      if (result[var] != val) {
	result[var] = val;
	changed = true;
      }
    }
  } while(changed);

  return result;
}


/*template<typename Domain>
std::ostream& operator<<(std::ostream& cout, const MaxStrategy<Domain>& strat) {
  strat.print(cout);
  return cout;
}*/

#endif